2004-11-30 Martin Baulig <[email protected]>

	Generics API cleanup: renamed MonoGenericInst -> MonoGenericClass.

	* metadata-internals.h (MonoImage): Renamed `generic_inst_cache'
	to `generic_class_cache'.

	* metadata.c
	(mono_generic_inst_hash): Renamed to mono_generic_class_hash().
	(mono_generic_inst_equal): Renamed to mono_generic_class_equal().
	(mono_generic_inst_is_valuetype): Renamed to
	mono_generic_class_is_valuetype().

	* class-internals.h
	(MonoGenericInst): Renamed to MonoGenericClass.
	(MonoDynamicGenericInst): Renamed to MonoDynamicGenericClass.
	(MonoClass): Renamed `generic_inst' to `generic_class'.
	(MonoGenericContext): Renamed `ginst' to `gclass'.

	* object-internals.h
	(MonoReflectionGenericInst): Renamed to MonoReflectionGenericClass.

	* reflection.c (mono_reflection_generic_inst_initialize): Renamed to
	mono_reflection_generic_class_initialize().

	* icall.c (icall_entries): "System.Reflection.MonoGenericInst" is
	now known as "System.Reflection.MonoGenericClass".
	(monogenericinst_icalls): Renamed to monogenericclass_icalls.


svn path=/trunk/mono/; revision=36854

mono/dis/get.c

@@ -733,16 +733,16 @@ dis_stringify_object_with_class (MonoImage *m, MonoClass *c, gboolean prefix)
 	esname = get_escaped_name (result);
 	g_free (result);
 
-	if (c->generic_inst) {
-		MonoGenericInst *ginst = c->generic_inst;
+	if (c->generic_class) {
+		MonoGenericClass *gclass = c->generic_class;
 		GString *str = g_string_new ("");
 		int i;
 
-		for (i = 0; i < ginst->type_argc; i++){
-			char *t = dis_stringify_type (m, ginst->type_argv [i]);
+		for (i = 0; i < gclass->type_argc; i++){
+			char *t = dis_stringify_type (m, gclass->type_argv [i]);
 
 			g_string_append (str, t);
-			if (i+1 != ginst->type_argc)
+			if (i+1 != gclass->type_argc)
 				g_string_append (str, ", ");
 			g_free (t);
 		}
@@ -841,13 +841,13 @@ dis_stringify_type (MonoImage *m, MonoType *type)
 	case MONO_TYPE_GENERICINST: {
 		GString *str = g_string_new ("");
 		int i;
-		char *generic_type = dis_stringify_type (m, type->data.generic_inst->generic_type);
+		char *generic_type = dis_stringify_type (m, type->data.generic_class->generic_type);
 
-		for (i = 0; i < type->data.generic_inst->type_argc; i++){
-			char *t = dis_stringify_type (m, type->data.generic_inst->type_argv [i]);
+		for (i = 0; i < type->data.generic_class->type_argc; i++){
+			char *t = dis_stringify_type (m, type->data.generic_class->type_argv [i]);
 
 			g_string_append (str, t);
-			if (i+1 != type->data.generic_inst->type_argc)
+			if (i+1 != type->data.generic_class->type_argc)
 				g_string_append (str, ", ");
 			g_free (t);
 		}

mono/metadata/ChangeLog

@@ -1,3 +1,32 @@
+2004-11-30  Martin Baulig  <[email protected]>
+
+	Generics API cleanup: renamed MonoGenericInst -> MonoGenericClass.
+
+	* metadata-internals.h (MonoImage): Renamed `generic_inst_cache'
+	to `generic_class_cache'.
+
+	* metadata.c
+	(mono_generic_inst_hash): Renamed to mono_generic_class_hash().
+	(mono_generic_inst_equal): Renamed to mono_generic_class_equal().
+	(mono_generic_inst_is_valuetype): Renamed to
+	mono_generic_class_is_valuetype().
+
+	* class-internals.h
+	(MonoGenericInst): Renamed to MonoGenericClass.
+	(MonoDynamicGenericInst): Renamed to MonoDynamicGenericClass.
+	(MonoClass): Renamed `generic_inst' to `generic_class'.
+	(MonoGenericContext): Renamed `ginst' to `gclass'.
+
+	* object-internals.h
+	(MonoReflectionGenericInst): Renamed to MonoReflectionGenericClass.
+
+	* reflection.c (mono_reflection_generic_inst_initialize): Renamed to
+	mono_reflection_generic_class_initialize().
+
+	* icall.c (icall_entries): "System.Reflection.MonoGenericInst" is
+	now known as "System.Reflection.MonoGenericClass".
+	(monogenericinst_icalls): Renamed to monogenericclass_icalls.
+
 2004-11-29  Sebastien Pouliot  <[email protected]>
 
 	* class-internals.h: Added a flag field to MonoClass to cache the

mono/metadata/class-internals.h

@@ -265,7 +265,7 @@ struct _MonoClass {
 	MonoType this_arg;
 	MonoType byval_arg;
 
-	MonoGenericInst *generic_inst;
+	MonoGenericClass *generic_class;
 	MonoGenericContainer *generic_container;
 
 	void *reflection_info;
@@ -301,7 +301,7 @@ struct MonoVTable {
 /*
  * Generic instantiation data type encoding.
  */
-struct _MonoGenericInst {
+struct _MonoGenericClass {
 	MonoGenericContainer *container;
 	MonoGenericContext *context;
 	MonoClass *klass;
@@ -309,7 +309,7 @@ struct _MonoGenericInst {
 	int count_ifaces;
 	MonoType **ifaces;
 	MonoType *generic_type;
-	MonoDynamicGenericInst *dynamic_info;
+	MonoDynamicGenericClass *dynamic_info;
 	int type_argc;
 	MonoType **type_argv;
 	guint is_open       : 1;
@@ -318,7 +318,7 @@ struct _MonoGenericInst {
 	guint is_dynamic    : 1;
 };
 
-struct _MonoDynamicGenericInst {
+struct _MonoDynamicGenericClass {
 	int count_methods;
 	MonoMethod **methods;
 	int count_ctors;
@@ -341,7 +341,7 @@ struct _MonoGenericMethod {
 
 struct _MonoGenericContext {
 	MonoGenericContainer *container;
-	MonoGenericInst *ginst;
+	MonoGenericClass *gclass;
 	MonoGenericMethod *gmethod;
 };
 
@@ -438,10 +438,10 @@ void
 mono_install_lookup_dynamic_token (MonoLookupDynamicToken func);
 
 void
-mono_class_create_generic (MonoGenericInst *ginst);
+mono_class_create_generic (MonoGenericClass *gclass);
 
 void
-mono_class_create_generic_2 (MonoGenericInst *ginst);
+mono_class_create_generic_2 (MonoGenericClass *gclass);
 
 typedef struct {
 	MonoImage *corlib;

mono/metadata/class.c

@@ -154,16 +154,16 @@ mono_type_get_name_recurse (MonoType *type, GString *str, gboolean is_recursed,
 			g_string_append (str, klass->name);
 		if (is_recursed)
 			break;
-		if (klass->generic_inst) {
-			MonoGenericInst *ginst = klass->generic_inst;
+		if (klass->generic_class) {
+			MonoGenericClass *gclass = klass->generic_class;
 			int i;
 
 			g_string_append_c (str, '[');
-			for (i = 0; i < ginst->type_argc; i++) {
+			for (i = 0; i < gclass->type_argc; i++) {
 				if (i)
 					g_string_append_c (str, ',');
 				mono_type_get_name_recurse (
-					ginst->type_argv [i], str, FALSE, include_ns, include_arity);
+					gclass->type_argv [i], str, FALSE, include_ns, include_arity);
 			}
 			g_string_append_c (str, ']');
 		} else if (klass->generic_container) {
@@ -222,7 +222,7 @@ mono_type_get_underlying_type (MonoType *type)
 			return type->data.klass->enum_basetype;
 		break;
 	case MONO_TYPE_GENERICINST:
-		return mono_type_get_underlying_type (type->data.generic_inst->generic_type);
+		return mono_type_get_underlying_type (type->data.generic_class->generic_type);
 	default:
 		break;
 	}
@@ -244,13 +244,13 @@ mono_class_is_open_constructed_type (MonoType *t)
 	case MONO_TYPE_PTR:
 		return mono_class_is_open_constructed_type (t->data.type);
 	case MONO_TYPE_GENERICINST: {
-		MonoGenericInst *ginst = t->data.generic_inst;
+		MonoGenericClass *gclass = t->data.generic_class;
 		int i;
 
-		if (mono_class_is_open_constructed_type (ginst->generic_type))
+		if (mono_class_is_open_constructed_type (gclass->generic_type))
 			return TRUE;
-		for (i = 0; i < ginst->type_argc; i++)
-			if (mono_class_is_open_constructed_type (ginst->type_argv [i]))
+		for (i = 0; i < gclass->type_argc; i++)
+			if (mono_class_is_open_constructed_type (gclass->type_argv [i]))
 				return TRUE;
 		return FALSE;
 	}
@@ -271,9 +271,9 @@ inflate_generic_type (MonoType *type, MonoGenericContext *context)
 		else
 			return NULL;
 	case MONO_TYPE_VAR:
-		if (context->ginst)
+		if (context->gclass)
 			return dup_type (
-				context->ginst->type_argv [type->data.generic_param->num],
+				context->gclass->type_argv [type->data.generic_param->num],
 				type);
 		else
 			return NULL;
@@ -287,58 +287,58 @@ inflate_generic_type (MonoType *type, MonoGenericContext *context)
 		return nt;
 	}
 	case MONO_TYPE_GENERICINST: {
-		MonoGenericInst *oginst = type->data.generic_inst;
-		MonoGenericInst *nginst, *cached;
+		MonoGenericClass *ogclass = type->data.generic_class;
+		MonoGenericClass *ngclass, *cached;
 		MonoType *nt;
 		int i;
 
-		nginst = g_new0 (MonoGenericInst, 1);
-		*nginst = *oginst;
+		ngclass = g_new0 (MonoGenericClass, 1);
+		*ngclass = *ogclass;
 
-		nginst->is_open = FALSE;
+		ngclass->is_open = FALSE;
 
-		nginst->type_argv = g_new0 (MonoType *, oginst->type_argc);
+		ngclass->type_argv = g_new0 (MonoType *, ogclass->type_argc);
 
-		for (i = 0; i < oginst->type_argc; i++) {
-			MonoType *t = oginst->type_argv [i];
-			nginst->type_argv [i] = mono_class_inflate_generic_type (t, context);
+		for (i = 0; i < ogclass->type_argc; i++) {
+			MonoType *t = ogclass->type_argv [i];
+			ngclass->type_argv [i] = mono_class_inflate_generic_type (t, context);
 
-			if (!nginst->is_open)
-				nginst->is_open = mono_class_is_open_constructed_type (nginst->type_argv [i]);
+			if (!ngclass->is_open)
+				ngclass->is_open = mono_class_is_open_constructed_type (ngclass->type_argv [i]);
 		};
 
-		nginst->klass = NULL;
+		ngclass->klass = NULL;
 
-		nginst->context = g_new0 (MonoGenericContext, 1);
-		nginst->context->ginst = nginst;
+		ngclass->context = g_new0 (MonoGenericContext, 1);
+		ngclass->context->gclass = ngclass;
 
 		mono_loader_lock ();
-		cached = g_hash_table_lookup (oginst->klass->image->generic_inst_cache, nginst);
+		cached = g_hash_table_lookup (ogclass->klass->image->generic_class_cache, ngclass);
 
 		if (cached) {
-			g_free (nginst->type_argv);
-			g_free (nginst);
+			g_free (ngclass->type_argv);
+			g_free (ngclass);
 			mono_loader_unlock ();
 
 			nt = dup_type (type, type);
-			nt->data.generic_inst = cached;
+			nt->data.generic_class = cached;
 			return nt;
 		}
 
-		nginst->dynamic_info = NULL;
-		nginst->initialized = FALSE;
+		ngclass->dynamic_info = NULL;
+		ngclass->initialized = FALSE;
 
-		mono_class_create_generic (nginst);
-		mono_class_create_generic_2 (nginst);
+		mono_class_create_generic (ngclass);
+		mono_class_create_generic_2 (ngclass);
 
 		mono_stats.generic_instance_count++;
-		mono_stats.generics_metadata_size += sizeof (MonoGenericInst) +
+		mono_stats.generics_metadata_size += sizeof (MonoGenericClass) +
 			sizeof (MonoGenericContext) +
-			nginst->type_argc * sizeof (MonoType);
+			ngclass->type_argc * sizeof (MonoType);
 
 		nt = dup_type (type, type);
-		nt->data.generic_inst = nginst;
-		g_hash_table_insert (oginst->klass->image->generic_inst_cache, nginst, nginst);
+		nt->data.generic_class = ngclass;
+		g_hash_table_insert (ogclass->klass->image->generic_class_cache, ngclass, ngclass);
 		mono_loader_unlock ();
 		return nt;
 	}
@@ -438,11 +438,11 @@ mono_class_inflate_generic_method (MonoMethod *method, MonoGenericContext *conte
 	if (context->gmethod) {
 		result->context = g_new0 (MonoGenericContext, 1);
 		result->context->gmethod = context->gmethod;
-		result->context->ginst = rklass->generic_inst;
+		result->context->gclass = rklass->generic_class;
 
 		mono_stats.generics_metadata_size += sizeof (MonoGenericContext);
-	} else if (rklass->generic_inst)
-		result->context = rklass->generic_inst->context;
+	} else if (rklass->generic_class)
+		result->context = rklass->generic_class->context;
 
 	if (method->signature->is_inflated)
 		result->declaring = ((MonoMethodInflated *) method)->declaring;
@@ -531,17 +531,17 @@ class_compute_field_layout (MonoClass *class)
 		g_assert (*sig == 0x06);
 		if (class->generic_container)
 			container = class->generic_container;
-		else if (class->generic_inst) {
-			g_assert (class->generic_inst->container);
-			container = class->generic_inst->container;
+		else if (class->generic_class) {
+			g_assert (class->generic_class->container);
+			container = class->generic_class->container;
 		}
 		field->type = mono_metadata_parse_type_full (
 			m, container, MONO_PARSE_FIELD, cols [MONO_FIELD_FLAGS], sig + 1, &sig);
 		if (mono_field_is_deleted (field))
 			continue;
-		if (class->generic_inst) {
+		if (class->generic_class) {
 			field->type = mono_class_inflate_generic_type (
-				field->type, class->generic_inst->context);
+				field->type, class->generic_class->context);
 			field->type->attrs = cols [MONO_FIELD_FLAGS];
 		}
 
@@ -594,7 +594,7 @@ class_compute_field_layout (MonoClass *class)
 	}
 
 	if (class->generic_container ||
-	    (class->generic_inst && class->generic_inst->is_open))
+	    (class->generic_class && class->generic_class->is_open))
 		return;
 
 	mono_class_layout_fields (class);
@@ -1105,8 +1105,8 @@ mono_class_setup_vtable (MonoClass *class, MonoMethod **overrides, int onum)
 				if (vtable [io + l])
 					continue;
 
-				if (ic->generic_inst) {
-					MonoClass *the_ic = mono_class_from_mono_type (ic->generic_inst->generic_type);
+				if (ic->generic_class) {
+					MonoClass *the_ic = mono_class_from_mono_type (ic->generic_class->generic_type);
 					the_cname = _mono_type_get_name (&the_ic->byval_arg, TRUE, FALSE, TRUE);
 					cname = the_cname;
 				} else {
@@ -1276,8 +1276,8 @@ mono_class_setup_vtable (MonoClass *class, MonoMethod **overrides, int onum)
 		mono_g_hash_table_destroy (override_map);
 	}
 
-	if (class->generic_inst) {
-		MonoClass *gklass = mono_class_from_mono_type (class->generic_inst->generic_type);
+	if (class->generic_class) {
+		MonoClass *gklass = mono_class_from_mono_type (class->generic_class->generic_type);
 
 		mono_class_init (gklass);
 		class->vtable_size = gklass->vtable_size;
@@ -1380,11 +1380,11 @@ mono_class_init (MonoClass *class)
 
 	mono_stats.initialized_class_count++;
 
-	if (class->generic_inst && !class->generic_inst->is_dynamic) {
-		MonoGenericInst *ginst = class->generic_inst;
+	if (class->generic_class && !class->generic_class->is_dynamic) {
+		MonoGenericClass *gclass = class->generic_class;
 		MonoClass *gklass;
 
-		gklass = mono_class_from_mono_type (ginst->generic_type);
+		gklass = mono_class_from_mono_type (gclass->generic_type);
 		mono_class_init (gklass);
 
 		if (MONO_CLASS_IS_INTERFACE (class))
@@ -1395,7 +1395,7 @@ mono_class_init (MonoClass *class)
 
 		for (i = 0; i < class->method.count; i++)
 			class->methods [i] = mono_class_inflate_generic_method (
-				gklass->methods [i], ginst->context, ginst->klass);
+				gklass->methods [i], gclass->context, gclass->klass);
 
 		g_assert (class->field.count == gklass->field.count);
 		class->fields = g_new0 (MonoClassField, class->field.count);
@@ -1408,7 +1408,7 @@ mono_class_init (MonoClass *class)
 			class->fields [i].generic_info = ifield;
 			class->fields [i].parent = class;
 			class->fields [i].type = mono_class_inflate_generic_type (
-				class->fields [i].type, ginst->context);
+				class->fields [i].type, gclass->context);
 		}
 
 		class->property = gklass->property;
@@ -1421,10 +1421,10 @@ mono_class_init (MonoClass *class)
 
 			if (prop->get)
 				prop->get = mono_class_inflate_generic_method (
-					prop->get, ginst->context, ginst->klass);
+					prop->get, gclass->context, gclass->klass);
 			if (prop->set)
 				prop->set = mono_class_inflate_generic_method (
-					prop->set, ginst->context, ginst->klass);
+					prop->set, gclass->context, gclass->klass);
 
 			prop->parent = class;
 		}
@@ -1478,7 +1478,7 @@ mono_class_init (MonoClass *class)
 			class->methods [1] = ctor;
 		}
 	} else {
-		if (!class->generic_inst && !class->methods) {
+		if (!class->generic_class && !class->methods) {
 			class->methods = g_new (MonoMethod*, class->method.count);
 			for (i = 0; i < class->method.count; ++i) {
 				class->methods [i] = mono_get_method (class->image,
@@ -1487,7 +1487,7 @@ mono_class_init (MonoClass *class)
 		}
 	}
 
-	if (!class->generic_inst) {
+	if (!class->generic_class) {
 		init_properties (class);
 		init_events (class);
 
@@ -1731,7 +1731,7 @@ mono_class_setup_parent (MonoClass *class, MonoClass *parent)
 		if (!parent)
 			g_assert_not_reached (); /* FIXME */
 
-		if (parent->generic_inst && !parent->name) {
+		if (parent->generic_class && !parent->name) {
 			/*
 			 * If the parent is a generic instance, we may get
 			 * called before it is fully initialized, especially
@@ -1935,15 +1935,15 @@ mono_class_create_from_typedef (MonoImage *image, guint32 type_token)
 }
 
 void
-mono_class_create_generic (MonoGenericInst *ginst)
+mono_class_create_generic (MonoGenericClass *gclass)
 {
 	MonoClass *klass, *gklass;
 
-	if (!ginst->klass)
-		ginst->klass = g_malloc0 (sizeof (MonoClass));
-	klass = ginst->klass;
+	if (!gclass->klass)
+		gclass->klass = g_malloc0 (sizeof (MonoClass));
+	klass = gclass->klass;
 
-	gklass = mono_class_from_mono_type (ginst->generic_type);
+	gklass = mono_class_from_mono_type (gclass->generic_type);
 
 	klass->nested_in = gklass->nested_in;
 
@@ -1952,15 +1952,15 @@ mono_class_create_generic (MonoGenericInst *ginst)
 	klass->image = gklass->image;
 	klass->flags = gklass->flags;
 
-	klass->generic_inst = ginst;
+	klass->generic_class = gclass;
 
 	klass->this_arg.type = klass->byval_arg.type = MONO_TYPE_GENERICINST;
-	klass->this_arg.data.generic_inst = klass->byval_arg.data.generic_inst = ginst;
+	klass->this_arg.data.generic_class = klass->byval_arg.data.generic_class = gclass;
 	klass->this_arg.byref = TRUE;
 
 	klass->cast_class = klass->element_class = klass;
 
-	if (ginst->is_dynamic) {
+	if (gclass->is_dynamic) {
 		klass->instance_size = gklass->instance_size;
 		klass->class_size = gklass->class_size;
 		klass->size_inited = 1;
@@ -1971,17 +1971,17 @@ mono_class_create_generic (MonoGenericInst *ginst)
 }
 
 void
-mono_class_create_generic_2 (MonoGenericInst *ginst)
+mono_class_create_generic_2 (MonoGenericClass *gclass)
 {
 	MonoClass *klass, *gklass;
 	GList *list;
 	int i;
 
-	if (ginst->is_dynamic)
+	if (gclass->is_dynamic)
 		return;
 
-	klass = ginst->klass;
-	gklass = mono_class_from_mono_type (ginst->generic_type);
+	klass = gclass->klass;
+	gklass = mono_class_from_mono_type (gclass->generic_type);
 
 	klass->method = gklass->method;
 	klass->field = gklass->field;
@@ -1990,7 +1990,7 @@ mono_class_create_generic_2 (MonoGenericInst *ginst)
 	klass->interfaces = g_new0 (MonoClass *, klass->interface_count);
 	for (i = 0; i < klass->interface_count; i++) {
 		MonoType *it = &gklass->interfaces [i]->byval_arg;
-		MonoType *inflated = mono_class_inflate_generic_type (it, ginst->context);
+		MonoType *inflated = mono_class_inflate_generic_type (it, gclass->context);
 		klass->interfaces [i] = mono_class_from_mono_type (inflated);
 	}
 
@@ -1998,10 +1998,10 @@ mono_class_create_generic_2 (MonoGenericInst *ginst)
 		klass->nested_classes = g_list_append (
 			klass->nested_classes, list->data);
 
-	if (ginst->parent)
-		klass->parent = mono_class_from_mono_type (ginst->parent);
+	if (gclass->parent)
+		klass->parent = mono_class_from_mono_type (gclass->parent);
 	else if (gklass->parent) {
-		MonoType *inflated = mono_class_inflate_generic_type (&gklass->parent->byval_arg, ginst->context);
+		MonoType *inflated = mono_class_inflate_generic_type (&gklass->parent->byval_arg, gclass->context);
 
 		klass->parent = mono_class_from_mono_type (inflated);
 	}
@@ -2223,8 +2223,8 @@ mono_class_from_mono_type (MonoType *type)
 	case MONO_TYPE_VALUETYPE:
 		return type->data.klass;
 	case MONO_TYPE_GENERICINST:
-		g_assert (type->data.generic_inst->klass);
-		return type->data.generic_inst->klass;
+		g_assert (type->data.generic_class->klass);
+		return type->data.generic_class->klass;
 	case MONO_TYPE_VAR:
 		return my_mono_class_from_generic_parameter (type->data.generic_param, FALSE);
 	case MONO_TYPE_MVAR:
@@ -2253,9 +2253,9 @@ mono_class_create_from_typespec (MonoImage *image, guint32 type_spec,
 		if (context->gmethod && context->gmethod->container) {
 			g_assert (context->gmethod->container);
 			container = context->gmethod->container;
-		} else if (context->ginst) {
-			g_assert (context->ginst->container);
-			container = context->ginst->container;
+		} else if (context->gclass) {
+			g_assert (context->gclass->container);
+			container = context->gclass->container;
 		} else if (context->container)
 			container = context->container;
 	}
@@ -2273,8 +2273,8 @@ mono_class_create_from_typespec (MonoImage *image, guint32 type_spec,
 		class = mono_ptr_class_get (type->data.type);
 		break;
 	case MONO_TYPE_GENERICINST:
-		g_assert (type->data.generic_inst->klass);
-		class = type->data.generic_inst->klass;
+		g_assert (type->data.generic_class->klass);
+		class = type->data.generic_class->klass;
 		break;
 	default:
 		/* it seems any type can be stored in TypeSpec as well */
@@ -2423,7 +2423,7 @@ mono_class_instance_size (MonoClass *klass)
 		mono_class_init (klass);
 
 	g_assert (!klass->generic_container &&
-		  (!klass->generic_inst || !klass->generic_inst->is_open));
+		  (!klass->generic_class || !klass->generic_class->is_open));
 	return klass->instance_size;
 }
 
@@ -2662,12 +2662,12 @@ mono_class_get_full (MonoImage *image, guint32 type_token, MonoGenericContext *c
 	MonoClass *class = _mono_class_get (image, type_token, context);
 	MonoType *inflated;
 
-	if (!class || !context || (!context->ginst && !context->gmethod))
+	if (!class || !context || (!context->gclass && !context->gmethod))
 		return class;
 
 	switch (class->byval_arg.type) {
 	case MONO_TYPE_GENERICINST:
-		if (!class->generic_inst->is_open)
+		if (!class->generic_class->is_open)
 			return class;
 		break;
 	case MONO_TYPE_VAR:
@@ -2854,8 +2854,8 @@ mono_class_is_subclass_of (MonoClass *klass, MonoClass *klassc,
 	if (klassc == mono_defaults.object_class)
 		return TRUE;
 
-	if (klass->generic_inst) {
-		MonoType *parent = klass->generic_inst->parent;
+	if (klass->generic_class) {
+		MonoType *parent = klass->generic_class->parent;
 		if (!parent)
 			return FALSE;
 
@@ -2990,7 +2990,7 @@ handle_enum:
 		}
 		return mono_class_instance_size (klass) - sizeof (MonoObject);
 	case MONO_TYPE_GENERICINST:
-		type = type->data.generic_inst->generic_type;
+		type = type->data.generic_class->generic_type;
 		goto handle_enum;
 	default:
 		g_error ("unknown type 0x%02x in mono_class_array_element_size", type->type);

mono/metadata/debug-helpers.c

@@ -110,7 +110,7 @@ mono_type_get_desc (GString *res, MonoType *type, gboolean include_namespace) {
 		append_class_name (res, type->data.klass, include_namespace);
 		break;
 	case MONO_TYPE_GENERICINST:
-		mono_type_get_desc (res, type->data.generic_inst->generic_type, include_namespace);
+		mono_type_get_desc (res, type->data.generic_class->generic_type, include_namespace);
 		break;
 	default:
 		break;

mono/metadata/icall.c

@@ -1206,7 +1206,7 @@ ves_icall_System_Reflection_FieldInfo_GetUnmanagedMarshal (MonoReflectionField *
 	int i;
 
 	if (klass->generic_container ||
-	    (klass->generic_inst && klass->generic_inst->is_open))
+	    (klass->generic_class && klass->generic_class->is_open))
 		return NULL;
 
 	info = mono_marshal_load_type_info (klass);
@@ -1740,8 +1740,8 @@ ves_icall_MonoType_GetGenericArguments (MonoReflectionType *type)
 			pklass = mono_class_from_generic_parameter (&container->type_params [i], klass->image, FALSE);
 			mono_array_set (res, gpointer, i, mono_type_get_object (mono_object_domain (type), &pklass->byval_arg));
 		}
-	} else if (klass->generic_inst) {
-		MonoGenericInst *inst = klass->generic_inst;
+	} else if (klass->generic_class) {
+		MonoGenericClass *inst = klass->generic_class;
 		res = mono_array_new (mono_object_domain (type), mono_defaults.monotype_class, inst->type_argc);
 		for (i = 0; i < inst->type_argc; ++i) {
 			mono_array_set (res, gpointer, i, mono_type_get_object (mono_object_domain (type), inst->type_argv [i]));
@@ -1773,8 +1773,8 @@ ves_icall_Type_GetGenericTypeDefinition_impl (MonoReflectionType *type)
 	if (klass->generic_container) {
 		return type; /* check this one */
 	}
-	if (klass->generic_inst) {
-		MonoType *generic_type = klass->generic_inst->generic_type;
+	if (klass->generic_class) {
+		MonoType *generic_type = klass->generic_class->generic_type;
 		MonoClass *generic_class = mono_class_from_mono_type (generic_type);
 
 		if (generic_class->wastypebuilder && generic_class->reflection_info)
@@ -1813,7 +1813,7 @@ ves_icall_Type_get_IsGenericInstance (MonoReflectionType *type)
 	MONO_ARCH_SAVE_REGS;
 
 	klass = mono_class_from_mono_type (type->type);
-	return klass->generic_inst != NULL;
+	return klass->generic_class != NULL;
 }
 
 static gint32
@@ -1865,7 +1865,7 @@ ves_icall_MonoType_get_HasGenericArguments (MonoReflectionType *type)
 	MONO_ARCH_SAVE_REGS;
 
 	klass = mono_class_from_mono_type (type->type);
-	if (klass->generic_container || klass->generic_inst)
+	if (klass->generic_container || klass->generic_class)
 		return TRUE;
 	return FALSE;
 }
@@ -1898,29 +1898,29 @@ ves_icall_EnumBuilder_setup_enum_type (MonoReflectionType *enumtype,
 }
 
 static MonoReflectionType*
-ves_icall_MonoGenericInst_GetParentType (MonoReflectionGenericInst *type)
+ves_icall_MonoGenericClass_GetParentType (MonoReflectionGenericClass *type)
 {
-	MonoGenericInst *ginst;
+	MonoGenericClass *gclass;
 	MonoClass *klass;
 
 	MONO_ARCH_SAVE_REGS;
 
-	ginst = type->type.type->data.generic_inst;
-	if (!ginst || !ginst->parent || (ginst->parent->type != MONO_TYPE_GENERICINST))
+	gclass = type->type.type->data.generic_class;
+	if (!gclass || !gclass->parent || (gclass->parent->type != MONO_TYPE_GENERICINST))
 		return NULL;
 
-	klass = mono_class_from_mono_type (ginst->parent);
-	if (!klass->generic_inst && !klass->generic_container)
+	klass = mono_class_from_mono_type (gclass->parent);
+	if (!klass->generic_class && !klass->generic_container)
 		return NULL;
 
-	return mono_type_get_object (mono_object_domain (type), ginst->parent);
+	return mono_type_get_object (mono_object_domain (type), gclass->parent);
 }
 
 static MonoArray*
-ves_icall_MonoGenericInst_GetInterfaces (MonoReflectionGenericInst *type)
+ves_icall_MonoGenericClass_GetInterfaces (MonoReflectionGenericClass *type)
 {
-	static MonoClass *System_Reflection_MonoGenericInst;
-	MonoGenericInst *ginst;
+	static MonoClass *System_Reflection_MonoGenericClass;
+	MonoGenericClass *gclass;
 	MonoDomain *domain;
 	MonoClass *klass;
 	MonoArray *res;
@@ -1928,24 +1928,24 @@ ves_icall_MonoGenericInst_GetInterfaces (MonoReflectionGenericInst *type)
 
 	MONO_ARCH_SAVE_REGS;
 
-	if (!System_Reflection_MonoGenericInst) {
-		System_Reflection_MonoGenericInst = mono_class_from_name (
-			mono_defaults.corlib, "System.Reflection", "MonoGenericInst");
-		g_assert (System_Reflection_MonoGenericInst);
+	if (!System_Reflection_MonoGenericClass) {
+		System_Reflection_MonoGenericClass = mono_class_from_name (
+			mono_defaults.corlib, "System.Reflection", "MonoGenericClass");
+		g_assert (System_Reflection_MonoGenericClass);
 	}
 
 	domain = mono_object_domain (type);
 
-	ginst = type->type.type->data.generic_inst;
-	if (!ginst || !ginst->ifaces)
-		return mono_array_new (domain, System_Reflection_MonoGenericInst, 0);
+	gclass = type->type.type->data.generic_class;
+	if (!gclass || !gclass->ifaces)
+		return mono_array_new (domain, System_Reflection_MonoGenericClass, 0);
 
-	klass = mono_class_from_mono_type (ginst->generic_type);
+	klass = mono_class_from_mono_type (gclass->generic_type);
 
-	res = mono_array_new (domain, System_Reflection_MonoGenericInst, ginst->count_ifaces);
+	res = mono_array_new (domain, System_Reflection_MonoGenericClass, gclass->count_ifaces);
 
-	for (i = 0; i < ginst->count_ifaces; i++) {
-		MonoReflectionType *iface = mono_type_get_object (domain, ginst->ifaces [i]);
+	for (i = 0; i < gclass->count_ifaces; i++) {
+		MonoReflectionType *iface = mono_type_get_object (domain, gclass->ifaces [i]);
 
 		mono_array_set (res, gpointer, i, iface);
 	}
@@ -1954,11 +1954,11 @@ ves_icall_MonoGenericInst_GetInterfaces (MonoReflectionGenericInst *type)
 }
 
 static MonoArray*
-ves_icall_MonoGenericInst_GetMethods (MonoReflectionGenericInst *type,
-				      MonoReflectionType *reflected_type)
+ves_icall_MonoGenericClass_GetMethods (MonoReflectionGenericClass *type,
+				       MonoReflectionType *reflected_type)
 {
-	MonoGenericInst *ginst;
-	MonoDynamicGenericInst *dginst;
+	MonoGenericClass *gclass;
+	MonoDynamicGenericClass *dgclass;
 	MonoDomain *domain;
 	MonoClass *refclass;
 	MonoArray *res;
@@ -1966,28 +1966,28 @@ ves_icall_MonoGenericInst_GetMethods (MonoReflectionGenericInst *type,
 
 	MONO_ARCH_SAVE_REGS;
 
-	ginst = type->type.type->data.generic_inst;
-	g_assert ((dginst = ginst->dynamic_info) != NULL);
+	gclass = type->type.type->data.generic_class;
+	g_assert ((dgclass = gclass->dynamic_info) != NULL);
 
 	refclass = mono_class_from_mono_type (reflected_type->type);
 
 	domain = mono_object_domain (type);
-	res = mono_array_new (domain, mono_defaults.method_info_class, dginst->count_methods);
+	res = mono_array_new (domain, mono_defaults.method_info_class, dgclass->count_methods);
 
-	for (i = 0; i < dginst->count_methods; i++)
+	for (i = 0; i < dgclass->count_methods; i++)
 		mono_array_set (res, gpointer, i,
-				mono_method_get_object (domain, dginst->methods [i], refclass));
+				mono_method_get_object (domain, dgclass->methods [i], refclass));
 
 	return res;
 }
 
 static MonoArray*
-ves_icall_MonoGenericInst_GetConstructors (MonoReflectionGenericInst *type,
-					   MonoReflectionType *reflected_type)
+ves_icall_MonoGenericClass_GetConstructors (MonoReflectionGenericClass *type,
+					    MonoReflectionType *reflected_type)
 {
 	static MonoClass *System_Reflection_ConstructorInfo;
-	MonoGenericInst *ginst;
-	MonoDynamicGenericInst *dginst;
+	MonoGenericClass *gclass;
+	MonoDynamicGenericClass *dgclass;
 	MonoDomain *domain;
 	MonoClass *refclass;
 	MonoArray *res;
@@ -1999,27 +1999,27 @@ ves_icall_MonoGenericInst_GetConstructors (MonoReflectionGenericInst *type,
 		System_Reflection_ConstructorInfo = mono_class_from_name (
 			mono_defaults.corlib, "System.Reflection", "ConstructorInfo");
 
-	ginst = type->type.type->data.generic_inst;
-	g_assert ((dginst = ginst->dynamic_info) != NULL);
+	gclass = type->type.type->data.generic_class;
+	g_assert ((dgclass = gclass->dynamic_info) != NULL);
 
 	refclass = mono_class_from_mono_type (reflected_type->type);
 
 	domain = mono_object_domain (type);
-	res = mono_array_new (domain, System_Reflection_ConstructorInfo, dginst->count_ctors);
+	res = mono_array_new (domain, System_Reflection_ConstructorInfo, dgclass->count_ctors);
 
-	for (i = 0; i < dginst->count_ctors; i++)
+	for (i = 0; i < dgclass->count_ctors; i++)
 		mono_array_set (res, gpointer, i,
-				mono_method_get_object (domain, dginst->ctors [i], refclass));
+				mono_method_get_object (domain, dgclass->ctors [i], refclass));
 
 	return res;
 }
 
 static MonoArray*
-ves_icall_MonoGenericInst_GetFields (MonoReflectionGenericInst *type,
-				     MonoReflectionType *reflected_type)
+ves_icall_MonoGenericClass_GetFields (MonoReflectionGenericClass *type,
+				      MonoReflectionType *reflected_type)
 {
-	MonoGenericInst *ginst;
-	MonoDynamicGenericInst *dginst;
+	MonoGenericClass *gclass;
+	MonoDynamicGenericClass *dgclass;
 	MonoDomain *domain;
 	MonoClass *refclass;
 	MonoArray *res;
@@ -2027,28 +2027,28 @@ ves_icall_MonoGenericInst_GetFields (MonoReflectionGenericInst *type,
 
 	MONO_ARCH_SAVE_REGS;
 
-	ginst = type->type.type->data.generic_inst;
-	g_assert ((dginst = ginst->dynamic_info) != NULL);
+	gclass = type->type.type->data.generic_class;
+	g_assert ((dgclass = gclass->dynamic_info) != NULL);
 
 	refclass = mono_class_from_mono_type (reflected_type->type);
 
 	domain = mono_object_domain (type);
-	res = mono_array_new (domain, mono_defaults.field_info_class, dginst->count_fields);
+	res = mono_array_new (domain, mono_defaults.field_info_class, dgclass->count_fields);
 
-	for (i = 0; i < dginst->count_fields; i++)
+	for (i = 0; i < dgclass->count_fields; i++)
 		mono_array_set (res, gpointer, i,
-				mono_field_get_object (domain, refclass, &dginst->fields [i]));
+				mono_field_get_object (domain, refclass, &dgclass->fields [i]));
 
 	return res;
 }
 
 static MonoArray*
-ves_icall_MonoGenericInst_GetProperties (MonoReflectionGenericInst *type,
-					 MonoReflectionType *reflected_type)
+ves_icall_MonoGenericClass_GetProperties (MonoReflectionGenericClass *type,
+					  MonoReflectionType *reflected_type)
 {
 	static MonoClass *System_Reflection_PropertyInfo;
-	MonoGenericInst *ginst;
-	MonoDynamicGenericInst *dginst;
+	MonoGenericClass *gclass;
+	MonoDynamicGenericClass *dgclass;
 	MonoDomain *domain;
 	MonoClass *refclass;
 	MonoArray *res;
@@ -2060,28 +2060,28 @@ ves_icall_MonoGenericInst_GetProperties (MonoReflectionGenericInst *type,
 		System_Reflection_PropertyInfo = mono_class_from_name (
 			mono_defaults.corlib, "System.Reflection", "PropertyInfo");
 
-	ginst = type->type.type->data.generic_inst;
-	g_assert ((dginst = ginst->dynamic_info) != NULL);
+	gclass = type->type.type->data.generic_class;
+	g_assert ((dgclass = gclass->dynamic_info) != NULL);
 
 	refclass = mono_class_from_mono_type (reflected_type->type);
 
 	domain = mono_object_domain (type);
-	res = mono_array_new (domain, System_Reflection_PropertyInfo, dginst->count_properties);
+	res = mono_array_new (domain, System_Reflection_PropertyInfo, dgclass->count_properties);
 
-	for (i = 0; i < dginst->count_properties; i++)
+	for (i = 0; i < dgclass->count_properties; i++)
 		mono_array_set (res, gpointer, i,
-				mono_property_get_object (domain, refclass, &dginst->properties [i]));
+				mono_property_get_object (domain, refclass, &dgclass->properties [i]));
 
 	return res;
 }
 
 static MonoArray*
-ves_icall_MonoGenericInst_GetEvents (MonoReflectionGenericInst *type,
-				     MonoReflectionType *reflected_type)
+ves_icall_MonoGenericClass_GetEvents (MonoReflectionGenericClass *type,
+				      MonoReflectionType *reflected_type)
 {
 	static MonoClass *System_Reflection_EventInfo;
-	MonoGenericInst *ginst;
-	MonoDynamicGenericInst *dginst;
+	MonoGenericClass *gclass;
+	MonoDynamicGenericClass *dgclass;
 	MonoDomain *domain;
 	MonoClass *refclass;
 	MonoArray *res;
@@ -2093,17 +2093,17 @@ ves_icall_MonoGenericInst_GetEvents (MonoReflectionGenericInst *type,
 		System_Reflection_EventInfo = mono_class_from_name (
 			mono_defaults.corlib, "System.Reflection", "EventInfo");
 
-	ginst = type->type.type->data.generic_inst;
-	g_assert ((dginst = ginst->dynamic_info) != NULL);
+	gclass = type->type.type->data.generic_class;
+	g_assert ((dgclass = gclass->dynamic_info) != NULL);
 
 	refclass = mono_class_from_mono_type (reflected_type->type);
 
 	domain = mono_object_domain (type);
-	res = mono_array_new (domain, System_Reflection_EventInfo, dginst->count_events);
+	res = mono_array_new (domain, System_Reflection_EventInfo, dgclass->count_events);
 
-	for (i = 0; i < dginst->count_events; i++)
+	for (i = 0; i < dgclass->count_events; i++)
 		mono_array_set (res, gpointer, i,
-				mono_event_get_object (domain, refclass, &dginst->events [i]));
+				mono_event_get_object (domain, refclass, &dgclass->events [i]));
 
 	return res;
 }
@@ -5382,8 +5382,8 @@ ves_icall_MonoMethod_get_base_definition (MonoReflectionMethod *m)
 	if (method->klass == NULL || (klass = method->klass->parent) == NULL)
 		return m;
 
-	if (klass->generic_inst)
-		klass = mono_class_from_mono_type (klass->generic_inst->generic_type);
+	if (klass->generic_class)
+		klass = mono_class_from_mono_type (klass->generic_class->generic_type);
 
 	while (result == NULL && klass != NULL && (klass->vtable_size > method->slot))
 	{
@@ -5981,15 +5981,15 @@ static const IcallEntry monofield_icalls [] = {
 	{"SetValueInternal", ves_icall_FieldInfo_SetValueInternal}
 };
 
-static const IcallEntry monogenericinst_icalls [] = {
-	{"GetConstructors_internal", ves_icall_MonoGenericInst_GetConstructors},
-	{"GetEvents_internal", ves_icall_MonoGenericInst_GetEvents},
-	{"GetFields_internal", ves_icall_MonoGenericInst_GetFields},
-	{"GetInterfaces_internal", ves_icall_MonoGenericInst_GetInterfaces},
-	{"GetMethods_internal", ves_icall_MonoGenericInst_GetMethods},
-	{"GetParentType", ves_icall_MonoGenericInst_GetParentType},
-	{"GetProperties_internal", ves_icall_MonoGenericInst_GetProperties},
-	{"initialize", mono_reflection_generic_inst_initialize}
+static const IcallEntry monogenericclass_icalls [] = {
+	{"GetConstructors_internal", ves_icall_MonoGenericClass_GetConstructors},
+	{"GetEvents_internal", ves_icall_MonoGenericClass_GetEvents},
+	{"GetFields_internal", ves_icall_MonoGenericClass_GetFields},
+	{"GetInterfaces_internal", ves_icall_MonoGenericClass_GetInterfaces},
+	{"GetMethods_internal", ves_icall_MonoGenericClass_GetMethods},
+	{"GetParentType", ves_icall_MonoGenericClass_GetParentType},
+	{"GetProperties_internal", ves_icall_MonoGenericClass_GetProperties},
+	{"initialize", mono_reflection_generic_class_initialize}
 };
 
 static const IcallEntry generictypeparambuilder_icalls [] = {
@@ -6456,7 +6456,7 @@ static const IcallMap icall_entries [] = {
 	{"System.Reflection.MonoCMethod", monocmethod_icalls, G_N_ELEMENTS (monocmethod_icalls)},
 	{"System.Reflection.MonoEventInfo", monoeventinfo_icalls, G_N_ELEMENTS (monoeventinfo_icalls)},
 	{"System.Reflection.MonoField", monofield_icalls, G_N_ELEMENTS (monofield_icalls)},
-	{"System.Reflection.MonoGenericInst", monogenericinst_icalls, G_N_ELEMENTS (monogenericinst_icalls)},
+	{"System.Reflection.MonoGenericClass", monogenericclass_icalls, G_N_ELEMENTS (monogenericclass_icalls)},
 	{"System.Reflection.MonoMethod", monomethod_icalls, G_N_ELEMENTS (monomethod_icalls)},
 	{"System.Reflection.MonoMethodInfo", monomethodinfo_icalls, G_N_ELEMENTS (monomethodinfo_icalls)},
 	{"System.Reflection.MonoPropertyInfo", monopropertyinfo_icalls, G_N_ELEMENTS (monopropertyinfo_icalls)},

mono/metadata/image.c

@@ -612,9 +612,9 @@ mono_image_init (MonoImage *image)
 	image->memberref_signatures = g_hash_table_new (NULL, NULL);
 	image->helper_signatures = g_hash_table_new (g_str_hash, g_str_equal);
 
-	image->generic_inst_cache =
-		g_hash_table_new ((GHashFunc)mono_metadata_generic_inst_hash,
-				  (GCompareFunc)mono_metadata_generic_inst_equal);
+	image->generic_class_cache =
+		g_hash_table_new ((GHashFunc)mono_metadata_generic_class_hash,
+				  (GCompareFunc)mono_metadata_generic_class_equal);
 }
 
 static MonoImage *
@@ -1031,7 +1031,7 @@ mono_image_close (MonoImage *image)
 	g_hash_table_destroy (image->remoting_invoke_cache);
 	g_hash_table_destroy (image->runtime_invoke_cache);
 	g_hash_table_destroy (image->typespec_cache);
-	g_hash_table_destroy (image->generic_inst_cache);
+	g_hash_table_destroy (image->generic_class_cache);
 	g_hash_table_foreach (image->memberref_signatures, free_mr_signatures, NULL);
 	g_hash_table_destroy (image->memberref_signatures);
 	g_hash_table_foreach (image->helper_signatures, free_mr_signatures, NULL);

mono/metadata/loader.c

@@ -152,7 +152,7 @@ mono_field_from_token (MonoImage *image, guint32 token, MonoClass **retklass,
 	}
 
 	mono_loader_lock ();
-	if (!field->parent->generic_inst)
+	if (!field->parent->generic_class)
 		g_hash_table_insert (image->field_cache, GUINT_TO_POINTER (token), field);
 	mono_loader_unlock ();
 	return field;
@@ -222,11 +222,11 @@ find_method (MonoClass *klass, MonoClass *ic, const char* name, MonoMethodSignat
 		klass = klass->parent;
 	}
 
-	if (sclass->generic_inst) {
+	if (sclass->generic_class) {
 		MonoClass *gclass;
 		MonoMethod *res;
 
-		gclass = mono_class_from_mono_type (sclass->generic_inst->generic_type);
+		gclass = mono_class_from_mono_type (sclass->generic_class->generic_type);
 		mono_class_init (gclass);
 
 		res = find_method (gclass, ic, name, sig);
@@ -267,7 +267,7 @@ mono_method_get_signature (MonoMethod *method, MonoImage *image, guint32 token)
 		return method->signature;
 	}
 
-	if (method->klass->generic_inst)
+	if (method->klass->generic_class)
 		return method->signature;
 
 	if (image->dynamic)
@@ -340,9 +340,9 @@ method_from_memberref (MonoImage *image, guint32 idx, MonoGenericContext *contex
 
 	if (klass->generic_container)
 		container = klass->generic_container;
-	else if (klass->generic_inst) {
-		g_assert (klass->generic_inst->container);
-		container = klass->generic_inst->container;
+	else if (klass->generic_class) {
+		g_assert (klass->generic_class->container);
+		container = klass->generic_class->container;
 	}
 
 	ptr = mono_metadata_blob_heap (image, cols [MONO_MEMBERREF_SIGNATURE]);
@@ -366,9 +366,9 @@ method_from_memberref (MonoImage *image, guint32 idx, MonoGenericContext *contex
 			method = find_method (klass, NULL, mname, sig);
 			if (!method)
 				g_warning ("Missing method %s in assembly %s typeref index %d", mname, image->name, nindex);
-			else if (klass->generic_inst && (klass != method->klass))
+			else if (klass->generic_class && (klass != method->klass))
 				method = mono_class_inflate_generic_method (
-					method, klass->generic_inst->context, klass);
+					method, klass->generic_class->context, klass);
 			mono_metadata_free_method_signature (sig);
 			return method;
 		}
@@ -457,9 +457,9 @@ method_from_methodspec (MonoImage *image, MonoGenericContext *context, guint32 i
 	g_assert (container && container->is_method);
 
 	if (context) {
-		if (context->ginst) {
-			g_assert (context->ginst->container);
-			container->parent = context->ginst->container;
+		if (context->gclass) {
+			g_assert (context->gclass->container);
+			container->parent = context->gclass->container;
 		} else
 			container->parent = context->container;
 	}
@@ -502,7 +502,7 @@ method_from_methodspec (MonoImage *image, MonoGenericContext *context, guint32 i
 	} else {
 		new_context = g_new0 (MonoGenericContext, 1);
 		new_context->gmethod = gmethod;
-		new_context->ginst = context->ginst;
+		new_context->gclass = context->gclass;
 
 		context = new_context;
 	}
@@ -514,7 +514,7 @@ method_from_methodspec (MonoImage *image, MonoGenericContext *context, guint32 i
 	g_hash_table_insert (container->method_hash, gmethod, inflated);
 
 	if (new_context)
-		context->ginst = inflated->klass->generic_inst;
+		context->gclass = inflated->klass->generic_class;
 	return inflated;
 }
 
@@ -822,9 +822,9 @@ mono_get_method_from_token (MonoImage *image, guint32 token, MonoClass *klass,
 	if (table != MONO_TABLE_METHOD) {
 		MonoGenericContainer *generic_container = NULL;
 		if (context) {
-			if (context->ginst) {
-				g_assert (context->ginst->container);
-				generic_container = context->ginst->container;
+			if (context->gclass) {
+				g_assert (context->gclass->container);
+				generic_container = context->gclass->container;
 			} else
 				generic_container = context->container;
 		}
@@ -1036,7 +1036,7 @@ mono_method_get_param_names (MonoMethod *method, const char **names)
 	for (i = 0; i < method->signature->param_count; ++i)
 		names [i] = "";
 
-	if (klass->generic_inst) /* copy the names later */
+	if (klass->generic_class) /* copy the names later */
 		return;
 
 	mono_class_init (klass);
@@ -1082,7 +1082,7 @@ mono_method_get_param_token (MonoMethod *method, int index)
 	MonoClass *klass = method->klass;
 	MonoTableInfo *methodt;
 
-	if (klass->generic_inst)
+	if (klass->generic_class)
 		g_assert_not_reached ();
 
 	mono_class_init (klass);

mono/metadata/metadata-internals.h

@@ -101,9 +101,9 @@ struct _MonoImage {
 	GHashTable *helper_signatures;
 
 	/*
-	 * Indexed by MonoGenericInst.
+	 * Indexed by MonoGenericClass.
 	 */
-	GHashTable *generic_inst_cache;
+	GHashTable *generic_class_cache;
 
 	/*
 	 * Indexes namespaces to hash tables that map class name to typedef token.

mono/metadata/metadata.c

@@ -1533,27 +1533,27 @@ mono_metadata_free_method_signature (MonoMethodSignature *sig)
 }
 
 static void
-do_mono_metadata_parse_generic_inst (MonoType *type, MonoImage *m, MonoGenericContainer *generic_container,
-				     const char *ptr, const char **rptr)
+do_mono_metadata_parse_generic_class (MonoType *type, MonoImage *m, MonoGenericContainer *generic_container,
+				      const char *ptr, const char **rptr)
 {
-	MonoGenericInst *ginst = g_new0 (MonoGenericInst, 1);
-	MonoGenericInst *cached;
+	MonoGenericClass *gclass = g_new0 (MonoGenericClass, 1);
+	MonoGenericClass *cached;
 	MonoClass *gklass;
 	int i, count;
 
-	type->data.generic_inst = ginst;
+	type->data.generic_class = gclass;
 
-	ginst->context = g_new0 (MonoGenericContext, 1);
-	ginst->context->ginst = ginst;
+	gclass->context = g_new0 (MonoGenericContext, 1);
+	gclass->context->gclass = gclass;
 
-	ginst->klass = g_new0 (MonoClass, 1);
+	gclass->klass = g_new0 (MonoClass, 1);
 
-	ginst->generic_type = mono_metadata_parse_type_full (m, generic_container, MONO_PARSE_TYPE, 0, ptr, &ptr);
-	ginst->type_argc = count = mono_metadata_decode_value (ptr, &ptr);
-	ginst->type_argv = g_new0 (MonoType*, count);
+	gclass->generic_type = mono_metadata_parse_type_full (m, generic_container, MONO_PARSE_TYPE, 0, ptr, &ptr);
+	gclass->type_argc = count = mono_metadata_decode_value (ptr, &ptr);
+	gclass->type_argv = g_new0 (MonoType*, count);
 
-	gklass = mono_class_from_mono_type (ginst->generic_type);
-	g_assert ((ginst->container = gklass->generic_container) != NULL);
+	gklass = mono_class_from_mono_type (gclass->generic_type);
+	g_assert ((gclass->container = gklass->generic_container) != NULL);
 
 	/*
 	 * Create the klass before parsing the type arguments.
@@ -1561,19 +1561,19 @@ do_mono_metadata_parse_generic_inst (MonoType *type, MonoImage *m, MonoGenericCo
 	 * See mcs/tests/gen-23.cs for an example.
 	 */
 
-	ginst->init_pending = TRUE;
+	gclass->init_pending = TRUE;
 
-	mono_class_create_generic (ginst);
+	mono_class_create_generic (gclass);
 
-	for (i = 0; i < ginst->type_argc; i++) {
+	for (i = 0; i < gclass->type_argc; i++) {
 		MonoType *t = mono_metadata_parse_type_full (m, generic_container, MONO_PARSE_TYPE, 0, ptr, &ptr);
 
-		ginst->type_argv [i] = t;
-		if (!ginst->is_open)
-			ginst->is_open = mono_class_is_open_constructed_type (t);
+		gclass->type_argv [i] = t;
+		if (!gclass->is_open)
+			gclass->is_open = mono_class_is_open_constructed_type (t);
 	}
 
-	mono_class_create_generic_2 (ginst);
+	mono_class_create_generic_2 (gclass);
 
 	if (rptr)
 		*rptr = ptr;
@@ -1583,7 +1583,7 @@ do_mono_metadata_parse_generic_inst (MonoType *type, MonoImage *m, MonoGenericCo
 	 * instantiated type.  This happens for instance if we're part of a method or
 	 * local variable signature.
 	 *
-	 * It's important to return the same MonoGenericInst * for each particualar
+	 * It's important to return the same MonoGenericClass * for each particualar
 	 * instantiation of a generic type (ie "Stack<Int32>") to make static fields
 	 * work.
 	 *
@@ -1592,24 +1592,24 @@ do_mono_metadata_parse_generic_inst (MonoType *type, MonoImage *m, MonoGenericCo
 	 * type.
 	 */
 
-	cached = g_hash_table_lookup (m->generic_inst_cache, ginst);
+	cached = g_hash_table_lookup (m->generic_class_cache, gclass);
 	if (cached) {
-		g_free (ginst->klass);
-		g_free (ginst->type_argv);
-		g_free (ginst);
+		g_free (gclass->klass);
+		g_free (gclass->type_argv);
+		g_free (gclass);
 
-		type->data.generic_inst = cached;
+		type->data.generic_class = cached;
 		return;
 	} else {
-		g_hash_table_insert (m->generic_inst_cache, ginst, ginst);
+		g_hash_table_insert (m->generic_class_cache, gclass, gclass);
 
 		mono_stats.generic_instance_count++;
-		mono_stats.generics_metadata_size += sizeof (MonoGenericInst) +
+		mono_stats.generics_metadata_size += sizeof (MonoGenericClass) +
 			sizeof (MonoGenericContext) +
-			ginst->type_argc * sizeof (MonoType);
+			gclass->type_argc * sizeof (MonoType);
 	}
 
-	ginst->init_pending = FALSE;
+	gclass->init_pending = FALSE;
 }
 
 /* 
@@ -1721,7 +1721,7 @@ do_mono_metadata_parse_type (MonoType *type, MonoImage *m, MonoGenericContainer
 		break;
 
 	case MONO_TYPE_GENERICINST:
-		do_mono_metadata_parse_generic_inst (type, m, generic_container, ptr, &ptr);
+		do_mono_metadata_parse_generic_class (type, m, generic_container, ptr, &ptr);
 		break;
 		
 	default:
@@ -2564,17 +2564,17 @@ mono_type_size (MonoType *t, gint *align)
 	case MONO_TYPE_TYPEDBYREF:
 		return mono_class_value_size (mono_defaults.typed_reference_class, align);
 	case MONO_TYPE_GENERICINST: {
-		MonoGenericInst *ginst = t->data.generic_inst;
+		MonoGenericClass *gclass = t->data.generic_class;
 
-		g_assert (!ginst->is_open && !ginst->klass->generic_container);
+		g_assert (!gclass->is_open && !gclass->klass->generic_container);
 
-		if (MONO_TYPE_ISSTRUCT (ginst->generic_type)) {
-			MonoClass *gklass = mono_class_from_mono_type (ginst->generic_type);
+		if (MONO_TYPE_ISSTRUCT (gclass->generic_type)) {
+			MonoClass *gklass = mono_class_from_mono_type (gclass->generic_type);
 
 			if (gklass->enumtype)
 				return mono_type_size (gklass->enum_basetype, align);
 			else
-				return mono_class_value_size (ginst->klass, align);
+				return mono_class_value_size (gclass->klass, align);
 		} else {
 			*align = __alignof__(gpointer);
 			return sizeof (gpointer);
@@ -2663,17 +2663,17 @@ mono_type_stack_size (MonoType *t, gint *align)
 		}
 	}
 	case MONO_TYPE_GENERICINST: {
-		MonoGenericInst *ginst = t->data.generic_inst;
+		MonoGenericClass *gclass = t->data.generic_class;
 
-		g_assert (!ginst->is_open && !ginst->klass->generic_container);
+		g_assert (!gclass->is_open && !gclass->klass->generic_container);
 
-		if (MONO_TYPE_ISSTRUCT (ginst->generic_type)) {
-			MonoClass *gklass = mono_class_from_mono_type (ginst->generic_type);
+		if (MONO_TYPE_ISSTRUCT (gclass->generic_type)) {
+			MonoClass *gklass = mono_class_from_mono_type (gclass->generic_type);
 
 			if (gklass->enumtype)
 				return mono_type_stack_size (gklass->enum_basetype, align);
 			else {
-				guint32 size = mono_class_value_size (ginst->klass, align);
+				guint32 size = mono_class_value_size (gclass->klass, align);
 
 				*align = *align + __alignof__(gpointer) - 1;
 				*align &= ~(__alignof__(gpointer) - 1);
@@ -2695,19 +2695,19 @@ mono_type_stack_size (MonoType *t, gint *align)
 }
 
 gboolean
-mono_metadata_generic_inst_is_valuetype (MonoGenericInst *ginst)
+mono_metadata_generic_class_is_valuetype (MonoGenericClass *gclass)
 {
-	return MONO_TYPE_ISSTRUCT (ginst->generic_type);
+	return MONO_TYPE_ISSTRUCT (gclass->generic_type);
 }
 
 guint
-mono_metadata_generic_inst_hash (MonoGenericInst *ginst)
+mono_metadata_generic_class_hash (MonoGenericClass *gclass)
 {
-	return mono_metadata_type_hash (ginst->generic_type);
+	return mono_metadata_type_hash (gclass->generic_type);
 }
 
 static gboolean
-_mono_metadata_generic_inst_equal (MonoGenericInst *g1, MonoGenericInst *g2, gboolean signature_only)
+_mono_metadata_generic_class_equal (MonoGenericClass *g1, MonoGenericClass *g2, gboolean signature_only)
 {
 	int i;
 
@@ -2723,9 +2723,9 @@ _mono_metadata_generic_inst_equal (MonoGenericInst *g1, MonoGenericInst *g2, gbo
 }
 
 gboolean
-mono_metadata_generic_inst_equal (MonoGenericInst *g1, MonoGenericInst *g2)
+mono_metadata_generic_class_equal (MonoGenericClass *g1, MonoGenericClass *g2)
 {
-	return _mono_metadata_generic_inst_equal (g1, g2, FALSE);
+	return _mono_metadata_generic_class_equal (g1, g2, FALSE);
 }
 
 guint
@@ -2772,7 +2772,7 @@ mono_metadata_type_hash (MonoType *t1)
 	case MONO_TYPE_ARRAY:
 		return ((hash << 5) - hash) ^ mono_metadata_type_hash (&t1->data.array->eklass->byval_arg);
 	case MONO_TYPE_GENERICINST:
-		return ((hash << 5) - hash) ^ mono_metadata_generic_inst_hash (t1->data.generic_inst);
+		return ((hash << 5) - hash) ^ mono_metadata_generic_class_hash (t1->data.generic_class);
 	}
 	return hash;
 }
@@ -2802,8 +2802,8 @@ mono_metadata_class_equal (MonoClass *c1, MonoClass *c2, gboolean signature_only
 {
 	if (c1 == c2)
 		return TRUE;
-	if (c1->generic_inst && c2->generic_inst)
-		return _mono_metadata_generic_inst_equal (c1->generic_inst, c2->generic_inst, signature_only);
+	if (c1->generic_class && c2->generic_class)
+		return _mono_metadata_generic_class_equal (c1->generic_class, c2->generic_class, signature_only);
 	if ((c1->byval_arg.type == MONO_TYPE_VAR) && (c2->byval_arg.type == MONO_TYPE_VAR))
 		return mono_metadata_generic_param_equal (
 			c1->byval_arg.data.generic_param, c2->byval_arg.data.generic_param, FALSE);
@@ -2859,8 +2859,8 @@ do_mono_metadata_type_equal (MonoType *t1, MonoType *t2, gboolean signature_only
 			return FALSE;
 		return mono_metadata_class_equal (t1->data.array->eklass, t2->data.array->eklass, signature_only);
 	case MONO_TYPE_GENERICINST:
-		return _mono_metadata_generic_inst_equal (
-			t1->data.generic_inst, t2->data.generic_inst, signature_only);
+		return _mono_metadata_generic_class_equal (
+			t1->data.generic_class, t2->data.generic_class, signature_only);
 	case MONO_TYPE_VAR:
 		return mono_metadata_generic_param_equal (
 			t1->data.generic_param, t2->data.generic_param, FALSE);

mono/metadata/metadata.h

@@ -14,7 +14,7 @@
 #define MONO_ZERO_LEN_ARRAY 1
 #endif
 
-#define MONO_TYPE_ISSTRUCT(t) (!(t)->byref && (((t)->type == MONO_TYPE_VALUETYPE && !(t)->data.klass->enumtype) || ((t)->type == MONO_TYPE_TYPEDBYREF) || (((t)->type == MONO_TYPE_GENERICINST) && mono_metadata_generic_inst_is_valuetype ((t)->data.generic_inst))))
+#define MONO_TYPE_ISSTRUCT(t) (!(t)->byref && (((t)->type == MONO_TYPE_VALUETYPE && !(t)->data.klass->enumtype) || ((t)->type == MONO_TYPE_TYPEDBYREF) || (((t)->type == MONO_TYPE_GENERICINST) && mono_metadata_generic_class_is_valuetype ((t)->data.generic_class))))
 #define MONO_TYPE_IS_VOID(t) ((t) && ((t)->type == MONO_TYPE_VOID) && !(t)->byref)
 #define MONO_TYPE_IS_POINTER(t) ((t) && (((t)->byref || ((t)->type == MONO_TYPE_I) || (t)->type == MONO_TYPE_STRING) || ((t)->type == MONO_TYPE_SZARRAY) || ((t)->type == MONO_TYPE_CLASS) || ((t)->type == MONO_TYPE_CLASS) || ((t)->type == MONO_TYPE_OBJECT) || ((t)->type == MONO_TYPE_ARRAY) || ((t)->type == MONO_TYPE_PTR)))
 
@@ -25,7 +25,7 @@
 				     ((t)->type == MONO_TYPE_OBJECT) ||		\
 				     ((t)->type == MONO_TYPE_ARRAY)) ||		\
 				    (((t)->type == MONO_TYPE_GENERICINST) &&	\
-				     !mono_metadata_generic_inst_is_valuetype ((t)->data.generic_inst))))
+				     !mono_metadata_generic_class_is_valuetype ((t)->data.generic_class))))
 
 #define MONO_CLASS_IS_INTERFACE(c) ((c->flags & TYPE_ATTRIBUTE_INTERFACE) || (c->byval_arg.type == MONO_TYPE_VAR) || (c->byval_arg.type == MONO_TYPE_MVAR))
 
@@ -275,8 +275,8 @@ typedef struct {
 } MonoExceptionClause;
 
 typedef struct _MonoType MonoType;
-typedef struct _MonoGenericInst MonoGenericInst;
-typedef struct _MonoDynamicGenericInst MonoDynamicGenericInst;
+typedef struct _MonoGenericClass MonoGenericClass;
+typedef struct _MonoDynamicGenericClass MonoDynamicGenericClass;
 typedef struct _MonoGenericMethod MonoGenericMethod;
 typedef struct _MonoGenericContext MonoGenericContext;
 typedef struct _MonoGenericContainer MonoGenericContainer;
@@ -305,7 +305,7 @@ struct _MonoType {
 		MonoArrayType *array; /* for ARRAY */
 		MonoMethodSignature *method;
 		MonoGenericParam *generic_param; /* for VAR and MVAR */
-		MonoGenericInst *generic_inst; /* for GENERICINST */
+		MonoGenericClass *generic_class; /* for GENERICINST */
 	} data;
 	unsigned int attrs    : 16; /* param attributes or field flags */
 	unsigned int type     : 8;  /* ElementTypeEnum */
@@ -426,9 +426,9 @@ int            mono_type_size                  (MonoType        *type,
 int            mono_type_stack_size            (MonoType        *type, 
 						int             *alignment);
 
-gboolean       mono_metadata_generic_inst_is_valuetype (MonoGenericInst *ginst);
-guint          mono_metadata_generic_inst_hash  (MonoGenericInst *ginst);
-gboolean       mono_metadata_generic_inst_equal (MonoGenericInst *g1, MonoGenericInst *g2);
+gboolean       mono_metadata_generic_class_is_valuetype (MonoGenericClass *gclass);
+guint          mono_metadata_generic_class_hash  (MonoGenericClass *gclass);
+gboolean       mono_metadata_generic_class_equal (MonoGenericClass *g1, MonoGenericClass *g2);
 
 guint          mono_metadata_type_hash         (MonoType *t1);
 gboolean       mono_metadata_type_equal        (MonoType *t1, MonoType *t2);

mono/metadata/object-internals.h

@@ -808,8 +808,8 @@ typedef struct {
 	guint32 attrs;
 } MonoReflectionGenericParam;
 
-typedef struct _MonoReflectionGenericInst MonoReflectionGenericInst;
-struct _MonoReflectionGenericInst {
+typedef struct _MonoReflectionGenericClass MonoReflectionGenericClass;
+struct _MonoReflectionGenericClass {
 	MonoReflectionType type;
 	MonoReflectionType *generic_type;
 	guint32 initialized;
@@ -948,7 +948,7 @@ mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc
 MonoReflectionMethod*
 mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *method, MonoArray *types);
 void
-mono_reflection_generic_inst_initialize (MonoReflectionGenericInst *type, MonoArray *methods, MonoArray *ctors, MonoArray *fields, MonoArray *properties, MonoArray *events);
+mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *methods, MonoArray *ctors, MonoArray *fields, MonoArray *properties, MonoArray *events);
 MonoReflectionEvent *
 mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb);
 

mono/metadata/reflection.c

@@ -454,20 +454,20 @@ default_class_from_mono_type (MonoType *type)
 }
 
 static void
-encode_generic_inst (MonoDynamicImage *assembly, MonoGenericInst *ginst, char *p, char **endbuf)
+encode_generic_class (MonoDynamicImage *assembly, MonoGenericClass *gclass, char *p, char **endbuf)
 {
 	int i;
 
-	if (!ginst) {
+	if (!gclass) {
 		g_assert_not_reached ();
 		return;
 	}
 
 	mono_metadata_encode_value (MONO_TYPE_GENERICINST, p, &p);
-	encode_type (assembly, ginst->generic_type, p, &p);
-	mono_metadata_encode_value (ginst->type_argc, p, &p);
-	for (i = 0; i < ginst->type_argc; ++i)
-		encode_type (assembly, ginst->type_argv [i], p, &p);
+	encode_type (assembly, gclass->generic_type, p, &p);
+	mono_metadata_encode_value (gclass->type_argc, p, &p);
+	for (i = 0; i < gclass->type_argc; ++i)
+		encode_type (assembly, gclass->type_argv [i], p, &p);
 
 	*endbuf = p;
 }
@@ -532,7 +532,7 @@ encode_type (MonoDynamicImage *assembly, MonoType *type, char *p, char **endbuf)
 		mono_metadata_encode_value (0, p, &p);
 		break;
 	case MONO_TYPE_GENERICINST:
-		encode_generic_inst (assembly, type->data.generic_inst, p, &p);
+		encode_generic_class (assembly, type->data.generic_class, p, &p);
 		break;
 	case MONO_TYPE_VAR:
 	case MONO_TYPE_MVAR:
@@ -586,19 +586,19 @@ encode_custom_modifiers (MonoDynamicImage *assembly, MonoArray *modreq, MonoArra
 }
 
 static guint32
-generic_inst_get_signature_size (MonoGenericInst *ginst)
+generic_class_get_signature_size (MonoGenericClass *gclass)
 {
 	guint32 size = 0;
 	int i;
 
-	if (!ginst) {
+	if (!gclass) {
 		g_assert_not_reached ();
 	}
 
-	size += 1 + type_get_signature_size (ginst->generic_type);
+	size += 1 + type_get_signature_size (gclass->generic_type);
 	size += 4;
-	for (i = 0; i < ginst->type_argc; ++i)
-		size += type_get_signature_size (ginst->type_argv [i]);
+	for (i = 0; i < gclass->type_argc; ++i)
+		size += type_get_signature_size (gclass->type_argv [i]);
 
 	return size;
 }
@@ -645,7 +645,7 @@ type_get_signature_size (MonoType *type)
 	case MONO_TYPE_ARRAY:
 		return size + 7 + type_get_signature_size (&type->data.array->eklass->byval_arg);
 	case MONO_TYPE_GENERICINST:
-		return size + generic_inst_get_signature_size (type->data.generic_inst);
+		return size + generic_class_get_signature_size (type->data.generic_class);
 	case MONO_TYPE_VAR:
 	case MONO_TYPE_MVAR:
 		return size + 5;
@@ -2192,9 +2192,9 @@ create_typespec (MonoDynamicImage *assembly, MonoType *type)
 	case MONO_TYPE_CLASS:
 	case MONO_TYPE_VALUETYPE: {
 		MonoClass *k = mono_class_from_mono_type (type);
-		if (!k || !k->generic_inst)
+		if (!k || !k->generic_class)
 			return 0;
-		encode_generic_inst (assembly, k->generic_inst, p, &p);
+		encode_generic_class (assembly, k->generic_class, p, &p);
 		break;
 	}
 	default:
@@ -3551,7 +3551,7 @@ fixup_method (MonoReflectionILGen *ilgen, gpointer value, MonoDynamicImage *asse
 			} else if (!strcmp (iltoken->member->vtable->klass->name, "MonoMethod") ||
 				   !strcmp (iltoken->member->vtable->klass->name, "MonoCMethod")) {
 				MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method;
-				g_assert (m->klass->generic_inst);
+				g_assert (m->klass->generic_class);
 				continue;
 			} else if (!strcmp (iltoken->member->vtable->klass->name, "FieldBuilder")) {
 				continue;
@@ -4108,7 +4108,7 @@ mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj, gboolean c
 		MonoReflectionType *tb = (MonoReflectionType *)obj;
 		token = mono_metadata_token_from_dor (
 			mono_image_typedef_or_ref (assembly, tb->type));
-	} else if (strcmp (klass->name, "MonoGenericInst") == 0) {
+	} else if (strcmp (klass->name, "MonoGenericClass") == 0) {
 		MonoReflectionType *tb = (MonoReflectionType *)obj;
 		token = mono_metadata_token_from_dor (
 			mono_image_typedef_or_ref (assembly, tb->type));
@@ -4121,7 +4121,7 @@ mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj, gboolean c
 			else
 				token = mono_image_get_inflated_method_token (assembly, m->method);
 		} else if ((m->method->klass->image == &assembly->image) &&
-			 !m->method->klass->generic_inst) {
+			 !m->method->klass->generic_class) {
 			static guint32 method_table_idx = 0xffffff;
 			if (m->method->klass->wastypebuilder) {
 				/* we use the same token as the one that was assigned
@@ -5194,12 +5194,12 @@ mymono_metadata_type_equal (MonoType *t1, MonoType *t2)
 		return t1->data.array->eklass == t2->data.array->eklass;
 	case MONO_TYPE_GENERICINST: {
 		int i;
-		if (t1->data.generic_inst->type_argc != t2->data.generic_inst->type_argc)
+		if (t1->data.generic_class->type_argc != t2->data.generic_class->type_argc)
 			return FALSE;
-		if (!mono_metadata_type_equal (t1->data.generic_inst->generic_type, t2->data.generic_inst->generic_type))
+		if (!mono_metadata_type_equal (t1->data.generic_class->generic_type, t2->data.generic_class->generic_type))
 			return FALSE;
-		for (i = 0; i < t1->data.generic_inst->type_argc; ++i) {
-			if (!mono_metadata_type_equal (t1->data.generic_inst->type_argv [i], t2->data.generic_inst->type_argv [i]))
+		for (i = 0; i < t1->data.generic_class->type_argc; ++i) {
+			if (!mono_metadata_type_equal (t1->data.generic_class->type_argv [i], t2->data.generic_class->type_argv [i]))
 				return FALSE;
 		}
 		return TRUE;
@@ -5235,32 +5235,32 @@ mymono_metadata_type_hash (MonoType *t1)
 	return hash;
 }
 
-static MonoReflectionGenericInst*
-mono_generic_inst_get_object (MonoDomain *domain, MonoType *geninst)
+static MonoReflectionGenericClass*
+mono_generic_class_get_object (MonoDomain *domain, MonoType *geninst)
 {
-	static MonoClass *System_Reflection_MonoGenericInst;
-	MonoReflectionGenericInst *res;
-	MonoGenericInst *ginst;
+	static MonoClass *System_Reflection_MonoGenericClass;
+	MonoReflectionGenericClass *res;
+	MonoGenericClass *gclass;
 	MonoClass *gklass;
 
-	if (!System_Reflection_MonoGenericInst) {
-		System_Reflection_MonoGenericInst = mono_class_from_name (
-			mono_defaults.corlib, "System.Reflection", "MonoGenericInst");
-		g_assert (System_Reflection_MonoGenericInst);
+	if (!System_Reflection_MonoGenericClass) {
+		System_Reflection_MonoGenericClass = mono_class_from_name (
+			mono_defaults.corlib, "System.Reflection", "MonoGenericClass");
+		g_assert (System_Reflection_MonoGenericClass);
 	}
 
-	ginst = geninst->data.generic_inst;
-	gklass = mono_class_from_mono_type (ginst->generic_type);
+	gclass = geninst->data.generic_class;
+	gklass = mono_class_from_mono_type (gclass->generic_type);
 
-	mono_class_init (ginst->klass);
+	mono_class_init (gclass->klass);
 
-	res = (MonoReflectionGenericInst *) mono_object_new (domain, System_Reflection_MonoGenericInst);
+	res = (MonoReflectionGenericClass *) mono_object_new (domain, System_Reflection_MonoGenericClass);
 
 	res->type.type = geninst;
 	if (gklass->wastypebuilder && gklass->reflection_info)
 		res->generic_type = gklass->reflection_info;
 	else
-		res->generic_type = mono_type_get_object (domain, ginst->generic_type);
+		res->generic_type = mono_type_get_object (domain, gclass->generic_type);
 
 	return res;
 }
@@ -5286,8 +5286,8 @@ mono_type_get_object (MonoDomain *domain, MonoType *type)
 		mono_domain_unlock (domain);
 		return res;
 	}
-	if ((type->type == MONO_TYPE_GENERICINST) && type->data.generic_inst->is_dynamic) {
-		res = (MonoReflectionType *)mono_generic_inst_get_object (domain, type);
+	if ((type->type == MONO_TYPE_GENERICINST) && type->data.generic_class->is_dynamic) {
+		res = (MonoReflectionType *)mono_generic_class_get_object (domain, type);
 		mono_g_hash_table_insert (domain->type_hash, type, res);
 		mono_domain_unlock (domain);
 		return res;
@@ -5590,7 +5590,7 @@ get_default_param_value_blobs (MonoMethod *method, char **blobs)
 	if (!methodsig->param_count)
 		return;
 
-	if (klass->generic_inst) {
+	if (klass->generic_class) {
 		return; /* FIXME - ??? */
 	}
 
@@ -6118,7 +6118,7 @@ mono_reflection_get_token (MonoObject *obj)
 			g_assert_not_reached ();
 		} else if (m->method->signature->generic_param_count) {
 			g_assert_not_reached ();
-		} else if (m->method->klass->generic_inst) {
+		} else if (m->method->klass->generic_class) {
 			g_assert_not_reached ();
 		} else {
 			token = m->method->token;
@@ -6709,7 +6709,7 @@ mono_custom_attrs_from_param (MonoMethod *method, guint32 param)
 	method_index = find_method_index (method);
 	ca = &image->tables [MONO_TABLE_METHOD];
 
-	if (method->klass->generic_inst || method->klass->generic_container ||
+	if (method->klass->generic_class || method->klass->generic_container ||
 	    method->signature->generic_param_count) {
 		/* FIXME FIXME FIXME */
 		return NULL;
@@ -7805,13 +7805,13 @@ do_mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_a
 {
 	MonoClass *klass, *gklass;
 	MonoReflectionTypeBuilder *tb = NULL;
-	MonoGenericInst *ginst, *cached;
+	MonoGenericClass *gclass, *cached;
 	MonoDomain *domain;
 	MonoType *geninst;
 	int icount, i;
 
 	klass = mono_class_from_mono_type (type->type);
-	if (!klass->generic_container && !klass->generic_inst &&
+	if (!klass->generic_container && !klass->generic_class &&
 	    !(klass->nested_in && klass->nested_in->generic_container))
 		return NULL;
 
@@ -7819,85 +7819,85 @@ do_mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_a
 
 	domain = mono_object_domain (type);
 
-	ginst = g_new0 (MonoGenericInst, 1);
+	gclass = g_new0 (MonoGenericClass, 1);
 
-	ginst->type_argc = type_argc;
-	ginst->type_argv = types;
+	gclass->type_argc = type_argc;
+	gclass->type_argv = types;
 
-	for (i = 0; i < ginst->type_argc; ++i) {
-		if (!ginst->is_open)
-			ginst->is_open = mono_class_is_open_constructed_type (types [i]);
+	for (i = 0; i < gclass->type_argc; ++i) {
+		if (!gclass->is_open)
+			gclass->is_open = mono_class_is_open_constructed_type (types [i]);
 	}
 
-	ginst->generic_type = &klass->byval_arg;
+	gclass->generic_type = &klass->byval_arg;
 
-	if (klass->generic_inst) {
-		MonoGenericInst *kginst = klass->generic_inst;
-		MonoGenericInst *oginst = ginst;
+	if (klass->generic_class) {
+		MonoGenericClass *kgclass = klass->generic_class;
+		MonoGenericClass *ogclass = gclass;
 
-		oginst->context = g_new0 (MonoGenericContext, 1);
-		oginst->context->ginst = oginst;
+		ogclass->context = g_new0 (MonoGenericContext, 1);
+		ogclass->context->gclass = ogclass;
 
-		ginst = g_new0 (MonoGenericInst, 1);
+		gclass = g_new0 (MonoGenericClass, 1);
 
-		ginst->type_argc = kginst->type_argc;
-		ginst->type_argv = g_new0 (MonoType *, ginst->type_argc);
+		gclass->type_argc = kgclass->type_argc;
+		gclass->type_argv = g_new0 (MonoType *, gclass->type_argc);
 
-		for (i = 0; i < ginst->type_argc; i++) {
-			MonoType *t = kginst->type_argv [i];
+		for (i = 0; i < gclass->type_argc; i++) {
+			MonoType *t = kgclass->type_argv [i];
 
-			t = mono_class_inflate_generic_type (t, oginst->context);
+			t = mono_class_inflate_generic_type (t, ogclass->context);
 
-			if (!ginst->is_open)
-				ginst->is_open = mono_class_is_open_constructed_type (t);
+			if (!gclass->is_open)
+				gclass->is_open = mono_class_is_open_constructed_type (t);
 
-			ginst->type_argv [i] = t;
+			gclass->type_argv [i] = t;
 		}
 
-		ginst->generic_type = kginst->generic_type;
+		gclass->generic_type = kgclass->generic_type;
 	}
 
 	geninst = g_new0 (MonoType, 1);
 	geninst->type = MONO_TYPE_GENERICINST;
 
-	cached = g_hash_table_lookup (klass->image->generic_inst_cache, ginst);
+	cached = g_hash_table_lookup (klass->image->generic_class_cache, gclass);
 	if (cached) {
-		g_free (ginst);
+		g_free (gclass);
 		mono_loader_unlock ();
-		geninst->data.generic_inst = cached;
+		geninst->data.generic_class = cached;
 		return geninst;
 	}
 
-	gklass = mono_class_from_mono_type (ginst->generic_type);
-	g_assert ((ginst->container = gklass->generic_container) != NULL);
+	gklass = mono_class_from_mono_type (gclass->generic_type);
+	g_assert ((gclass->container = gklass->generic_container) != NULL);
 
-	geninst->data.generic_inst = ginst;
+	geninst->data.generic_class = gclass;
 
-	ginst->parent = parent;
+	gclass->parent = parent;
 
-	ginst->context = g_new0 (MonoGenericContext, 1);
-	ginst->context->ginst = ginst;
+	gclass->context = g_new0 (MonoGenericContext, 1);
+	gclass->context->gclass = gclass;
 
 	if (!strcmp (((MonoObject *) type)->vtable->klass->name, "TypeBuilder")) {
 		tb = (MonoReflectionTypeBuilder *) type;
 
 		icount = tb->interfaces ? mono_array_length (tb->interfaces) : 0;
-		ginst->is_dynamic = TRUE;
-	} else if (!strcmp (((MonoObject *) type)->vtable->klass->name, "MonoGenericInst")) {
-		MonoReflectionGenericInst *rgi = (MonoReflectionGenericInst *) type;
+		gclass->is_dynamic = TRUE;
+	} else if (!strcmp (((MonoObject *) type)->vtable->klass->name, "MonoGenericClass")) {
+		MonoReflectionGenericClass *rgi = (MonoReflectionGenericClass *) type;
 		MonoReflectionType *rgt = rgi->generic_type;
 
 		g_assert (!strcmp (((MonoObject *) rgt)->vtable->klass->name, "TypeBuilder"));
 		tb = (MonoReflectionTypeBuilder *) rgt;
 
 		icount = tb->interfaces ? mono_array_length (tb->interfaces) : 0;
-		ginst->is_dynamic = TRUE;
+		gclass->is_dynamic = TRUE;
 	} else {
 		icount = klass->interface_count;
 	}
 
-	ginst->ifaces = g_new0 (MonoType *, icount);
-	ginst->count_ifaces = icount;
+	gclass->ifaces = g_new0 (MonoType *, icount);
+	gclass->count_ifaces = icount;
 
 	for (i = 0; i < icount; i++) {
 		MonoReflectionType *itype;
@@ -7906,15 +7906,15 @@ do_mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_a
 			itype = mono_array_get (tb->interfaces, MonoReflectionType *, i);
 		else
 			itype = mono_type_get_object (domain, &klass->interfaces [i]->byval_arg);
-		ginst->ifaces [i] = mono_reflection_bind_generic_parameters (itype, type_argc, types);
-		if (!ginst->ifaces [i])
-			ginst->ifaces [i] = itype->type;
+		gclass->ifaces [i] = mono_reflection_bind_generic_parameters (itype, type_argc, types);
+		if (!gclass->ifaces [i])
+			gclass->ifaces [i] = itype->type;
 	}
 
-	mono_class_create_generic (ginst);
-	mono_class_create_generic_2 (ginst);
+	mono_class_create_generic (gclass);
+	mono_class_create_generic_2 (gclass);
 
-	g_hash_table_insert (klass->image->generic_inst_cache, ginst, ginst);
+	g_hash_table_insert (klass->image->generic_class_cache, gclass, gclass);
 
 	mono_loader_unlock ();
 
@@ -7928,7 +7928,7 @@ mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc
 	MonoReflectionType *parent = NULL;
 	MonoType *the_parent = NULL, *geninst;
 	MonoReflectionTypeBuilder *tb = NULL;
-	MonoGenericInst *ginst;
+	MonoGenericClass *gclass;
 	MonoDomain *domain;
 
 	domain = mono_object_domain (type);
@@ -7945,20 +7945,20 @@ mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc
 		pklass = klass->parent;
 		if (pklass)
 			parent = mono_type_get_object (domain, &pklass->byval_arg);
-		else if (klass->generic_inst && klass->generic_inst->parent) {
-			parent = mono_type_get_object (domain, klass->generic_inst->parent);
-			pklass = mono_class_from_mono_type (klass->generic_inst->parent);
+		else if (klass->generic_class && klass->generic_class->parent) {
+			parent = mono_type_get_object (domain, klass->generic_class->parent);
+			pklass = mono_class_from_mono_type (klass->generic_class->parent);
 		}
 	}
 
-	if (pklass && pklass->generic_inst)
+	if (pklass && pklass->generic_class)
 		the_parent = mono_reflection_bind_generic_parameters (parent, type_argc, types);
 
 	geninst = do_mono_reflection_bind_generic_parameters (type, type_argc, types, the_parent);
 	if (!geninst)
 		return NULL;
 
-	ginst = geninst->data.generic_inst;
+	gclass = geninst->data.generic_class;
 
 	return geninst;
 }
@@ -8017,7 +8017,7 @@ mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *rmethod, M
 	gmethod->reflection_info = rmethod;
 
 	context = g_new0 (MonoGenericContext, 1);
-	context->ginst = method->klass->generic_inst;
+	context->gclass = method->klass->generic_class;
 	context->gmethod = gmethod;
 
 	inflated = mono_class_inflate_generic_method (method, context, NULL);
@@ -8027,14 +8027,14 @@ mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *rmethod, M
 }
 
 static MonoMethod *
-inflate_mono_method (MonoReflectionGenericInst *type, MonoMethod *method, MonoObject *obj)
+inflate_mono_method (MonoReflectionGenericClass *type, MonoMethod *method, MonoObject *obj)
 {
 	MonoGenericMethod *gmethod;
-	MonoGenericInst *ginst;
+	MonoGenericClass *gclass;
 	MonoGenericContext *context;
 	int i;
 
-	ginst = type->type.type->data.generic_inst;
+	gclass = type->type.type->data.generic_class;
 
 	gmethod = g_new0 (MonoGenericMethod, 1);
 	gmethod->reflection_info = obj;
@@ -8051,14 +8051,14 @@ inflate_mono_method (MonoReflectionGenericInst *type, MonoMethod *method, MonoOb
 	}
 
 	context = g_new0 (MonoGenericContext, 1);
-	context->ginst = ginst;
+	context->gclass = gclass;
 	context->gmethod = gmethod;
 
-	return mono_class_inflate_generic_method (method, context, ginst->klass);
+	return mono_class_inflate_generic_method (method, context, gclass->klass);
 }
 
 static MonoMethod *
-inflate_method (MonoReflectionGenericInst *type, MonoObject *obj)
+inflate_method (MonoReflectionGenericClass *type, MonoObject *obj)
 {
 	MonoMethod *method;
 	MonoClass *klass;
@@ -8080,59 +8080,60 @@ inflate_method (MonoReflectionGenericInst *type, MonoObject *obj)
 }
 
 void
-mono_reflection_generic_inst_initialize (MonoReflectionGenericInst *type, MonoArray *methods, 
-	MonoArray *ctors, MonoArray *fields, MonoArray *properties, MonoArray *events)
+mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *methods, 
+					  MonoArray *ctors, MonoArray *fields, MonoArray *properties,
+					  MonoArray *events)
 {
-	MonoGenericInst *ginst;
-	MonoDynamicGenericInst *dginst;
+	MonoGenericClass *gclass;
+	MonoDynamicGenericClass *dgclass;
 	MonoClass *klass, *gklass, *pklass;
 	int i;
 
 	MONO_ARCH_SAVE_REGS;
 
 	klass = mono_class_from_mono_type (type->type.type);
-	ginst = type->type.type->data.generic_inst;
+	gclass = type->type.type->data.generic_class;
 
-	if (ginst->initialized)
+	if (gclass->initialized)
 		return;
 
-	dginst = ginst->dynamic_info = g_new0 (MonoDynamicGenericInst, 1);
+	dgclass = gclass->dynamic_info = g_new0 (MonoDynamicGenericClass, 1);
 
-	gklass = mono_class_from_mono_type (ginst->generic_type);
+	gklass = mono_class_from_mono_type (gclass->generic_type);
 	mono_class_init (gklass);
 
-	if (ginst->parent)
-		pklass = mono_class_from_mono_type (ginst->parent);
+	if (gclass->parent)
+		pklass = mono_class_from_mono_type (gclass->parent);
 	else
 		pklass = gklass->parent;
 
 	mono_class_setup_parent (klass, pklass);
 
-	dginst->count_methods = methods ? mono_array_length (methods) : 0;
-	dginst->count_ctors = ctors ? mono_array_length (ctors) : 0;
-	dginst->count_fields = fields ? mono_array_length (fields) : 0;
-	dginst->count_properties = properties ? mono_array_length (properties) : 0;
-	dginst->count_events = events ? mono_array_length (events) : 0;
+	dgclass->count_methods = methods ? mono_array_length (methods) : 0;
+	dgclass->count_ctors = ctors ? mono_array_length (ctors) : 0;
+	dgclass->count_fields = fields ? mono_array_length (fields) : 0;
+	dgclass->count_properties = properties ? mono_array_length (properties) : 0;
+	dgclass->count_events = events ? mono_array_length (events) : 0;
 
-	dginst->methods = g_new0 (MonoMethod *, dginst->count_methods);
-	dginst->ctors = g_new0 (MonoMethod *, dginst->count_ctors);
-	dginst->fields = g_new0 (MonoClassField, dginst->count_fields);
-	dginst->properties = g_new0 (MonoProperty, dginst->count_properties);
-	dginst->events = g_new0 (MonoEvent, dginst->count_events);
+	dgclass->methods = g_new0 (MonoMethod *, dgclass->count_methods);
+	dgclass->ctors = g_new0 (MonoMethod *, dgclass->count_ctors);
+	dgclass->fields = g_new0 (MonoClassField, dgclass->count_fields);
+	dgclass->properties = g_new0 (MonoProperty, dgclass->count_properties);
+	dgclass->events = g_new0 (MonoEvent, dgclass->count_events);
 
-	for (i = 0; i < dginst->count_methods; i++) {
+	for (i = 0; i < dgclass->count_methods; i++) {
 		MonoObject *obj = mono_array_get (methods, gpointer, i);
 
-		dginst->methods [i] = inflate_method (type, obj);
+		dgclass->methods [i] = inflate_method (type, obj);
 	}
 
-	for (i = 0; i < dginst->count_ctors; i++) {
+	for (i = 0; i < dgclass->count_ctors; i++) {
 		MonoObject *obj = mono_array_get (ctors, gpointer, i);
 
-		dginst->ctors [i] = inflate_method (type, obj);
+		dgclass->ctors [i] = inflate_method (type, obj);
 	}
 
-	for (i = 0; i < dginst->count_fields; i++) {
+	for (i = 0; i < dgclass->count_fields; i++) {
 		MonoObject *obj = mono_array_get (fields, gpointer, i);
 		MonoClassField *field;
 		MonoInflatedField *ifield;
@@ -8150,14 +8151,14 @@ mono_reflection_generic_inst_initialize (MonoReflectionGenericInst *type, MonoAr
 		ifield->generic_type = field->type;
 		ifield->reflection_info = obj;
 
-		dginst->fields [i] = *field;
-		dginst->fields [i].generic_info = ifield;
-		dginst->fields [i].type = mono_class_inflate_generic_type (field->type, ginst->context);
+		dgclass->fields [i] = *field;
+		dgclass->fields [i].generic_info = ifield;
+		dgclass->fields [i].type = mono_class_inflate_generic_type (field->type, gclass->context);
 	}
 
-	for (i = 0; i < dginst->count_properties; i++) {
+	for (i = 0; i < dgclass->count_properties; i++) {
 		MonoObject *obj = mono_array_get (properties, gpointer, i);
-		MonoProperty *property = &dginst->properties [i];
+		MonoProperty *property = &dgclass->properties [i];
 
 		if (!strcmp (obj->vtable->klass->name, "PropertyBuilder")) {
 			MonoReflectionPropertyBuilder *pb = (MonoReflectionPropertyBuilder *) obj;
@@ -8180,9 +8181,9 @@ mono_reflection_generic_inst_initialize (MonoReflectionGenericInst *type, MonoAr
 			g_assert_not_reached ();
 	}
 
-	for (i = 0; i < dginst->count_events; i++) {
+	for (i = 0; i < dgclass->count_events; i++) {
 		MonoObject *obj = mono_array_get (events, gpointer, i);
-		MonoEvent *event = &dginst->events [i];
+		MonoEvent *event = &dgclass->events [i];
 
 		if (!strcmp (obj->vtable->klass->name, "EventBuilder")) {
 			MonoReflectionEventBuilder *eb = (MonoReflectionEventBuilder *) obj;
@@ -8205,7 +8206,7 @@ mono_reflection_generic_inst_initialize (MonoReflectionGenericInst *type, MonoAr
 			g_assert_not_reached ();
 	}
 
-	ginst->initialized = TRUE;
+	gclass->initialized = TRUE;
 }
 
 static void

mono/mini/mini.c

@@ -897,7 +897,7 @@ handle_enum:
 	case MONO_TYPE_TYPEDBYREF:
 		return CEE_LDOBJ;
 	case MONO_TYPE_GENERICINST:
-		type = type->data.generic_inst->generic_type;
+		type = type->data.generic_class->generic_type;
 		goto handle_enum;
 	default:
 		g_error ("unknown type 0x%02x in type_to_ldind", type->type);
@@ -951,7 +951,7 @@ handle_enum:
 	case MONO_TYPE_TYPEDBYREF:
 		return CEE_STOBJ;
 	case MONO_TYPE_GENERICINST:
-		type = type->data.generic_inst->generic_type;
+		type = type->data.generic_class->generic_type;
 		goto handle_enum;
 	default:
 		g_error ("unknown type 0x%02x in type_to_stind", type->type);
@@ -1022,7 +1022,7 @@ handle_enum:
 		inst->type = STACK_VTYPE;
 		return;
 	case MONO_TYPE_GENERICINST:
-		type = type->data.generic_inst->generic_type;
+		type = type->data.generic_class->generic_type;
 		goto handle_enum;
 	default:
 		g_error ("unknown type 0x%02x in eval stack type", type->type);
@@ -1744,7 +1744,7 @@ handle_enum:
 	case MONO_TYPE_TYPEDBYREF:
 		return calli? OP_VCALL_REG: virt? OP_VCALLVIRT: OP_VCALL;
 	case MONO_TYPE_GENERICINST:
-		type = type->data.generic_inst->generic_type;
+		type = type->data.generic_class->generic_type;
 		goto handle_enum;
 	default:
 		g_error ("unknown type 0x%02x in ret_type_to_call_opcode", type->type);
@@ -1895,7 +1895,7 @@ handle_enum:
 				return 1;
 			continue;
 		case MONO_TYPE_GENERICINST:
-			simple_type = simple_type->data.generic_inst->generic_type;
+			simple_type = simple_type->data.generic_class->generic_type;
 			goto handle_enum;
 
 		default:
@@ -5855,7 +5855,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 				NEW_LOCSTORE (cfg, store, i, ins);
 				MONO_ADD_INS (init_localsbb, store);
 			} else if ((t == MONO_TYPE_VALUETYPE) || (t == MONO_TYPE_TYPEDBYREF) ||
-				   ((t == MONO_TYPE_GENERICINST) && mono_metadata_generic_inst_is_valuetype (ptype->data.generic_inst))) {
+				   ((t == MONO_TYPE_GENERICINST) && mono_metadata_generic_class_is_valuetype (ptype->data.generic_class))) {
 				NEW_LOCLOADA (cfg, ins, i);
 				handle_initobj (cfg, init_localsbb, ins, NULL, mono_class_from_mono_type (ptype), NULL, NULL);
 				break;