Imported Upstream version 5.0.0.42

Former-commit-id: fd56571888259555122d8a0f58c68838229cea2b

mcs/class/corlib/System.Reflection.Emit/AssemblyBuilder.cs

@@ -468,7 +468,12 @@ namespace System.Reflection.Emit
 
 		public static AssemblyBuilder DefineDynamicAssembly (AssemblyName name, AssemblyBuilderAccess access, IEnumerable<CustomAttributeBuilder> assemblyAttributes)
 		{
-			throw new NotImplementedException ();
+			var ab = DefineDynamicAssembly (name, access);
+			foreach (var attr in  assemblyAttributes) {
+				ab.SetCustomAttribute (attr);
+			}
+
+			return ab;
 		}
 
 		public ModuleBuilder DefineDynamicModule (string name)
@@ -1046,7 +1051,7 @@ namespace System.Reflection.Emit
 		/*Warning, @typeArguments must be a mscorlib internal array. So make a copy before passing it in*/
 		internal Type MakeGenericType (Type gtd, Type[] typeArguments)
 		{
-			return new MonoGenericClass (gtd, typeArguments);
+			return new TypeBuilderInstantiation (gtd, typeArguments);
 		}
 
 		void _AssemblyBuilder.GetIDsOfNames([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)

mcs/class/corlib/System.Reflection.Emit/ConstructorBuilder.cs

@@ -145,7 +145,11 @@ namespace System.Reflection.Emit {
 		internal override Type GetParameterType (int pos) {
 			return parameters [pos];
 		}
-		
+
+		internal MethodBase RuntimeResolve () {
+			return type.RuntimeResolve ().GetConstructor (this);
+		}
+
 		public override Object Invoke (Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
 		{
 			throw not_supported ();
@@ -372,6 +376,11 @@ namespace System.Reflection.Emit {
 					TypeBuilder.ResolveUserTypes (types);
 			}
 		}
+
+		internal void FixupTokens (Dictionary<int, int> token_map, Dictionary<int, MemberInfo> member_map) {
+			if (ilgen != null)
+				ilgen.FixupTokens (token_map, member_map);
+		}
 		
 		internal void GenerateDebugInfo (ISymbolWriter symbolWriter)
 		{

mcs/class/corlib/System.Reflection.Emit/ConstructorOnTypeBuilderInst.cs

@@ -42,11 +42,11 @@ namespace System.Reflection.Emit
 	internal class ConstructorOnTypeBuilderInst : ConstructorInfo
 	{
 		#region Keep in sync with object-internals.h
-		MonoGenericClass instantiation;
-		ConstructorInfo cb;
+		internal TypeBuilderInstantiation instantiation;
+		internal ConstructorInfo cb;
 		#endregion
 
-		public ConstructorOnTypeBuilderInst (MonoGenericClass instantiation, ConstructorInfo cb)
+		public ConstructorOnTypeBuilderInst (TypeBuilderInstantiation instantiation, ConstructorInfo cb)
 		{
 			this.instantiation = instantiation;
 			this.cb = cb;
@@ -134,6 +134,25 @@ namespace System.Reflection.Emit
 			return res;
 		}
 
+		internal override Type[] GetParameterTypes () {
+			if (cb is ConstructorBuilder) {
+				return (cb as ConstructorBuilder).parameters;
+			} else {
+				ParameterInfo[] parms = cb.GetParameters ();
+				var res = new Type [parms.Length];
+				for (int i = 0; i < parms.Length; i++) {
+					res [i] = parms [i].ParameterType;
+				}
+				return res;
+			}
+		}
+
+		// Called from the runtime to return the corresponding finished ConstructorInfo object
+		internal ConstructorInfo RuntimeResolve () {
+			var type = instantiation.InternalResolve ();
+			return type.GetConstructor (cb);
+		}
+
 		public override int MetadataToken {
 			get {
 				return base.MetadataToken;

mcs/class/corlib/System.Reflection.Emit/DerivedTypes.cs

@@ -45,9 +45,6 @@ namespace System.Reflection.Emit
 	{
 		internal Type m_baseType;
 
-		[MethodImplAttribute(MethodImplOptions.InternalCall)]
-		static extern void create_unmanaged_type (Type type);
-
 		internal SymbolType (Type elementType)
 		{
 			this.m_baseType = elementType;
@@ -121,7 +118,6 @@ namespace System.Reflection.Emit
 	
 		public override Type UnderlyingSystemType {
 			get {
-				create_unmanaged_type (this);
 				return this;
 			}
 		}
@@ -131,6 +127,11 @@ namespace System.Reflection.Emit
 				return m_baseType.IsUserType;
 			}
 		}
+
+		// Called from the runtime to return the corresponding finished Type object
+		internal override Type RuntimeResolve () {
+			return InternalResolve ();
+		}
 	}
 
 	[StructLayout (LayoutKind.Sequential)]
@@ -150,9 +151,17 @@ namespace System.Reflection.Emit
 
 		internal override Type InternalResolve ()
 		{
-			Type et = m_baseType.InternalResolve (); 
+			Type et = m_baseType.InternalResolve ();
 			if (rank == 0)
-				return et.MakeArrayType ();			
+				return et.MakeArrayType ();
+			return et.MakeArrayType (rank);
+		}
+
+		internal override Type RuntimeResolve ()
+		{
+			Type et = m_baseType.RuntimeResolve ();
+			if (rank == 0)
+				return et.MakeArrayType ();
 			return et.MakeArrayType (rank);
 		}
 

mcs/class/corlib/System.Reflection.Emit/EventOnTypeBuilderInst.cs

@@ -42,17 +42,17 @@ namespace System.Reflection.Emit
 	[StructLayout (LayoutKind.Sequential)]
 	internal class EventOnTypeBuilderInst : EventInfo
 	{
-		MonoGenericClass instantiation;
+		TypeBuilderInstantiation instantiation;
 		EventBuilder event_builder;
 		EventInfo event_info;
 
-		internal EventOnTypeBuilderInst (MonoGenericClass instantiation, EventBuilder evt)
+		internal EventOnTypeBuilderInst (TypeBuilderInstantiation instantiation, EventBuilder evt)
 		{
 			this.instantiation = instantiation;
 			this.event_builder = evt;
 		}
 
-		internal EventOnTypeBuilderInst (MonoGenericClass instantiation, EventInfo evt)
+		internal EventOnTypeBuilderInst (TypeBuilderInstantiation instantiation, EventInfo evt)
 		{
 			this.instantiation = instantiation;
 			this.event_info = evt;

mcs/class/corlib/System.Reflection.Emit/FieldBuilder.cs

@@ -228,6 +228,10 @@ namespace System.Reflection.Emit {
 				marshal_info.marshaltyperef = TypeBuilder.ResolveUserType (marshal_info.marshaltyperef);
 		}
 
+		internal FieldInfo RuntimeResolve () {
+			return typeb.CreateType ().GetField (this);
+		}
+
 		public override Module Module {
 			get {
 				return base.Module;

mcs/class/corlib/System.Reflection.Emit/FieldOnTypeBuilderInst.cs

@@ -42,11 +42,11 @@ namespace System.Reflection.Emit
 	internal class FieldOnTypeBuilderInst : FieldInfo
 	{
 		#region Keep in sync with object-internals.h
-		internal MonoGenericClass instantiation;
+		internal TypeBuilderInstantiation instantiation;
 		internal FieldInfo fb;
 		#endregion
 
-		public FieldOnTypeBuilderInst (MonoGenericClass instantiation, FieldInfo fb) {
+		public FieldOnTypeBuilderInst (TypeBuilderInstantiation instantiation, FieldInfo fb) {
 			this.instantiation = instantiation;
 			this.fb = fb;
 		}
@@ -127,6 +127,12 @@ namespace System.Reflection.Emit
 		public override void SetValue (object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture) {
 			throw new NotSupportedException ();
 		}
+
+		// Called from the runtime to return the corresponding finished FieldInfo object
+		internal FieldInfo RuntimeResolve () {
+			var type = instantiation.RuntimeResolve ();
+			return type.GetField (fb);
+		}
 	}
 }
 #endif

mcs/class/corlib/System.Reflection.Emit/GenericTypeParameterBuilder.cs

@@ -82,17 +82,21 @@ namespace System.Reflection.Emit
 			this.mbuilder = mbuilder;
 			this.name = name;
 			this.index = index;
-
-			initialize ();
 		}
 
 		internal override Type InternalResolve ()
 		{
-			return tbuilder.InternalResolve ().GetGenericArguments () [index]; 
+			if (mbuilder != null)
+				return MethodBase.GetMethodFromHandle (mbuilder.MethodHandleInternal).GetGenericArguments () [index];
+			return tbuilder.InternalResolve ().GetGenericArguments () [index];
 		}
 
-		[MethodImplAttribute(MethodImplOptions.InternalCall)]
-		private extern void initialize ();
+		internal override Type RuntimeResolve ()
+		{
+			if (mbuilder != null)
+				return MethodBase.GetMethodFromHandle (mbuilder.MethodHandleInternal, mbuilder.TypeBuilder.RuntimeResolve ().TypeHandle).GetGenericArguments () [index];
+			return tbuilder.RuntimeResolve ().GetGenericArguments () [index];
+		}
 
 		[ComVisible (true)]
 		public override bool IsSubclassOf (Type c)

mcs/class/corlib/System.Reflection.Emit/ILGenerator.cs

@@ -521,7 +521,7 @@ namespace System.Reflection.Emit {
 			int token = token_gen.GetToken (con, true);
 			make_room (6);
 			ll_emit (opcode);
-			if (con.DeclaringType.Module == module)
+			if (con.DeclaringType.Module == module || (con is ConstructorOnTypeBuilderInst) || (con is ConstructorBuilder))
 				add_token_fixup (con);
 			emit_int (token);
 			
@@ -554,7 +554,7 @@ namespace System.Reflection.Emit {
 			int token = token_gen.GetToken (field, true);
 			make_room (6);
 			ll_emit (opcode);
-			if (field.DeclaringType.Module == module)
+			if (field.DeclaringType.Module == module || (field is FieldOnTypeBuilderInst) || (field is FieldBuilder))
 				add_token_fixup (field);
 			emit_int (token);
 		}
@@ -737,7 +737,7 @@ namespace System.Reflection.Emit {
 			Type declaringType = meth.DeclaringType;
 			// Might be a DynamicMethod with no declaring type
 			if (declaringType != null) {
-				if (declaringType.Module == module)
+				if (declaringType.Module == module || meth is MethodOnTypeBuilderInst || meth is MethodBuilder)
 					add_token_fixup (meth);
 			}
 			emit_int (token);
@@ -755,7 +755,7 @@ namespace System.Reflection.Emit {
 			// Might be a DynamicMethod with no declaring type
 			Type declaringType = method.DeclaringType;
 			if (declaringType != null) {
-				if (declaringType.Module == module)
+				if (declaringType.Module == module || method is MethodBuilder)
 					add_token_fixup (method);
 			}
 			emit_int (token);
@@ -813,7 +813,10 @@ namespace System.Reflection.Emit {
 
 			make_room (6);
 			ll_emit (opcode);
-			emit_int (token_gen.GetToken (cls, opcode != OpCodes.Ldtoken));
+			int token = token_gen.GetToken (cls, opcode != OpCodes.Ldtoken);
+			if (cls is TypeBuilderInstantiation || cls is SymbolType || cls is TypeBuilder || cls is GenericTypeParameterBuilder)
+				add_token_fixup (cls);
+			emit_int (token);
 		}
 
 		[MonoLimitation ("vararg methods are not supported")]
@@ -1007,6 +1010,21 @@ namespace System.Reflection.Emit {
 			}
 		}
 
+		internal void FixupTokens (Dictionary<int, int> token_map, Dictionary<int, MemberInfo> member_map) {
+			for (int i = 0; i < num_token_fixups; ++i) {
+				int pos = token_fixups [i].code_pos;
+				int old_token = code [pos] | (code [pos + 1] << 8) | (code [pos + 2] << 16) | (code [pos + 3] << 24);
+				int new_token;
+				if (token_map.TryGetValue (old_token, out new_token)) {
+					token_fixups [i].member = member_map [old_token];
+					int old_cl = code_len;
+					code_len = pos;
+					emit_int (new_token);
+					code_len = old_cl;
+				}
+			}
+		}
+
 		// Used by MethodBuilder.SetMethodBody
 		internal void SetExceptionHandlers (ILExceptionInfo[] exHandlers) {
 			this.ex_handlers = exHandlers;

mcs/class/corlib/System.Reflection.Emit/MethodBuilder.cs

@@ -138,6 +138,12 @@ namespace System.Reflection.Emit
 			}
 		}
 
+		internal RuntimeMethodHandle MethodHandleInternal {
+			get {
+				return mhandle;
+			}
+		}
+
 		public override Type ReturnType {
 			get { return rtype; }
 		}
@@ -248,6 +254,10 @@ namespace System.Reflection.Emit
 			return parameters [pos];
 		}
 
+		internal MethodBase RuntimeResolve () {
+			return type.RuntimeResolve ().GetMethod (this);
+		}
+
 		public Module GetModule ()
 		{
 			return type.Module;
@@ -380,6 +390,11 @@ namespace System.Reflection.Emit
 			}
 		}
 
+		internal void FixupTokens (Dictionary<int, int> token_map, Dictionary<int, MemberInfo> member_map) {
+			if (ilgen != null)
+				ilgen.FixupTokens (token_map, member_map);
+		}
+
 		internal void GenerateDebugInfo (ISymbolWriter symbolWriter)
 		{
 			if (ilgen != null && ilgen.HasDebugInfo) {

mcs/class/corlib/System.Reflection.Emit/MethodOnTypeBuilderInst.cs

@@ -50,7 +50,7 @@ namespace System.Reflection.Emit
 		#endregion
 		MethodInfo generic_method_definition;
 
-		public MethodOnTypeBuilderInst (MonoGenericClass instantiation, MethodInfo base_method)
+		public MethodOnTypeBuilderInst (TypeBuilderInstantiation instantiation, MethodInfo base_method)
 		{
 			this.instantiation = instantiation;
 			this.base_method = base_method;
@@ -100,6 +100,19 @@ namespace System.Reflection.Emit
 			return instantiation.GetGenericArguments ();
 		}
 
+		// Called from the runtime to return the corresponding finished MethodInfo object
+		internal MethodInfo RuntimeResolve () {
+			var type = instantiation.InternalResolve ();
+			var m = type.GetMethod (base_method);
+			if (method_arguments != null) {
+				var args = new Type [method_arguments.Length];
+				for (int i = 0; i < method_arguments.Length; ++i)
+					args [i] = method_arguments [i].InternalResolve ();
+				m = m.MakeGenericMethod (args);
+			}
+			return m;
+		}
+
 		//
 		// MemberInfo members
 		//

mcs/class/corlib/System.Reflection.Emit/ModuleBuilder.cs

@@ -348,9 +348,6 @@ namespace System.Reflection.Emit {
 			return null;
 		}
 
-		[MethodImplAttribute(MethodImplOptions.InternalCall)]
-		private static extern Type create_modified_type (TypeBuilder tb, string modifiers);
-
 		private TypeBuilder GetMaybeNested (TypeBuilder t, IEnumerable<TypeName> nested) {
 			TypeBuilder result = t;
 
@@ -392,8 +389,27 @@ namespace System.Reflection.Emit {
 			if ((result == null) && throwOnError)
 				throw new TypeLoadException (className);
 			if (result != null && (ts.HasModifiers || ts.IsByRef)) {
-				string modifiers = ts.ModifierString ();
-				Type mt = create_modified_type (result, modifiers);
+				Type mt = result;
+				if (result is TypeBuilder) {
+					var tb = result as TypeBuilder;
+					if (tb.is_created)
+						mt = tb.CreateType ();
+				}
+				foreach (var mod in ts.Modifiers) {
+					if (mod is PointerSpec)
+						mt = mt.MakePointerType ();
+					else if (mod is ArraySpec) {
+						var spec = mod as ArraySpec;
+						if (spec.IsBound)
+							return null;
+						if (spec.Rank == 1)
+							mt = mt.MakeArrayType ();
+						else
+							mt = mt.MakeArrayType (spec.Rank);
+					}
+				}
+				if (ts.IsByRef)
+					mt = mt.MakeByRefType ();
 				result = mt as TypeBuilder;
 				if (result == null)
 					return mt;
@@ -665,15 +681,90 @@ namespace System.Reflection.Emit {
 			return result;
 		}
 
+		static int typeref_tokengen =  0x01ffffff;
+		static int typedef_tokengen =  0x02ffffff;
+		static int typespec_tokengen =  0x1bffffff;
+		static int memberref_tokengen =  0x0affffff;
+		static int methoddef_tokengen =  0x06ffffff;
+		Dictionary<MemberInfo, int> inst_tokens = new Dictionary<MemberInfo, int> ();
+		Dictionary<MemberInfo, int> inst_tokens_open = new Dictionary<MemberInfo, int> ();
+
+		//
+		// Assign a pseudo token to the various TypeBuilderInst objects, so the runtime
+		// doesn't have to deal with them.
+		// For Save assemblies, the tokens will be fixed up later during Save ().
+		// For Run assemblies, the tokens will not be fixed up, so the runtime will
+		// still encounter these objects, it will resolve them by calling their
+		// RuntimeResolve () methods.
+		//
+		int GetPseudoToken (MemberInfo member, bool create_open_instance) {
+			int token;
+
+			if (create_open_instance) {
+				if (inst_tokens_open.TryGetValue (member, out token))
+					return token;
+			} else {
+				if (inst_tokens.TryGetValue (member, out token))
+					return token;
+			}
+			// Count backwards to avoid collisions with the tokens
+			// allocated by the runtime
+			if (member is TypeBuilderInstantiation || member is SymbolType)
+				token = typespec_tokengen --;
+			else if (member is FieldOnTypeBuilderInst)
+				token = memberref_tokengen --;
+			else if (member is ConstructorOnTypeBuilderInst)
+				token = memberref_tokengen --;
+			else if (member is MethodOnTypeBuilderInst)
+				token = memberref_tokengen --;
+			else if (member is FieldBuilder)
+				token = memberref_tokengen --;
+			else if (member is TypeBuilder) {
+				if (create_open_instance && (member as TypeBuilder).ContainsGenericParameters)
+					token = typespec_tokengen --;
+				else if (member.Module == this)
+					token = typedef_tokengen --;
+				else
+					token = typeref_tokengen --;
+			} else if (member is ConstructorBuilder) {
+				if (member.Module == this && !(member as ConstructorBuilder).TypeBuilder.ContainsGenericParameters)
+					token = methoddef_tokengen --;
+				else
+					token = memberref_tokengen --;
+			} else if (member is MethodBuilder) {
+				var mb = member as MethodBuilder;
+				if (member.Module == this && !mb.TypeBuilder.ContainsGenericParameters && !mb.IsGenericMethodDefinition)
+					token = methoddef_tokengen --;
+				else
+					token = memberref_tokengen --;
+			} else if (member is GenericTypeParameterBuilder) {
+				token = typespec_tokengen --;
+			} else
+				throw new NotImplementedException ();
+			if (create_open_instance)
+				inst_tokens_open [member] = token;
+			else
+				inst_tokens [member] = token;
+			RegisterToken (member, token);
+			return token;
+		}
+
 		internal int GetToken (MemberInfo member) {
+			if (member is ConstructorBuilder || member is MethodBuilder)
+				return GetPseudoToken (member, false);
 			return getToken (this, member, true);
 		}
 
 		internal int GetToken (MemberInfo member, bool create_open_instance) {
+			if (member is TypeBuilderInstantiation || member is FieldOnTypeBuilderInst || member is ConstructorOnTypeBuilderInst || member is MethodOnTypeBuilderInst || member is SymbolType || member is FieldBuilder || member is TypeBuilder || member is ConstructorBuilder || member is MethodBuilder || member is GenericTypeParameterBuilder)
+				return GetPseudoToken (member, create_open_instance);
 			return getToken (this, member, create_open_instance);
 		}
 
 		internal int GetToken (MethodBase method, IEnumerable<Type> opt_param_types) {
+			if (method is ConstructorBuilder || method is MethodBuilder)
+				return GetPseudoToken (method, false);
+
 			if (opt_param_types == null)
 				return getToken (this, method, true);
 
@@ -682,6 +773,8 @@ namespace System.Reflection.Emit {
 		}
 		
 		internal int GetToken (MethodBase method, Type[] opt_param_types) {
+			if (method is ConstructorBuilder || method is MethodBuilder)
+				return GetPseudoToken (method, false);
 			return getMethodToken (this, method, opt_param_types);
 		}
 
@@ -708,12 +801,88 @@ namespace System.Reflection.Emit {
 			return token_gen;
 		}
 
+		// Called from the runtime to return the corresponding finished reflection object
+		internal static object RuntimeResolve (object obj) {
+			if (obj is MethodBuilder)
+				return (obj as MethodBuilder).RuntimeResolve ();
+			if (obj is ConstructorBuilder)
+				return (obj as ConstructorBuilder).RuntimeResolve ();
+			if (obj is FieldBuilder)
+				return (obj as FieldBuilder).RuntimeResolve ();
+			if (obj is GenericTypeParameterBuilder)
+				return (obj as GenericTypeParameterBuilder).RuntimeResolve ();
+			if (obj is FieldOnTypeBuilderInst)
+				return (obj as FieldOnTypeBuilderInst).RuntimeResolve ();
+			if (obj is MethodOnTypeBuilderInst)
+				return (obj as MethodOnTypeBuilderInst).RuntimeResolve ();
+			if (obj is ConstructorOnTypeBuilderInst)
+				return (obj as ConstructorOnTypeBuilderInst).RuntimeResolve ();
+			if (obj is Type)
+				return (obj as Type).RuntimeResolve ();
+			throw new NotImplementedException (obj.GetType ().FullName);
+		}
+
 		[MethodImplAttribute(MethodImplOptions.InternalCall)]
 		private static extern void build_metadata (ModuleBuilder mb);
 
 		[MethodImplAttribute(MethodImplOptions.InternalCall)]
 		private extern void WriteToFile (IntPtr handle);
 
+		void FixupTokens (Dictionary<int, int> token_map, Dictionary<int, MemberInfo> member_map, Dictionary<MemberInfo, int> inst_tokens,
+						  bool open) {
+			foreach (var v in inst_tokens) {
+				var member = v.Key;
+				var old_token = v.Value;
+				MemberInfo finished = null;
+
+				// Construct the concrete reflection object corresponding to the
+				// TypeBuilderInst object, and request a token for it instead.
+				if (member is TypeBuilderInstantiation || member is SymbolType) {
+					finished = (member as Type).RuntimeResolve ();
+				} else if (member is FieldOnTypeBuilderInst) {
+					finished = (member as FieldOnTypeBuilderInst).RuntimeResolve ();
+				} else if (member is ConstructorOnTypeBuilderInst) {
+					finished = (member as ConstructorOnTypeBuilderInst).RuntimeResolve ();
+				} else if (member is MethodOnTypeBuilderInst) {
+					finished = (member as MethodOnTypeBuilderInst).RuntimeResolve ();
+				} else if (member is FieldBuilder) {
+					finished = (member as FieldBuilder).RuntimeResolve ();
+				} else if (member is TypeBuilder) {
+					finished = (member as TypeBuilder).RuntimeResolve ();
+				} else if (member is ConstructorBuilder) {
+					finished = (member as ConstructorBuilder).RuntimeResolve ();
+				} else if (member is MethodBuilder) {
+					finished = (member as MethodBuilder).RuntimeResolve ();
+				} else if (member is GenericTypeParameterBuilder) {
+					finished = (member as GenericTypeParameterBuilder).RuntimeResolve ();
+				} else {
+					throw new NotImplementedException ();
+				}
+
+				int new_token = GetToken (finished, open);
+				token_map [old_token] = new_token;
+				member_map [old_token] = finished;
+				// Replace the token mapping in the runtime so it points to the new object
+				RegisterToken (finished, old_token);
+			}
+		}
+
+		//
+		// Fixup the pseudo tokens assigned to the various SRE objects
+		//
+		void FixupTokens () {
+			var token_map = new Dictionary<int, int> ();
+			var member_map = new Dictionary<int, MemberInfo> ();
+			FixupTokens (token_map, member_map, inst_tokens, false);
+			FixupTokens (token_map, member_map, inst_tokens_open, true);
+
+			// Replace the tokens in the IL stream
+			if (types != null) {
+				for (int i = 0; i < num_types; ++i)
+					types [i].FixupTokens (token_map, member_map);
+			}
+		}
+
 		internal void Save ()
 		{
 			if (transient && !is_main)
@@ -725,6 +894,8 @@ namespace System.Reflection.Emit {
 						throw new NotSupportedException ("Type '" + types [i].FullName + "' was not completed.");
 			}
 
+			FixupTokens ();
+
 			if ((global_type != null) && (global_type_created == null))
 				global_type_created = global_type.CreateType ();
 

mcs/class/corlib/System.Reflection.Emit/PropertyOnTypeBuilderInst.cs

@@ -41,10 +41,10 @@ namespace System.Reflection.Emit
 	[StructLayout (LayoutKind.Sequential)]
 	internal class PropertyOnTypeBuilderInst : PropertyInfo
 	{
-		MonoGenericClass instantiation;
+		TypeBuilderInstantiation instantiation;
 		PropertyInfo prop;
 
-		internal PropertyOnTypeBuilderInst (MonoGenericClass instantiation, PropertyInfo prop)
+		internal PropertyOnTypeBuilderInst (TypeBuilderInstantiation instantiation, PropertyInfo prop)
 		{
 			this.instantiation = instantiation;
 			this.prop = prop;

mcs/class/corlib/System.Reflection.Emit/TypeBuilder.cs

@@ -40,6 +40,7 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Globalization;
 using System.Collections;
+using System.Collections.Generic;
 using System.Security;
 using System.Security.Permissions;
 using System.Diagnostics.SymbolStore;
@@ -91,15 +92,6 @@ namespace System.Reflection.Emit
 		{
 			return attrs;
 		}
-		
-		[MethodImplAttribute(MethodImplOptions.InternalCall)]
-		private extern void setup_internal_class ();
-		
-		[MethodImplAttribute(MethodImplOptions.InternalCall)]
-		private extern void create_generic_class ();
-
-		[MethodImplAttribute(MethodImplOptions.InternalCall)]
-		private extern EventInfo get_event_info (EventBuilder eb);
 
 		internal TypeBuilder (ModuleBuilder mb, TypeAttributes attr, int table_idx)
 		{
@@ -111,7 +103,6 @@ namespace System.Reflection.Emit
 			this.nspace = String.Empty;
 			this.fullname = TypeIdentifiers.WithoutEscape(this.tname);
 			pmodule = mb;
-			setup_internal_class ();
 		}
 
 		internal TypeBuilder (ModuleBuilder mb, string name, TypeAttributes attr, Type parent, Type[] interfaces, PackingSize packing_size, int type_size, Type nesting_type)
@@ -147,7 +138,6 @@ namespace System.Reflection.Emit
 
 			// skip .<Module> ?
 			table_idx = mb.get_next_table_index (this, 0x02, true);
-			setup_internal_class ();
 			fullname = GetFullName ();
 		}
 
@@ -764,8 +754,6 @@ namespace System.Reflection.Emit
 				SetParent (pmodule.assemblyb.corlib_object_type);
 			}
 
-			create_generic_class ();
-
 			// Fire TypeResolve events for fields whose type is an unfinished
 			// value type.
 			if (fields != null) {
@@ -873,6 +861,21 @@ namespace System.Reflection.Emit
 			}
 		}
 
+		internal void FixupTokens (Dictionary<int, int> token_map, Dictionary<int, MemberInfo> member_map) {
+			if (methods != null) {
+				for (int i = 0; i < num_methods; ++i)
+					methods[i].FixupTokens (token_map, member_map);
+			}
+			if (ctors != null) {
+				foreach (var cb in ctors)
+					cb.FixupTokens (token_map, member_map);
+			}
+			if (subtypes != null) {
+				foreach (var tb in subtypes)
+					tb.FixupTokens (token_map, member_map);
+			}
+		}
+
 		internal void GenerateDebugInfo (ISymbolWriter symbolWriter)
 		{
 			symbolWriter.OpenNamespace (this.Namespace);
@@ -968,53 +971,6 @@ namespace System.Reflection.Emit
 			throw new NotSupportedException ();
 		}
 
-		// This is only used from MonoGenericInst.initialize().
-		internal EventInfo[] GetEvents_internal (BindingFlags bindingAttr)
-		{
-			if (events == null)
-				return new EventInfo [0];
-			ArrayList l = new ArrayList ();
-			bool match;
-			MethodAttributes mattrs;
-			MethodInfo accessor;
-
-			foreach (EventBuilder eb in events) {
-				if (eb == null)
-					continue;
-				EventInfo c = get_event_info (eb);
-				match = false;
-				accessor = c.GetAddMethod (true);
-				if (accessor == null)
-					accessor = c.GetRemoveMethod (true);
-				if (accessor == null)
-					continue;
-				mattrs = accessor.Attributes;
-				if ((mattrs & MethodAttributes.MemberAccessMask) == MethodAttributes.Public) {
-					if ((bindingAttr & BindingFlags.Public) != 0)
-						match = true;
-				} else {
-					if ((bindingAttr & BindingFlags.NonPublic) != 0)
-						match = true;
-				}
-				if (!match)
-					continue;
-				match = false;
-				if ((mattrs & MethodAttributes.Static) != 0) {
-					if ((bindingAttr & BindingFlags.Static) != 0)
-						match = true;
-				} else {
-					if ((bindingAttr & BindingFlags.Instance) != 0)
-						match = true;
-				}
-				if (!match)
-					continue;
-				l.Add (c);
-			}
-			EventInfo[] result = new EventInfo [l.Count];
-			l.CopyTo (result);
-			return result;
-		}
-
 		public override FieldInfo GetField (string name, BindingFlags bindingAttr)
 		{
 			if (created != null)
@@ -1642,9 +1598,6 @@ namespace System.Reflection.Emit
 				this.parent = parent;
 			}
 			this.parent = ResolveUserType (this.parent);
-
-			// will just set the parent-related bits if called a second time
-			setup_internal_class ();
 		}
 
 		internal int get_next_table_index (object obj, int table, bool inc) {
@@ -1666,6 +1619,12 @@ namespace System.Reflection.Emit
 			return created;
 		}
 
+		internal override Type RuntimeResolve ()
+		{
+			check_created ();
+			return created;
+		}
+
 		internal bool is_created {
 			get {
 				return createTypeCalled;
@@ -1764,9 +1723,10 @@ namespace System.Reflection.Emit
 			}
 		}
 
-		public extern override bool IsGenericParameter {
-			[MethodImplAttribute(MethodImplOptions.InternalCall)]
-			get;
+		public override bool IsGenericParameter {
+			get {
+				return false;
+			}
 		}
 
 		public override GenericParameterAttributes GenericParameterAttributes {
@@ -1843,7 +1803,7 @@ namespace System.Reflection.Emit
 
 		static bool IsValidGetMethodType (Type type)
 		{
-			if (type is TypeBuilder || type is MonoGenericClass)
+			if (type is TypeBuilder || type is TypeBuilderInstantiation)
 				return true;
 			/*GetMethod() must work with TypeBuilders after CreateType() was called.*/
 			if (type.Module is ModuleBuilder)