update known-issues

[mono.git] / mono / metadata / reflection.c

diff --git a/mono/metadata/reflection.c b/mono/metadata/reflection.c
index d9bd89e1972a59d6d9b3ffb45d7aa075b323cd48..442903f3b01fba43b1c6c34fd8a1bc4f89f8642e 100644 (file)
--- a/mono/metadata/reflection.c
+++ b/mono/metadata/reflection.c
@@ -149,6 +149,7 @@ static void get_default_param_value_blobs (MonoMethod *method, char **blobs, gui
 static MonoObject *mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob);
 static inline MonoType *dup_type (const MonoType *original);
 static MonoReflectionType *mono_reflection_type_get_underlying_system_type (MonoReflectionType* t);
+static MonoType* mono_reflection_get_type_with_rootimage (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve);
 
 #define mono_reflection_lock() EnterCriticalSection (&reflection_mutex)
 #define mono_reflection_unlock() LeaveCriticalSection (&reflection_mutex)
@@ -568,7 +569,7 @@ default_class_from_mono_type (MonoType *type)
        case MONO_TYPE_STRING:
                return mono_defaults.string_class;
        default:
-               g_warning ("implement me 0x%02x\n", type->type);
+               g_warning ("default_class_from_mono_type: implement me 0x%02x\n", type->type);
                g_assert_not_reached ();
        }
        
@@ -6281,6 +6282,7 @@ _mono_reflection_get_type_from_info (MonoTypeNameParse *info, MonoImage *image,
 {
        gboolean type_resolve = FALSE;
        MonoType *type;
+       MonoImage *rootimage = image;
 
        if (info->assembly.name) {
                MonoAssembly *assembly = mono_assembly_loaded (&info->assembly);
@@ -6295,17 +6297,17 @@ _mono_reflection_get_type_from_info (MonoTypeNameParse *info, MonoImage *image,
                image = mono_defaults.corlib;
        }
 
-       type = mono_reflection_get_type (image, info, ignorecase, &type_resolve);
+       type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve);
        if (type == NULL && !info->assembly.name && image != mono_defaults.corlib) {
                image = mono_defaults.corlib;
-               type = mono_reflection_get_type (image, info, ignorecase, &type_resolve);
+               type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve);
        }
 
        return type;
 }
 
 static MonoType*
-mono_reflection_get_type_internal (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase)
+mono_reflection_get_type_internal (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase)
 {
        MonoClass *klass;
        GList *mod;
@@ -6354,7 +6356,7 @@ mono_reflection_get_type_internal (MonoImage* image, MonoTypeNameParse *info, gb
                for (i = 0; i < info->type_arguments->len; i++) {
                        MonoTypeNameParse *subinfo = g_ptr_array_index (info->type_arguments, i);
 
-                       type_args [i] = _mono_reflection_get_type_from_info (subinfo, image, ignorecase);
+                       type_args [i] = _mono_reflection_get_type_from_info (subinfo, rootimage, ignorecase);
                        if (!type_args [i]) {
                                g_free (type_args);
                                return NULL;
@@ -6401,14 +6403,19 @@ mono_reflection_get_type_internal (MonoImage* image, MonoTypeNameParse *info, gb
  */
 
 MonoType*
-mono_reflection_get_type (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve)
+mono_reflection_get_type (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve) {
+       return mono_reflection_get_type_with_rootimage(image, image, info, ignorecase, type_resolve);
+}
+       
+MonoType*
+mono_reflection_get_type_with_rootimage (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve)
 {
        MonoType *type;
        MonoReflectionAssembly *assembly;
        GString *fullName;
        GList *mod;
 
-       type = mono_reflection_get_type_internal (image, info, ignorecase);
+       type = mono_reflection_get_type_internal (rootimage, image, info, ignorecase);
        if (type)
                return type;
        if (!mono_domain_has_type_resolve (mono_domain_get ()))
@@ -6441,7 +6448,7 @@ mono_reflection_get_type (MonoImage* image, MonoTypeNameParse *info, gboolean ig
                        if (abuilder->modules) {
                                for (i = 0; i < mono_array_length (abuilder->modules); ++i) {
                                        MonoReflectionModuleBuilder *mb = mono_array_get (abuilder->modules, MonoReflectionModuleBuilder*, i);
-                                       type = mono_reflection_get_type_internal (&mb->dynamic_image->image, info, ignorecase);
+                                       type = mono_reflection_get_type_internal (rootimage, &mb->dynamic_image->image, info, ignorecase);
                                        if (type)
                                                break;
                                }
@@ -6450,14 +6457,14 @@ mono_reflection_get_type (MonoImage* image, MonoTypeNameParse *info, gboolean ig
                        if (!type && abuilder->loaded_modules) {
                                for (i = 0; i < mono_array_length (abuilder->loaded_modules); ++i) {
                                        MonoReflectionModule *mod = mono_array_get (abuilder->loaded_modules, MonoReflectionModule*, i);
-                                       type = mono_reflection_get_type_internal (mod->image, info, ignorecase);
+                                       type = mono_reflection_get_type_internal (rootimage, mod->image, info, ignorecase);
                                        if (type)
                                                break;
                                }
                        }
                }
                else
-                       type = mono_reflection_get_type_internal (assembly->assembly->image, 
+                       type = mono_reflection_get_type_internal (rootimage, assembly->assembly->image, 
                                                                                                          info, ignorecase);
        }
        g_string_free (fullName, TRUE);
@@ -8287,6 +8294,11 @@ mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb)
 
                fb = mono_array_get (tb->fields, MonoReflectionFieldBuilder*, 0);
 
+               if (!mono_type_is_valid_enum_basetype (fb->type->type)) {
+                       mono_loader_unlock ();
+                       return;
+               }
+
                klass->enum_basetype = fb->type->type;
                klass->element_class = my_mono_class_from_mono_type (klass->enum_basetype);
                if (!klass->element_class)
@@ -8782,15 +8794,12 @@ mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **
        inst = g_new0 (MonoGenericInst, 1);
        inst->type_argc = type_argc;
        inst->type_argv = g_new0 (MonoType *, inst->type_argc);
-       inst->is_reference = 1;
 
        for (i = 0; i < inst->type_argc; ++i) {
                MonoType *t = dup_type (types [i]);
 
                if (!inst->is_open)
                        inst->is_open = mono_class_is_open_constructed_type (t);
-               if (inst->is_reference)
-                       inst->is_reference = MONO_TYPE_IS_REFERENCE (t);
 
                inst->type_argv [i] = t;
        }
@@ -8864,15 +8873,12 @@ mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *rmethod, M
        ginst = g_new0 (MonoGenericInst,1 );
        ginst->type_argc = count;
        ginst->type_argv = g_new0 (MonoType *, count);
-       ginst->is_reference = 1;
        for (i = 0; i < count; i++) {
                MonoReflectionType *garg = mono_array_get (types, gpointer, i);
                ginst->type_argv [i] = dup_type (garg->type);
 
                if (!ginst->is_open)
                        ginst->is_open = mono_class_is_open_constructed_type (ginst->type_argv [i]);
-               if (ginst->is_reference)
-                       ginst->is_reference = MONO_TYPE_IS_REFERENCE (ginst->type_argv [i]);
        }
        ginst = mono_metadata_lookup_generic_inst (ginst);
 
@@ -9398,11 +9404,16 @@ mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb)
        typebuilder_setup_properties (klass);
 
        typebuilder_setup_events (klass);
-
+       
        klass->wastypebuilder = TRUE;
        mono_loader_unlock ();
        mono_domain_unlock (domain);
 
+       if (klass->enumtype && !mono_class_is_valid_enum (klass)) {
+               mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL);
+               mono_raise_exception (mono_get_exception_type_load (tb->name, NULL));
+       }
+
        res = mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
        g_assert (res != (MonoReflectionType*)tb);