Remove MirroredCompilationError from the VM.

runtime/lib/mirrors.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "lib/invocation_mirror.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/port.h"
 #include "vm/resolver.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
-DEFINE_FLAG(bool, use_mirrored_compilation_error, false,
-    "Wrap compilation errors that occur during reflective access in a "
-    "MirroredCompilationError, rather than suspending the isolate.");
-
 static RawInstance* CreateMirror(const String& mirror_class_name,
                                  const Array& constructor_arguments) {
   const Library& mirrors_lib = Library::Handle(Library::MirrorsLibrary());
   const String& constructor_name = Symbols::Dot();
 
   const Object& result = Object::Handle(
       DartLibraryCalls::InstanceCreate(mirrors_lib,
                                        mirror_class_name,
                                        constructor_name,
                                        constructor_arguments));
   ASSERT(!result.IsError());
   return Instance::Cast(result).raw();
 }
 
 
-static void ThrowMirroredCompilationError(const String& message) {
-  Array& args = Array::Handle(Array::New(1));
-  args.SetAt(0, message);
-
-  Exceptions::ThrowByType(Exceptions::kMirroredCompilationError, args);
-  UNREACHABLE();
-}
-
-
-static void ThrowInvokeError(const Error& error) {
-  if (FLAG_use_mirrored_compilation_error && error.IsLanguageError()) {
-    // A compilation error that was delayed by lazy compilation.
-    const LanguageError& compilation_error = LanguageError::Cast(error);
-    String& message = String::Handle(compilation_error.FormatMessage());
-    ThrowMirroredCompilationError(message);
-    UNREACHABLE();
-  }
-  Exceptions::PropagateError(error);
-  UNREACHABLE();
-}
-
-
 // Conventions:
 // * For throwing a NSM in a class klass we use its runtime type as receiver,
 //   i.e., klass.RareType().
 // * For throwing a NSM in a library, we just pass the null instance as
 //   receiver.
 static void ThrowNoSuchMethod(const Instance& receiver,
                               const String& function_name,
                               const Function& function,
                               const Array& arguments,
                               const InvocationMirror::Call call,
@@ skipping 25 matching lines @@
 
 static void EnsureConstructorsAreCompiled(const Function& func) {
   // Only generative constructors can have initializing formals.
   if (!func.IsConstructor()) return;
 
   Isolate* isolate = Isolate::Current();
   const Class& cls = Class::Handle(isolate, func.Owner());
   const Error& error = Error::Handle(
       isolate, cls.EnsureIsFinalized(Isolate::Current()));
   if (!error.IsNull()) {
-    ThrowInvokeError(error);
+    Exceptions::PropagateError(error);
     UNREACHABLE();
   }
   if (!func.HasCode()) {
     const Error& error = Error::Handle(
         isolate, Compiler::CompileFunction(isolate, func));
     if (!error.IsNull()) {
-      ThrowInvokeError(error);
+      Exceptions::PropagateError(error);
       UNREACHABLE();
     }
   }
 }
 
 static RawInstance* CreateParameterMirrorList(const Function& func,
                                               const Instance& owner_mirror) {
   HANDLESCOPE(Isolate::Current());
   const intptr_t implicit_param_count = func.NumImplicitParameters();
   const intptr_t non_implicit_param_count = func.NumParameters() -
@@ skipping 28 matching lines @@
 
   Array& param_descriptor = Array::Handle();
   if (has_extra_parameter_info) {
     // Reparse the function for the following information:
     // * The default value of a parameter.
     // * Whether a parameters has been deflared as final.
     // * Any metadata associated with the parameter.
     const Object& result =
         Object::Handle(Parser::ParseFunctionParameters(func));
     if (result.IsError()) {
-      ThrowInvokeError(Error::Cast(result));
+      Exceptions::PropagateError(Error::Cast(result));
       UNREACHABLE();
     }
     param_descriptor ^= result.raw();
     ASSERT(param_descriptor.Length() ==
            (Parser::kParameterEntrySize * non_implicit_param_count));
   }
 
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(func)));
   args.SetAt(2, owner_mirror);
 
@@ skipping 171 matching lines @@
       // We represent function types as canonical signature classes.
       return CreateFunctionTypeMirror(cls, type);
     } else {
       // We represent typedefs as non-canonical signature classes.
       return CreateTypedefMirror(cls, type, is_declaration, owner_mirror);
     }
   }
 
   const Error& error = Error::Handle(cls.EnsureIsFinalized(Isolate::Current()));
   if (!error.IsNull()) {
-    ThrowInvokeError(error);
+    Exceptions::PropagateError(error);
     UNREACHABLE();
   }
 
   const Bool& is_generic = Bool::Get(cls.NumTypeParameters() != 0);
   const Bool& is_mixin_app_alias = Bool::Get(cls.is_mixin_app_alias());
 
   const Array& args = Array::Handle(Array::New(8));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
   args.SetAt(1, type);
   // Note that the VM does not consider mixin application aliases to be mixin
@@ skipping 63 matching lines @@
     combinators.SetAt(i++, t);
   }
   for (intptr_t j = 0; j < m; j++) {
     t = hide_names.At(j);
     t = CreateCombinatorMirror(t, false);
     combinators.SetAt(i++, t);
   }
 
   Object& metadata = Object::Handle(ns.GetMetadata());
   if (metadata.IsError()) {
-    ThrowInvokeError(Error::Cast(metadata));
+    Exceptions::PropagateError(Error::Cast(metadata));
     UNREACHABLE();
   }
 
   const Array& args = Array::Handle(Array::New(6));
   args.SetAt(0, importer);
   args.SetAt(1, importee_mirror);
   args.SetAt(2, combinators);
   args.SetAt(3, prefix);
   args.SetAt(4, Bool::Get(is_import));
   args.SetAt(5, metadata);
@@ skipping 135 matching lines @@
 
   const Array& args = Array::Handle(Array::New(2));
   args.SetAt(0, library_mirrors);
   args.SetAt(1, isolate_mirror);
   return CreateMirror(Symbols::_LocalMirrorSystem(), args);
 }
 
 
 static RawInstance* ReturnResult(const Object& result) {
   if (result.IsError()) {
-    ThrowInvokeError(Error::Cast(result));
+    Exceptions::PropagateError(Error::Cast(result));
     UNREACHABLE();
   }
   if (result.IsInstance()) {
     return Instance::Cast(result).raw();
   }
   ASSERT(result.IsNull());
   return Instance::null();
 }
 
 
@@ skipping 173 matching lines @@
   ASSERT(!instantiator.IsNull());
   ASSERT(instantiator.IsFinalized());
   ASSERT(!instantiator.IsMalformed());
 
   const TypeArguments& type_args =
       TypeArguments::Handle(instantiator.arguments());
   Error& bound_error = Error::Handle();
   AbstractType& result =
       AbstractType::Handle(type.InstantiateFrom(type_args, &bound_error));
   if (!bound_error.IsNull()) {
-    ThrowInvokeError(bound_error);
+    Exceptions::PropagateError(bound_error);
     UNREACHABLE();
   }
   ASSERT(result.IsFinalized());
   return result.Canonicalize();
 }
 
 
 DEFINE_NATIVE_ENTRY(Mirrors_makeLocalMirrorSystem, 0) {
   return CreateMirrorSystem();
 }
@@ skipping 68 matching lines @@
     library ^= decl.raw();
   } else if (decl.IsTypeParameter()) {
     klass ^= TypeParameter::Cast(decl).parameterized_class();
     library = klass.library();
   } else {
     return Object::empty_array().raw();
   }
 
   const Object& metadata = Object::Handle(library.GetMetadata(decl));
   if (metadata.IsError()) {
-    ThrowInvokeError(Error::Cast(metadata));
+    Exceptions::PropagateError(Error::Cast(metadata));
   }
   return metadata.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(FunctionTypeMirror_call_method, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance,
                                owner_mirror,
                                arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
@@ skipping 68 matching lines @@
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
   ASSERT(!type.IsMalformed());
   ASSERT(type.IsFinalized());
   if (!type.HasResolvedTypeClass()) {
     Exceptions::ThrowArgumentError(type);
     UNREACHABLE();
   }
   const Class& cls = Class::Handle(type.type_class());
   const Error& error = Error::Handle(cls.EnsureIsFinalized(isolate));
   if (!error.IsNull()) {
-    ThrowInvokeError(error);
+    Exceptions::PropagateError(error);
   }
 
   return cls.interfaces();
 }
 
 DEFINE_NATIVE_ENTRY(ClassMirror_interfaces_instantiated, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
   ASSERT(!type.IsMalformed());
   ASSERT(type.IsFinalized());
   if (!type.HasResolvedTypeClass()) {
     Exceptions::ThrowArgumentError(type);
     UNREACHABLE();
   }
   const Class& cls = Class::Handle(type.type_class());
   const Error& error = Error::Handle(cls.EnsureIsFinalized(isolate));
   if (!error.IsNull()) {
-    ThrowInvokeError(error);
+    Exceptions::PropagateError(error);
   }
 
   Array& interfaces = Array::Handle(cls.interfaces());
   Array& interfaces_inst = Array::Handle(Array::New(interfaces.Length()));
   AbstractType& interface = AbstractType::Handle();
 
   for (int i = 0; i < interfaces.Length(); i++) {
     interface ^= interfaces.At(i);
     interface = InstantiateType(interface, type);
     interfaces_inst.SetAt(i, interface);
@@ skipping 41 matching lines @@
 
 DEFINE_NATIVE_ENTRY(ClassMirror_members, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance,
                                owner_mirror,
                                arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Class& klass = Class::Handle(ref.GetClassReferent());
 
   const Error& error = Error::Handle(klass.EnsureIsFinalized(isolate));
   if (!error.IsNull()) {
-    ThrowInvokeError(error);
+    Exceptions::PropagateError(error);
   }
 
   const Array& fields = Array::Handle(klass.fields());
   const intptr_t num_fields = fields.Length();
 
   const Array& functions = Array::Handle(klass.functions());
   const intptr_t num_functions = functions.Length();
 
   Instance& member_mirror = Instance::Handle();
   const GrowableObjectArray& member_mirrors = GrowableObjectArray::Handle(
@@ skipping 26 matching lines @@
 
 DEFINE_NATIVE_ENTRY(ClassMirror_constructors, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance,
                                owner_mirror,
                                arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Class& klass = Class::Handle(ref.GetClassReferent());
 
   const Error& error = Error::Handle(klass.EnsureIsFinalized(isolate));
   if (!error.IsNull()) {
-    ThrowInvokeError(error);
+    Exceptions::PropagateError(error);
   }
 
   const Array& functions = Array::Handle(klass.functions());
   const intptr_t num_functions = functions.Length();
 
   Instance& constructor_mirror = Instance::Handle();
   const GrowableObjectArray& constructor_mirrors = GrowableObjectArray::Handle(
       GrowableObjectArray::New(num_functions));
 
   Function& func = Function::Handle();
@@ skipping 201 matching lines @@
                                 function,
                                 getter_name,
                                 getter_args,
                                 getter_args_descriptor));
       // Replace the closure as the receiver in the arguments list.
       args.SetAt(0, getter_result);
       // Call the closure.
       const Object& call_result =
           Object::Handle(DartEntry::InvokeClosure(args, args_descriptor));
       if (call_result.IsError()) {
-        ThrowInvokeError(Error::Cast(call_result));
+        Exceptions::PropagateError(Error::Cast(call_result));
         UNREACHABLE();
       }
       return call_result.raw();
     }
   }
 
   // Found an ordinary method.
   return InvokeDynamicFunction(reflectee,
                                function,
                                function_name,
@@ skipping 81 matching lines @@
   if (function.IsNull()) {
     // Didn't find a method: try to find a getter and invoke call on its result.
     const String& getter_name =
         String::Handle(Field::GetterName(function_name));
     function = klass.LookupStaticFunction(getter_name);
     if (!function.IsNull()) {
       // Invoke the getter.
       const Object& getter_result = Object::Handle(
           DartEntry::InvokeFunction(function, Object::empty_array()));
       if (getter_result.IsError()) {
-        ThrowInvokeError(Error::Cast(getter_result));
+        Exceptions::PropagateError(Error::Cast(getter_result));
         UNREACHABLE();
       }
       // Make room for the closure (receiver) in the argument list.
       intptr_t numArgs = args.Length();
       const Array& call_args = Array::Handle(Array::New(numArgs + 1));
       Object& temp = Object::Handle();
       for (int i = 0; i < numArgs; i++) {
         temp = args.At(i);
         call_args.SetAt(i + 1, temp);
       }
       call_args.SetAt(0, getter_result);
       const Array& call_args_descriptor_array =
         Array::Handle(ArgumentsDescriptor::New(call_args.Length(), arg_names));
       // Call the closure.
       const Object& call_result = Object::Handle(
           DartEntry::InvokeClosure(call_args, call_args_descriptor_array));
       if (call_result.IsError()) {
-        ThrowInvokeError(Error::Cast(call_result));
+        Exceptions::PropagateError(Error::Cast(call_result));
         UNREACHABLE();
       }
       return call_result.raw();
     }
   }
 
   const Array& args_descriptor_array =
       Array::Handle(ArgumentsDescriptor::New(args.Length(), arg_names));
 
   ArgumentsDescriptor args_descriptor(args_descriptor_array);
 
   if (function.IsNull() ||
       !function.AreValidArguments(args_descriptor, NULL) ||
       !function.is_visible()) {
     ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                       function_name,
                       function,
                       Object::null_array(),
                       InvocationMirror::kStatic,
                       InvocationMirror::kMethod);
     UNREACHABLE();
   }
 
   Object& result = Object::Handle(
       DartEntry::InvokeFunction(function, args, args_descriptor_array));
   if (result.IsError()) {
-    ThrowInvokeError(Error::Cast(result));
+    Exceptions::PropagateError(Error::Cast(result));
     UNREACHABLE();
   }
   return result.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_invokeGetter, 3) {
   // Argument 0 is the mirror, which is unused by the native. It exists
   // because this native is an instance method in order to be polymorphic
   // with its cousins.
@@ skipping 33 matching lines @@
                         args,
                         InvocationMirror::kStatic,
                         InvocationMirror::kSetter);
       UNREACHABLE();
     }
 
     // Invoke the setter and return the result.
     Object& result = Object::Handle(
         DartEntry::InvokeFunction(setter, args));
     if (result.IsError()) {
-      ThrowInvokeError(Error::Cast(result));
+      Exceptions::PropagateError(Error::Cast(result));
       UNREACHABLE();
     }
     return result.raw();
   }
 
   if (field.is_final()) {
     ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                       internal_setter_name,
                       setter,
                       Object::null_array(),
@@ skipping 71 matching lines @@
     ClassFinalizer::ResolveRedirectingFactory(klass, lookup_constructor);
     Type& redirect_type = Type::Handle(lookup_constructor.RedirectionType());
 
     if (!redirect_type.IsInstantiated()) {
       // The type arguments of the redirection type are instantiated from the
       // type arguments of the type reflected by the class mirror.
       Error& bound_error = Error::Handle();
       redirect_type ^= redirect_type.InstantiateFrom(type_arguments,
                                                      &bound_error);
       if (!bound_error.IsNull()) {
-        ThrowInvokeError(bound_error);
+        Exceptions::PropagateError(bound_error);
         UNREACHABLE();
       }
       redirect_type ^= redirect_type.Canonicalize();
     }
 
     type = redirect_type.raw();
     type_arguments = redirect_type.arguments();
 
     redirected_constructor = lookup_constructor.RedirectionTarget();
     ASSERT(!redirected_constructor.IsNull());
@@ skipping 50 matching lines @@
     // Factories get type arguments.
     args.SetAt(0, type_arguments);
   }
 
   // Invoke the constructor and return the new object.
   const Object& result =
       Object::Handle(DartEntry::InvokeFunction(redirected_constructor,
                                                args,
                                                args_descriptor_array));
   if (result.IsError()) {
-    ThrowInvokeError(Error::Cast(result));
+    Exceptions::PropagateError(Error::Cast(result));
     UNREACHABLE();
   }
 
   // Factories may return null.
   ASSERT(result.IsInstance() || result.IsNull());
 
   if (redirected_constructor.IsConstructor()) {
     return new_object.raw();
   } else {
     return result.raw();
@@ skipping 28 matching lines @@
         temp = args.At(i);
         call_args.SetAt(i + 1, temp);
       }
       call_args.SetAt(0, getter_result);
       const Array& call_args_descriptor_array = Array::Handle(
           ArgumentsDescriptor::New(call_args.Length(), arg_names));
       // Call closure.
       const Object& call_result = Object::Handle(
           DartEntry::InvokeClosure(call_args, call_args_descriptor_array));
       if (call_result.IsError()) {
-        ThrowInvokeError(Error::Cast(call_result));
+        Exceptions::PropagateError(Error::Cast(call_result));
         UNREACHABLE();
       }
       return call_result.raw();
     }
   }
 
   const Array& args_descriptor_array =
       Array::Handle(ArgumentsDescriptor::New(args.Length(), arg_names));
   ArgumentsDescriptor args_descriptor(args_descriptor_array);
 
   if (function.IsNull() ||
       !function.AreValidArguments(args_descriptor, NULL) ||
       !function.is_visible()) {
     ThrowNoSuchMethod(Instance::null_instance(),
                       function_name,
                       function,
                       Object::null_array(),
                       InvocationMirror::kTopLevel,
                       InvocationMirror::kMethod);
     UNREACHABLE();
   }
 
   const Object& result = Object::Handle(
       DartEntry::InvokeFunction(function, args, args_descriptor_array));
   if (result.IsError()) {
-    ThrowInvokeError(Error::Cast(result));
+    Exceptions::PropagateError(Error::Cast(result));
     UNREACHABLE();
   }
   return result.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(LibraryMirror_invokeGetter, 3) {
   // Argument 0 is the mirror, which is unused by the native. It exists
   // because this native is an instance method in order to be polymorphic
   // with its cousins.
@@ skipping 36 matching lines @@
                         args,
                         InvocationMirror::kTopLevel,
                         InvocationMirror::kSetter);
       UNREACHABLE();
     }
 
     // Invoke the setter and return the result.
     const Object& result = Object::Handle(
         DartEntry::InvokeFunction(setter, args));
     if (result.IsError()) {
-      ThrowInvokeError(Error::Cast(result));
+      Exceptions::PropagateError(Error::Cast(result));
       UNREACHABLE();
     }
     return result.raw();
   }
 
   if (field.is_final()) {
     ThrowNoSuchMethod(Instance::null_instance(),
                       internal_setter_name,
                       setter,
                       Object::null_array(),
@@ skipping 162 matching lines @@
 }
 
 DEFINE_NATIVE_ENTRY(TypeMirror_moreSpecificTest, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, a, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, b, arguments->NativeArgAt(1));
   return Bool::Get(a.IsMoreSpecificThan(b, NULL)).raw();
 }
 
 
 }  // namespace dart