internal Type GetParameterType(IGenericBinder binder, int index)
		{
			return parameterTypes[index].BindTypeParameters(binder);
		}

		internal Type[] GetReturnTypeOptionalCustomModifiers(IGenericBinder binder)
		{
			return BindTypeParameters(binder, modifiers, 0, 0);
		}

		internal Type[] GetReturnTypeRequiredCustomModifiers(IGenericBinder binder)
		{
			return BindTypeParameters(binder, modifiers, 0, 1);
		}

		private static Type[] BindArray(Type[] array, IGenericBinder binder)
		{
			if (array ==null || array.Length == 0)
			{
				return array;
			}
			Type[] result = array;
			for (int i = 0; i < array.Length; i++)
			{
				Type type = array[i].BindTypeParameters(binder);
				if (!ReferenceEquals(type, array[i]))
				{
					if (result == array)
					{
						result = (Type[])array.Clone();
					}
					result[i] = type;
				}
			}
			return result;
		}

		internal sealed override Type BindTypeParameters(IGenericBinder binder)
		{
			Type type = elementType.BindTypeParameters(binder);
			CustomModifiers mods = this.mods.Bind(binder);
			if (ReferenceEquals(type, elementType)
				&& mods.Equals(this.mods))
			{
				return this;
			}
			return Wrap(type, mods);
		}

		internal static void InplaceBindTypeParameters(IGenericBinder binder, Type[] types)
		{
			for (int i = 0; i < types.Length; i++)
			{
				types[i] = types[i].BindTypeParameters(binder);
			}
		}

		internal CustomModifiers GetParameterCustomModifiers(IGenericBinder binder, int index)
		{
			return modifiers.GetParameterCustomModifiers(index).Bind(binder);
		}

		internal PackedCustomModifiers Bind(IGenericBinder binder)
		{
			if (customModifiers == null)
			{
				return new PackedCustomModifiers();
			}
			CustomModifiers[] expanded = new CustomModifiers[customModifiers.Length];
			for (int i = 0; i < customModifiers.Length; i++)
			{
				expanded[i] = customModifiers[i].Bind(binder);
			}
			return new PackedCustomModifiers(expanded);
		}

		protected static Type[] BindTypeParameters(IGenericBinder binder, Type[][][] types, int index, int optOrReq)
		{
			if (types == null || types[index] == null)
			{
				return null;
			}
			return BindTypeParameters(binder, types[index][optOrReq]);
		}

		internal CustomModifiers GetReturnTypeCustomModifiers(IGenericBinder binder)
		{
			return modifiers.GetReturnTypeCustomModifiers().Bind(binder);
		}

		internal override Type BindTypeParameters(IGenericBinder binder)
		{
			int owner = module.GenericParam.records[index].Owner;
			if ((owner >> 24) == MethodDefTable.Index)
			{
				return binder.BindMethodParameter(this);
			}
			else
			{
				return binder.BindTypeParameter(this);
			}
		}

		internal Type[] GetParameterOptionalCustomModifiers(IGenericBinder binder, int index)
		{
			return BindTypeParameters(binder, modifiers, index + 1, 0);
		}

		protected static Type[] BindTypeParameters(IGenericBinder binder, Type[] types)
		{
			if (types == null || types.Length == 0)
			{
				return Type.EmptyTypes;
			}
			Type[] expanded = new Type[types.Length];
			for (int i = 0; i < types.Length; i++)
			{
				expanded[i] = types[i].BindTypeParameters(binder);
			}
			return expanded;
		}

		internal Type[] GetParameterRequiredCustomModifiers(IGenericBinder binder, int index)
		{
			return BindTypeParameters(binder, modifiers, index + 1, 1);
		}

		internal override Type BindTypeParameters(IGenericBinder binder)
		{
			return this;
		}

		internal virtual Type BindTypeParameters(IGenericBinder binder)
		{
			if (IsGenericTypeDefinition)
			{
				Type[] args = GetGenericArguments();
				Type.InplaceBindTypeParameters(binder, args);
				return GenericTypeInstance.Make(this, args, null, null);
			}
			else
			{
				return this;
			}
		}

		internal Type GetReturnType(IGenericBinder binder)
		{
			return returnType.BindTypeParameters(binder);
		}

		internal Type GetReturnType(IGenericBinder binder)
		{
            if (binder == null)
                return returnType;

			return returnType.BindTypeParameters(binder);
		}