internal LocalVariableInfo(int index, Type type, bool pinned, CustomModifiers customModifiers)
		{
			this.index = index;
			this.type = type;
			this.pinned = pinned;
			this.customModifiers = customModifiers;
		}

 public void SetSignature(Type returnType, CustomModifiers returnTypeCustomModifiers, Type[] parameterTypes, CustomModifiers[] parameterTypeCustomModifiers)
 {
     method.signature = new MethodSignature(
         returnType ?? method.Module.universe.System_Void,
         Util.Copy(parameterTypes),
         PackedCustomModifiers.CreateFromExternal(returnTypeCustomModifiers, parameterTypeCustomModifiers, parameterTypes.Length),
         method.signature.CallingConvention,
         method.signature.GenericParameterCount);
 }

		internal FieldBuilder(TypeBuilder type, string name, Type fieldType, CustomModifiers customModifiers, FieldAttributes attribs)
		{
			this.typeBuilder = type;
			this.name = name;
			this.pseudoToken = type.ModuleBuilder.AllocPseudoToken();
			this.nameIndex = type.ModuleBuilder.Strings.Add(name);
			this.fieldSig = FieldSignature.Create(fieldType, customModifiers);
			ByteBuffer sig = new ByteBuffer(5);
			fieldSig.WriteSig(this.typeBuilder.ModuleBuilder, sig);
			this.signature = this.typeBuilder.ModuleBuilder.Blobs.Add(sig);
			this.attribs = attribs;
			this.typeBuilder.ModuleBuilder.Field.AddVirtualRecord();
		}

 internal static PackedCustomModifiers CreateFromExternal(CustomModifiers returnTypeCustomModifiers, CustomModifiers[] parameterTypeCustomModifiers, int parameterCount)
 {
     CustomModifiers[] customModifiers = null;
     Pack(ref customModifiers, 0, returnTypeCustomModifiers, parameterCount + 1);
     if (parameterTypeCustomModifiers != null)
     {
         for (int i = 0; i < parameterCount; i++)
         {
             Pack(ref customModifiers, i + 1, parameterTypeCustomModifiers[i], parameterCount + 1);
         }
     }
     return new PackedCustomModifiers(customModifiers);
 }

			public override void __AddArgument(Type argument, bool pinned, CustomModifiers customModifiers)
			{
				if (pinned)
				{
					args.Add(MarkerType.Pinned);
				}
				foreach (CustomModifiers.Entry mod in customModifiers)
				{
					args.Add(mod.IsRequired ? MarkerType.ModReq : MarkerType.ModOpt);
					args.Add(mod.Type);
				}
				args.Add(argument);
				paramCount++;
			}

		public abstract Type[] __ResolveOptionalParameterTypes(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments, out CustomModifiers[] customModifiers);

		private static CustomModifiers ReadCustomModifiers(ModuleReader module, ByteReader br, IGenericContext context)
		{
			CustomModifiers mods = new CustomModifiers();
			byte b = br.PeekByte();
			if (IsCustomModifier(b))
			{
				List<Type> required = new List<Type>();
				List<Type> optional = new List<Type>();
				while (IsCustomModifier(b))
				{
					bool req = br.ReadByte() == ELEMENT_TYPE_CMOD_REQD;
					Type type = ReadTypeDefOrRefEncoded(module, br, context);
					(req ? required : optional).Add(type);
					b = br.PeekByte();
				}
				mods.required = required.ToArray();
				mods.optional = optional.ToArray();
			}
			return mods;
		}

 public void __SetSignature(Type returnType, CustomModifiers returnTypeCustomModifiers, Type[] parameterTypes, CustomModifiers[] parameterTypeCustomModifiers)
 {
     SetSignature(returnType, parameterTypes, PackedCustomModifiers.CreateFromExternal(returnTypeCustomModifiers, parameterTypeCustomModifiers, Util.NullSafeLength(parameterTypes)));
 }

		protected override Type Wrap(Type type, CustomModifiers mods)
		{
			return Make(type, mods);
		}

		protected static void WriteCustomModifiers(ModuleBuilder module, ByteBuffer bb, CustomModifiers modifiers)
		{
			foreach (CustomModifiers.Entry entry in modifiers)
			{
				bb.Write(entry.IsRequired ? ELEMENT_TYPE_CMOD_REQD : ELEMENT_TYPE_CMOD_OPT);
				bb.WriteTypeDefOrRefEncoded(module.GetTypeTokenForMemberRef(entry.Type));
			}
		}

		internal static PackedCustomModifiers Wrap(CustomModifiers[] modifiers)
		{
			return new PackedCustomModifiers(modifiers);
		}

		private PackedCustomModifiers(CustomModifiers[] customModifiers)
		{
			this.customModifiers = customModifiers;
		}

		private FieldSignature(Type fieldType, CustomModifiers mods)
		{
			this.fieldType = fieldType;
			this.mods = mods;
		}

		internal static FieldSignature Create(Type fieldType, CustomModifiers customModifiers)
		{
			return new FieldSignature(fieldType, customModifiers);
		}

		private GenericTypeInstance(Type type, Type[] args, CustomModifiers[] mods)
		{
			this.type = type;
			this.args = args;
			this.mods = mods;
		}

		private static bool IsEmpty(CustomModifiers[] mods, int i)
		{
			// we need to be extra careful, because mods doesn't not need to be in canonical format
			// (Signature.ReadGenericInst() calls Make() directly, without copying the modifier arrays)
			return mods == null || mods[i].IsEmpty;
		}

		internal static Type Make(Type type, Type[] typeArguments, CustomModifiers[] mods)
		{
			bool identity = true;
			if (type is TypeBuilder || type is BakedType || type.__IsMissing)
			{
				// a TypeBuiler identity must be instantiated
				identity = false;
			}
			else
			{
				// we must not instantiate the identity instance, because typeof(Foo<>).MakeGenericType(typeof(Foo<>).GetGenericArguments()) == typeof(Foo<>)
				for (int i = 0; i < typeArguments.Length; i++)
				{
					if (typeArguments[i] != type.GetGenericTypeArgument(i)
						|| !IsEmpty(mods, i))
					{
						identity = false;
						break;
					}
				}
			}
			if (identity)
			{
				return type;
			}
			else
			{
				return type.Universe.CanonicalizeType(new GenericTypeInstance(type, typeArguments, mods));
			}
		}

		internal void WriteMethodRefSig(ModuleBuilder module, ByteBuffer bb, Type[] optionalParameterTypes, CustomModifiers[] customModifiers)
		{
			WriteSigImpl(module, bb, parameterTypes.Length + optionalParameterTypes.Length);
			if (optionalParameterTypes.Length > 0)
			{
				bb.Write(SENTINEL);
				for (int i = 0; i < optionalParameterTypes.Length; i++)
				{
					WriteCustomModifiers(module, bb, Util.NullSafeElementAt(customModifiers, i));
					WriteType(module, bb, optionalParameterTypes[i]);
				}
			}
		}

		internal LocalVariableInfo(int index, Type type, bool pinned, CustomModifiers customModifiers)
			: this(index, type, pinned)
		{
			this.customModifiers = customModifiers;
		}

		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);
		}