+static MonoType*
+reflection_instance_handle_mono_type (MonoReflectionGenericClassHandle ref_gclass, MonoError *error)
+{
+ HANDLE_FUNCTION_ENTER ();
+ MonoType *result = NULL;
+ MonoType **types = NULL;
+
+ MonoArrayHandle typeargs = MONO_HANDLE_NEW_GET (MonoArray, ref_gclass, type_arguments);
+ int count = mono_array_handle_length (typeargs);
+ types = g_new0 (MonoType*, count);
+ MonoReflectionTypeHandle t = MONO_HANDLE_NEW (MonoReflectionType, NULL);
+ for (int i = 0; i < count; ++i) {
+ MONO_HANDLE_ARRAY_GETREF (t, typeargs, i);
+ types [i] = mono_reflection_type_handle_mono_type (t, error);
+ if (!types[i] || !is_ok (error)) {
+ goto leave;
+ }
+ }
+ /* Need to resolve the generic_type in order for it to create its generic context. */
+ MonoReflectionTypeHandle ref_gtd = MONO_HANDLE_NEW_GET (MonoReflectionType, ref_gclass, generic_type);
+ MonoType *gtd = mono_reflection_type_handle_mono_type (ref_gtd, error);
+ if (!is_ok (error)) {
+ goto leave;
+ }
+ MonoClass *gtd_klass = mono_class_from_mono_type (gtd);
+ if (is_sre_type_builder (mono_handle_class (ref_gtd))) {
+ reflection_create_generic_class (MONO_HANDLE_CAST (MonoReflectionTypeBuilder, ref_gtd), error);
+ if (!is_ok (error)) {
+ goto leave;
+ }
+ }
+ g_assert (count == 0 || mono_class_is_gtd (gtd_klass));
+ result = mono_reflection_bind_generic_parameters (ref_gtd, count, types, error);
+ if (!is_ok (error))
+ goto leave;
+ g_assert (result);
+ MONO_HANDLE_SETVAL (MONO_HANDLE_CAST (MonoReflectionType, ref_gclass), type, MonoType*, result);
+leave:
+ g_free (types);
+ HANDLE_FUNCTION_RETURN_VAL (result);
+}
+
+static MonoType*
+reflection_param_handle_mono_type (MonoReflectionGenericParamHandle ref_gparam, MonoError *error)
+{
+ HANDLE_FUNCTION_ENTER ();
+ error_init (error);
+ MonoType *result = NULL;
+
+
+ MonoReflectionTypeBuilderHandle ref_tbuilder = MONO_HANDLE_NEW_GET (MonoReflectionTypeBuilder, ref_gparam, tbuilder);
+ MonoReflectionModuleBuilderHandle ref_module = MONO_HANDLE_NEW_GET (MonoReflectionModuleBuilder, ref_tbuilder, module);
+ MonoDynamicImage *dynamic_image = MONO_HANDLE_GETVAL (ref_module, dynamic_image);
+ MonoImage *image = &dynamic_image->image;
+
+ MonoGenericParamFull *param = mono_image_new0 (image, MonoGenericParamFull, 1);
+
+ MonoStringHandle ref_name = MONO_HANDLE_NEW_GET (MonoString, ref_gparam, name);
+ param->info.name = mono_string_to_utf8_image (image, ref_name, error);
+ mono_error_assert_ok (error);
+ param->param.num = MONO_HANDLE_GETVAL (ref_gparam, index);
+
+ MonoReflectionMethodBuilderHandle ref_mbuilder = MONO_HANDLE_NEW_GET (MonoReflectionMethodBuilder, ref_gparam, mbuilder);
+ if (!MONO_HANDLE_IS_NULL (ref_mbuilder)) {
+ MonoGenericContainer *generic_container = MONO_HANDLE_GETVAL (ref_mbuilder, generic_container);
+ if (!generic_container) {
+ generic_container = (MonoGenericContainer *)mono_image_alloc0 (image, sizeof (MonoGenericContainer));
+ generic_container->is_method = TRUE;
+ /*
+ * Cannot set owner.method, since the MonoMethod is not created yet.
+ * Set the image field instead, so type_in_image () works.
+ */
+ generic_container->is_anonymous = TRUE;
+ generic_container->owner.image = image;
+ MONO_HANDLE_SETVAL (ref_mbuilder, generic_container, MonoGenericContainer*, generic_container);
+ }
+ param->param.owner = generic_container;
+ } else {
+ MonoType *type = mono_reflection_type_handle_mono_type (MONO_HANDLE_CAST (MonoReflectionType, ref_tbuilder), error);
+ if (!is_ok (error))
+ goto leave;
+ MonoClass *owner = mono_class_from_mono_type (type);
+ g_assert (mono_class_is_gtd (owner));
+ param->param.owner = mono_class_get_generic_container (owner);
+ }
+
+ MonoClass *pklass = mono_class_from_generic_parameter_internal ((MonoGenericParam *) param);
+
+ result = &pklass->byval_arg;
+
+ mono_class_set_ref_info (pklass, MONO_HANDLE_CAST (MonoObject, ref_gparam));
+ mono_image_append_class_to_reflection_info_set (pklass);
+
+ MONO_HANDLE_SETVAL (MONO_HANDLE_CAST (MonoReflectionType, ref_gparam), type, MonoType*, result);
+
+leave:
+ HANDLE_FUNCTION_RETURN_VAL (result);
+}
+
+static MonoType*
+mono_type_array_get_and_resolve_raw (MonoArray* array_raw, int idx, MonoError *error)
+{
+ HANDLE_FUNCTION_ENTER(); /* FIXME callers of mono_type_array_get_and_resolve_raw should use handles */
+ error_init (error);
+ MONO_HANDLE_DCL (MonoArray, array);
+ MonoType *result = mono_type_array_get_and_resolve (array, idx, error);
+ HANDLE_FUNCTION_RETURN_VAL (result);
+}
+
+MonoType*
+mono_reflection_type_handle_mono_type (MonoReflectionTypeHandle ref, MonoError *error)
+{
+ HANDLE_FUNCTION_ENTER ();
+ error_init (error);
+
+ MonoType* result = NULL;
+
+ g_assert (ref);
+ if (MONO_HANDLE_IS_NULL (ref))
+ goto leave;
+ MonoType *t = MONO_HANDLE_GETVAL (ref, type);
+ if (t) {
+ result = t;
+ goto leave;
+ }