[mono-error] Replace mono_metadata_parse_type_full with mono_metadata_parse_type_checked.

diff --git a/mono/dis/get.c b/mono/dis/get.c
index 3dbc1f7a79b1b7a9c355a889158c28a34cf61554..a5d3faae04c1d7acfd6cff44c0b6f3c94f088cb6 100755 (executable)
--- a/mono/dis/get.c
+++ b/mono/dis/get.c
@@ -1269,6 +1269,7 @@ dis_stringify_type (MonoImage *m, MonoType *type, gboolean is_def)
 const char *
 get_type (MonoImage *m, const char *ptr, char **result, gboolean is_def, MonoGenericContainer *container)
 {
+       MonoError error;
        const char *start = ptr;
        guint32 type;
        MonoType *t;
@@ -1323,23 +1324,12 @@ get_type (MonoImage *m, const char *ptr, char **result, gboolean is_def, MonoGen
        }
 
        default:
-               t = mono_metadata_parse_type_full (m, container, 0, start, &ptr);
+               t = mono_metadata_parse_type_checked (m, container, 0, FALSE, start, &ptr, &error);
                if (t) {
                        *result = dis_stringify_type (m, t, is_def);
                } else {
-                       GString *err = g_string_new ("@!#$<InvalidType>$#!@");
-                       if (container)
-                               t = mono_metadata_parse_type_full (m, NULL, 0, start, &ptr);
-                       if (t) {
-                               char *name = dis_stringify_type (m, t, is_def);
-                               g_warning ("Encountered a generic type inappropriate for its context");
-                               g_string_append (err, " // ");
-                               g_string_append (err, name);
-                               g_free (name);
-                       } else {
-                               g_warning ("Encountered an invalid type");
-                       }
-                       *result = g_string_free (err, FALSE);
+                       *result = g_strdup_printf ("Invalid type due to %s", mono_error_get_message (&error));
+                       mono_error_cleanup (&error);
                }
 
                break;

diff --git a/mono/dis/main.c b/mono/dis/main.c
index 6a96e4329e1c85db0164f0e0263b2c15791aeb06..e8538ea31be80ed83721bfaf8bf0e5fd95bb492c 100644 (file)
--- a/mono/dis/main.c
+++ b/mono/dis/main.c
@@ -958,6 +958,7 @@ dis_property_methods (MonoImage *m, guint32 prop, MonoGenericContainer *containe
 static char*
 dis_property_signature (MonoImage *m, guint32 prop_idx, MonoGenericContainer *container)
 {
+       MonoError error;
        MonoTableInfo *propt = &m->tables [MONO_TABLE_PROPERTY];
        const char *ptr;
        guint32 pcount, i;
@@ -980,8 +981,13 @@ dis_property_signature (MonoImage *m, guint32 prop_idx, MonoGenericContainer *co
                g_string_append (res, "instance ");
        ptr++;
        pcount = mono_metadata_decode_value (ptr, &ptr);
-       type = mono_metadata_parse_type_full (m, container, 0, ptr, &ptr);
-       blurb = dis_stringify_type (m, type, TRUE);
+       type = mono_metadata_parse_type_checked (m, container, 0, FALSE, ptr, &ptr, &error);
+       if (type) {
+               blurb = dis_stringify_type (m, type, TRUE);
+       } else {
+               blurb = g_strdup_printf ("Invalid type due to %s", mono_error_get_message (&error));
+               mono_error_cleanup (&error);
+       }
        if (prop_flags & 0x0200)
                g_string_append (res, "specialname ");
        if (prop_flags & 0x0400)
@@ -993,8 +999,14 @@ dis_property_signature (MonoImage *m, guint32 prop_idx, MonoGenericContainer *co
        for (i = 0; i < pcount; i++) {
                if (i)
                        g_string_append (res, ", ");
-               param = mono_metadata_parse_type_full (m, container, 0, ptr, &ptr);
-               blurb = dis_stringify_param (m, param);
+               param = mono_metadata_parse_type_checked (m, container, 0, FALSE, ptr, &ptr, &error);
+               if (type) {
+                       blurb = dis_stringify_param (m, param);
+               } else {
+                       blurb = g_strdup_printf ("Invalid type due to %s", mono_error_get_message (&error));
+                       mono_error_cleanup (&error);
+               }
+
                g_string_append (res, blurb);
                g_free (blurb);
        }

diff --git a/mono/metadata/class.c b/mono/metadata/class.c
index e9e693a1f5f2415b93b3447511eb3fe48b35ceab..983f1ca4149d90e78ab62646b4c9983b3d2a415d 100644 (file)
--- a/mono/metadata/class.c
+++ b/mono/metadata/class.c
@@ -1350,14 +1350,10 @@ mono_class_find_enum_basetype (MonoClass *klass, MonoError *error)
                        goto fail;
                }
 
-               ftype = mono_metadata_parse_type_full (m, container, cols [MONO_FIELD_FLAGS], sig + 1, &sig);
-               if (!ftype) {
-                       if (mono_loader_get_last_error ()) /*FIXME plug the above to not leak errors*/
-                               mono_error_set_from_loader_error (error);
-                       else
-                               mono_error_set_bad_image (error, klass->image, "Could not parse type for field signature %x", cols [MONO_FIELD_SIGNATURE]);
+               ftype = mono_metadata_parse_type_checked (m, container, cols [MONO_FIELD_FLAGS], FALSE, sig + 1, &sig, error);
+               if (!ftype)
                        goto fail;
-               }
+
                if (klass->generic_class) {
                        //FIXME do we leak here?
                        ftype = mono_class_inflate_generic_type_checked (ftype, mono_class_get_context (klass), error);
@@ -10686,14 +10682,12 @@ mono_field_resolve_type (MonoClassField *field, MonoError *error)
                if (!mono_error_ok (error)) {
                        char *err_msg = g_strdup_printf ("Could not load field %d type due to: %s", field_idx, mono_error_get_message (error));
                        mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, err_msg);
-                       g_free (err_msg);
                }
 
                field->type = mono_class_inflate_generic_type_no_copy (image, gtype, mono_class_get_context (klass), error);
                if (!mono_error_ok (error)) {
                        char *err_msg = g_strdup_printf ("Could not load field %d type due to: %s", field_idx, mono_error_get_message (error));
                        mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, err_msg);
-                       g_free (err_msg);
                }
        } else {
                const char *sig;
@@ -10715,8 +10709,8 @@ mono_field_resolve_type (MonoClassField *field, MonoError *error)
                mono_metadata_decode_table_row (image, MONO_TABLE_FIELD, idx, cols, MONO_FIELD_SIZE);
 
                if (!mono_verifier_verify_field_signature (image, cols [MONO_FIELD_SIGNATURE], NULL)) {
-                       mono_error_set_type_load_class (error, klass, "Could not verify field %s signature", field->name);
-                       mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL);
+                       mono_error_set_type_load_class (error, klass, "Could not verify field %s signature", field->name);;
+                       mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, g_strdup (mono_error_get_message (error)));
                        return;
                }
 
@@ -10725,9 +10719,12 @@ mono_field_resolve_type (MonoClassField *field, MonoError *error)
                mono_metadata_decode_value (sig, &sig);
                /* FIELD signature == 0x06 */
                g_assert (*sig == 0x06);
-               field->type = mono_metadata_parse_type_full (image, container, cols [MONO_FIELD_FLAGS], sig + 1, &sig);
-               if (!field->type)
-                       mono_class_set_failure_from_loader_error (klass, error, g_strdup_printf ("Could not load field %s type", field->name));
+
+               field->type = mono_metadata_parse_type_checked (image, container, cols [MONO_FIELD_FLAGS], FALSE, sig + 1, &sig, error);
+               if (!field->type) {
+                       char *err_msg = g_strdup_printf ("Could not load field %d type due to: %s", field_idx, mono_error_get_message (error));
+                       mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, err_msg);
+               }
        }
 }