Enumerate URIs of all types in type errors in order to help the user diagnose

runtime/vm/code_generator.cc

 // Copyright (c) 2013, 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 "vm/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 172 matching lines @@
           (type_arguments.Length() >= cls.NumTypeArguments())));
   instance.SetTypeArguments(type_arguments);
 }
 
 
 // Instantiate type.
 // Arg0: uninstantiated type.
 // Arg1: instantiator type arguments.
 // Return value: instantiated type.
 DEFINE_RUNTIME_ENTRY(InstantiateType, 2) {
-  AbstractType& type = AbstractType::CheckedHandle(arguments.ArgAt(0));
+  AbstractType& type = AbstractType::CheckedHandle(zone, arguments.ArgAt(0));
   const TypeArguments& instantiator =
-      TypeArguments::CheckedHandle(arguments.ArgAt(1));
+      TypeArguments::CheckedHandle(zone, arguments.ArgAt(1));
   ASSERT(!type.IsNull() && !type.IsInstantiated());
   ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
-  Error& bound_error = Error::Handle();
+  Error& bound_error = Error::Handle(zone);
   type =
       type.InstantiateFrom(instantiator, &bound_error, NULL, NULL, Heap::kOld);
   if (!bound_error.IsNull()) {
     // Throw a dynamic type error.
     const TokenPosition location = GetCallerLocation();
     String& bound_error_message =  String::Handle(
-        String::New(bound_error.ToErrorCString()));
+        zone, String::New(bound_error.ToErrorCString()));
     Exceptions::CreateAndThrowTypeError(
-        location, Symbols::Empty(), Symbols::Empty(),
+        location, AbstractType::Handle(zone), AbstractType::Handle(zone),
         Symbols::Empty(), bound_error_message);
     UNREACHABLE();
   }
   if (type.IsTypeRef()) {
     type = TypeRef::Cast(type).type();
     ASSERT(!type.IsTypeRef());
     ASSERT(type.IsCanonical());
   }
   ASSERT(!type.IsNull() && type.IsInstantiated());
   arguments.SetReturn(type);
 }
 
 
 // Instantiate type arguments.
 // Arg0: uninstantiated type arguments.
 // Arg1: instantiator type arguments.
 // Return value: instantiated type arguments.
 DEFINE_RUNTIME_ENTRY(InstantiateTypeArguments, 2) {
   TypeArguments& type_arguments =
-      TypeArguments::CheckedHandle(arguments.ArgAt(0));
+      TypeArguments::CheckedHandle(zone, arguments.ArgAt(0));
   const TypeArguments& instantiator =
-      TypeArguments::CheckedHandle(arguments.ArgAt(1));
+      TypeArguments::CheckedHandle(zone, arguments.ArgAt(1));
   ASSERT(!type_arguments.IsNull() && !type_arguments.IsInstantiated());
   ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
   // Code inlined in the caller should have optimized the case where the
   // instantiator can be reused as type argument vector.
   ASSERT(instantiator.IsNull() || !type_arguments.IsUninstantiatedIdentity());
   if (isolate->type_checks()) {
-    Error& bound_error = Error::Handle();
+    Error& bound_error = Error::Handle(zone);
     type_arguments =
         type_arguments.InstantiateAndCanonicalizeFrom(instantiator,
                                                       &bound_error);
     if (!bound_error.IsNull()) {
       // Throw a dynamic type error.
       const TokenPosition location = GetCallerLocation();
       String& bound_error_message =  String::Handle(
-          String::New(bound_error.ToErrorCString()));
+          zone, String::New(bound_error.ToErrorCString()));
       Exceptions::CreateAndThrowTypeError(
-          location, Symbols::Empty(), Symbols::Empty(),
+          location, AbstractType::Handle(zone), AbstractType::Handle(zone),
           Symbols::Empty(), bound_error_message);
       UNREACHABLE();
     }
   } else {
     type_arguments =
         type_arguments.InstantiateAndCanonicalizeFrom(instantiator, NULL);
   }
   ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
   arguments.SetReturn(type_arguments);
 }
 
 
 // Allocate a new context large enough to hold the given number of variables.
 // Arg0: number of variables.
 // Return value: newly allocated context.
 DEFINE_RUNTIME_ENTRY(AllocateContext, 1) {
-  const Smi& num_variables = Smi::CheckedHandle(arguments.ArgAt(0));
+  const Smi& num_variables = Smi::CheckedHandle(zone, arguments.ArgAt(0));
   arguments.SetReturn(Context::Handle(Context::New(num_variables.Value())));
 }
 
 
 // Make a copy of the given context, including the values of the captured
 // variables.
 // Arg0: the context to be cloned.
 // Return value: newly allocated context.
 DEFINE_RUNTIME_ENTRY(CloneContext, 1) {
-  const Context& ctx = Context::CheckedHandle(arguments.ArgAt(0));
-  Context& cloned_ctx = Context::Handle(Context::New(ctx.num_variables()));
+  const Context& ctx = Context::CheckedHandle(zone, arguments.ArgAt(0));
+  Context& cloned_ctx =
+      Context::Handle(zone, Context::New(ctx.num_variables()));
   cloned_ctx.set_parent(Context::Handle(ctx.parent()));
   Object& inst = Object::Handle(zone);
   for (int i = 0; i < ctx.num_variables(); i++) {
     inst = ctx.At(i);
     cloned_ctx.SetAt(i, inst);
   }
   arguments.SetReturn(cloned_ctx);
 }
 
 
@@ skipping 157 matching lines @@
 
 
 // Check that the given instance is an instance of the given type.
 // Tested instance may not be null, because the null test is inlined.
 // Arg0: instance being checked.
 // Arg1: type.
 // Arg2: type arguments of the instantiator of the type.
 // Arg3: SubtypeTestCache.
 // Return value: true or false, or may throw a type error in checked mode.
 DEFINE_RUNTIME_ENTRY(Instanceof, 4) {
-  const Instance& instance = Instance::CheckedHandle(arguments.ArgAt(0));
-  const AbstractType& type = AbstractType::CheckedHandle(arguments.ArgAt(1));
+  const Instance& instance = Instance::CheckedHandle(zone, arguments.ArgAt(0));
+  const AbstractType& type =
+      AbstractType::CheckedHandle(zone, arguments.ArgAt(1));
   const TypeArguments& instantiator_type_arguments =
-      TypeArguments::CheckedHandle(arguments.ArgAt(2));
+      TypeArguments::CheckedHandle(zone, arguments.ArgAt(2));
   const SubtypeTestCache& cache =
-      SubtypeTestCache::CheckedHandle(arguments.ArgAt(3));
+      SubtypeTestCache::CheckedHandle(zone, arguments.ArgAt(3));
   ASSERT(type.IsFinalized());
   ASSERT(!type.IsDynamicType());  // No need to check assignment.
   ASSERT(!type.IsMalformed());  // Already checked in code generator.
   ASSERT(!type.IsMalbounded());  // Already checked in code generator.
-  Error& bound_error = Error::Handle();
+  Error& bound_error = Error::Handle(zone);
   const Bool& result =
       Bool::Get(instance.IsInstanceOf(type,
                                       instantiator_type_arguments,
                                       &bound_error));
   if (FLAG_trace_type_checks) {
     PrintTypeCheck("InstanceOf",
         instance, type, instantiator_type_arguments, result);
   }
   if (!result.value() && !bound_error.IsNull()) {
     // Throw a dynamic type error only if the instanceof test fails.
     const TokenPosition location = GetCallerLocation();
     String& bound_error_message =  String::Handle(
-        String::New(bound_error.ToErrorCString()));
+        zone, String::New(bound_error.ToErrorCString()));
     Exceptions::CreateAndThrowTypeError(
-        location, Symbols::Empty(), Symbols::Empty(),
+        location, AbstractType::Handle(zone), AbstractType::Handle(zone),
         Symbols::Empty(), bound_error_message);
     UNREACHABLE();
   }
   UpdateTypeTestCache(
       instance, type, instantiator_type_arguments, result, cache);
   arguments.SetReturn(result);
 }
 
 
 // Check that the type of the given instance is a subtype of the given type and
 // can therefore be assigned.
 // Arg0: instance being assigned.
 // Arg1: type being assigned to.
 // Arg2: type arguments of the instantiator of the type being assigned to.
 // Arg3: name of variable being assigned to.
 // Arg4: SubtypeTestCache.
 // Return value: instance if a subtype, otherwise throw a TypeError.
 DEFINE_RUNTIME_ENTRY(TypeCheck, 5) {
-  const Instance& src_instance = Instance::CheckedHandle(arguments.ArgAt(0));
-  AbstractType& dst_type = AbstractType::CheckedHandle(arguments.ArgAt(1));
+  const Instance& src_instance =
+      Instance::CheckedHandle(zone, arguments.ArgAt(0));
+  AbstractType& dst_type =
+      AbstractType::CheckedHandle(zone, arguments.ArgAt(1));
   const TypeArguments& instantiator_type_arguments =
-      TypeArguments::CheckedHandle(arguments.ArgAt(2));
-  const String& dst_name = String::CheckedHandle(arguments.ArgAt(3));
+      TypeArguments::CheckedHandle(zone, arguments.ArgAt(2));
+  const String& dst_name = String::CheckedHandle(zone, arguments.ArgAt(3));
   const SubtypeTestCache& cache =
-      SubtypeTestCache::CheckedHandle(arguments.ArgAt(4));
+      SubtypeTestCache::CheckedHandle(zone, arguments.ArgAt(4));
   ASSERT(!dst_type.IsDynamicType());  // No need to check assignment.
   ASSERT(!dst_type.IsMalformed());  // Already checked in code generator.
   ASSERT(!dst_type.IsMalbounded());  // Already checked in code generator.
   ASSERT(!src_instance.IsNull());  // Already checked in inlined code.
 
-  Error& bound_error = Error::Handle();
+  Error& bound_error = Error::Handle(zone);
   const bool is_instance_of = src_instance.IsInstanceOf(
       dst_type, instantiator_type_arguments, &bound_error);
 
   if (FLAG_trace_type_checks) {
     PrintTypeCheck("TypeCheck",
                    src_instance, dst_type, instantiator_type_arguments,
                    Bool::Get(is_instance_of));
   }
   if (!is_instance_of) {
     // Throw a dynamic type error.
     const TokenPosition location = GetCallerLocation();
-    const AbstractType& src_type = AbstractType::Handle(src_instance.GetType());
-    String& src_type_name = String::Handle(src_type.UserVisibleName());
+    const AbstractType& src_type =
+        AbstractType::Handle(zone, src_instance.GetType());
     if (!dst_type.IsInstantiated()) {
       // Instantiate dst_type before reporting the error.
       dst_type = dst_type.InstantiateFrom(instantiator_type_arguments, NULL,
                                           NULL, NULL, Heap::kNew);
       // Note that instantiated dst_type may be malbounded.
     }
-    String& dst_type_name = String::Handle(dst_type.UserVisibleName());
-    String& bound_error_message =  String::Handle();
+    String& bound_error_message =  String::Handle(zone);
     if (!bound_error.IsNull()) {
       ASSERT(isolate->type_checks());
       bound_error_message = String::New(bound_error.ToErrorCString());
     }
-    if (src_type_name.Equals(dst_type_name)) {
-      src_type_name = src_type.UserVisibleNameWithURI();
-      dst_type_name = dst_type.UserVisibleNameWithURI();
-    }
-    Exceptions::CreateAndThrowTypeError(location, src_type_name, dst_type_name,
+    Exceptions::CreateAndThrowTypeError(location, src_type, dst_type,
                                         dst_name, bound_error_message);
     UNREACHABLE();
   }
   UpdateTypeTestCache(
       src_instance, dst_type, instantiator_type_arguments, Bool::True(), cache);
   arguments.SetReturn(src_instance);
 }
 
 
 // Report that the type of the given object is not bool in conditional context.
 // Throw assertion error if the object is null. (cf. Boolean Conversion
 // in language Spec.)
 // Arg0: bad object.
 // Return value: none, throws TypeError or AssertionError.
 DEFINE_RUNTIME_ENTRY(NonBoolTypeError, 1) {
   const TokenPosition location = GetCallerLocation();
-  const Instance& src_instance = Instance::CheckedHandle(arguments.ArgAt(0));
+  const Instance& src_instance =
+      Instance::CheckedHandle(zone, arguments.ArgAt(0));
 
   if (src_instance.IsNull()) {
-    const Array& args = Array::Handle(Array::New(4));
-    args.SetAt(0, String::Handle(
+    const Array& args = Array::Handle(zone, Array::New(4));
+    args.SetAt(0, String::Handle(zone,
         String::New("Failed assertion: boolean expression must not be null")));
 
     // No source code for this assertion, set url to null.
-    args.SetAt(1, String::Handle(String::null()));
-    args.SetAt(2, Smi::Handle(Smi::New(0)));
-    args.SetAt(3, Smi::Handle(Smi::New(0)));
+    args.SetAt(1, String::Handle(zone, String::null()));
+    args.SetAt(2, Smi::Handle(zone, Smi::New(0)));
+    args.SetAt(3, Smi::Handle(zone, Smi::New(0)));
 
     Exceptions::ThrowByType(Exceptions::kAssertion, args);
     UNREACHABLE();
   }
 
   ASSERT(!src_instance.IsBool());
   const Type& bool_interface = Type::Handle(Type::BoolType());
-  const AbstractType& src_type = AbstractType::Handle(src_instance.GetType());
-  const String& src_type_name = String::Handle(src_type.UserVisibleName());
-  const String& bool_type_name =
-      String::Handle(bool_interface.UserVisibleName());
-  const String& no_bound_error = String::Handle();
-  Exceptions::CreateAndThrowTypeError(location, src_type_name, bool_type_name,
+  const AbstractType& src_type =
+      AbstractType::Handle(zone, src_instance.GetType());
+  const String& no_bound_error = String::Handle(zone);
+  Exceptions::CreateAndThrowTypeError(location, src_type, bool_interface,
                                       Symbols::BooleanExpression(),
                                       no_bound_error);
   UNREACHABLE();
 }
 
 
 // Report that the type of the type check is malformed or malbounded.
 // Arg0: src value.
 // Arg1: name of destination being assigned to.
 // Arg2: type of destination being assigned to.
 // Return value: none, throws an exception.
 DEFINE_RUNTIME_ENTRY(BadTypeError, 3) {
   const TokenPosition location = GetCallerLocation();
-  const Instance& src_value = Instance::CheckedHandle(arguments.ArgAt(0));
-  const String& dst_name = String::CheckedHandle(arguments.ArgAt(1));
+  const Instance& src_value = Instance::CheckedHandle(zone, arguments.ArgAt(0));
+  const String& dst_name = String::CheckedHandle(zone, arguments.ArgAt(1));
   const AbstractType& dst_type =
-      AbstractType::CheckedHandle(arguments.ArgAt(2));
-  const AbstractType& src_type = AbstractType::Handle(src_value.GetType());
-  const String& src_type_name = String::Handle(src_type.UserVisibleName());
-
-  String& dst_type_name = String::Handle();
-  LanguageError& error = LanguageError::Handle(dst_type.error());
-  ASSERT(!error.IsNull());
-  if (error.kind() == Report::kMalformedType) {
-    dst_type_name = Symbols::Malformed().raw();
-  } else {
-    ASSERT(error.kind() == Report::kMalboundedType);
-    dst_type_name = Symbols::Malbounded().raw();
-  }
-  const String& error_message = String::ZoneHandle(
-      Symbols::New(error.ToErrorCString()));
+      AbstractType::CheckedHandle(zone, arguments.ArgAt(2));
+  const AbstractType& src_type =
+      AbstractType::Handle(zone, src_value.GetType());
   Exceptions::CreateAndThrowTypeError(
-      location, src_type_name, dst_type_name, dst_name, error_message);
+      location, src_type, dst_type, dst_name, String::Handle(zone));
   UNREACHABLE();
 }
 
 
 DEFINE_RUNTIME_ENTRY(Throw, 1) {
   const Instance& exception =
       Instance::CheckedHandle(zone, arguments.ArgAt(0));
   Exceptions::Throw(thread, exception);
 }
 
 
 DEFINE_RUNTIME_ENTRY(ReThrow, 2) {
   const Instance& exception =
       Instance::CheckedHandle(zone, arguments.ArgAt(0));
   const Instance& stacktrace =
       Instance::CheckedHandle(zone, arguments.ArgAt(1));
   Exceptions::ReThrow(thread, exception, stacktrace);
 }
 
 
 // Patches static call in optimized code with the target's entry point.
 // Compiles target if necessary.
 DEFINE_RUNTIME_ENTRY(PatchStaticCall, 0) {
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
-  const Code& caller_code = Code::Handle(caller_frame->LookupDartCode());
+  const Code& caller_code = Code::Handle(zone, caller_frame->LookupDartCode());
   ASSERT(!caller_code.IsNull());
   ASSERT(caller_code.is_optimized());
   const Function& target_function = Function::Handle(
-      caller_code.GetStaticCallTargetFunctionAt(caller_frame->pc()));
+      zone, caller_code.GetStaticCallTargetFunctionAt(caller_frame->pc()));
   if (!target_function.HasCode()) {
     const Error& error =
-        Error::Handle(Compiler::CompileFunction(thread, target_function));
+        Error::Handle(zone, Compiler::CompileFunction(thread, target_function));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
   }
-  const Code& target_code = Code::Handle(target_function.CurrentCode());
+  const Code& target_code = Code::Handle(zone, target_function.CurrentCode());
   // Before patching verify that we are not repeatedly patching to the same
   // target.
   ASSERT(target_code.raw() !=
          CodePatcher::GetStaticCallTargetAt(caller_frame->pc(), caller_code));
   CodePatcher::PatchStaticCallAt(caller_frame->pc(),
                                  caller_code,
                                  target_code);
   caller_code.SetStaticCallTargetCodeAt(caller_frame->pc(), target_code);
   if (FLAG_trace_patching) {
     THR_Print("PatchStaticCall: patching caller pc %#" Px ""
@@ skipping 20 matching lines @@
 // set on a runtime stub call.
 DEFINE_RUNTIME_ENTRY(BreakpointRuntimeHandler, 0) {
   if (!FLAG_support_debugger) {
     UNREACHABLE();
     return;
   }
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& orig_stub = Code::Handle(
-      isolate->debugger()->GetPatchedStubAddress(caller_frame->pc()));
-  const Error& error = Error::Handle(isolate->debugger()->SignalBpReached());
+      zone, isolate->debugger()->GetPatchedStubAddress(caller_frame->pc()));
+  const Error& error =
+      Error::Handle(zone, isolate->debugger()->SignalBpReached());
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
     UNREACHABLE();
   }
   arguments.SetReturn(orig_stub);
 }
 
 
 DEFINE_RUNTIME_ENTRY(SingleStepHandler, 0) {
   if (!FLAG_support_debugger) {
     UNREACHABLE();
     return;
   }
   const Error& error =
-      Error::Handle(isolate->debugger()->DebuggerStepCallback());
+      Error::Handle(zone, isolate->debugger()->DebuggerStepCallback());
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
     UNREACHABLE();
   }
 }
 
 
 // An instance call of the form o.f(...) could not be resolved.  Check if
 // there is a getter with the same name.  If so, invoke it.  If the value is
 // a closure, invoke it with the given arguments.  If the value is a
@@ skipping 1174 matching lines @@
   const intptr_t elm_size = old_data.ElementSizeInBytes();
   const TypedData& new_data =
       TypedData::Handle(TypedData::New(cid, new_size, Heap::kOld));
   TypedData::Copy(new_data, 0, old_data, 0, old_size * elm_size);
   typed_data_cell.SetAt(0, new_data);
   arguments.SetReturn(new_data);
 }
 
 
 }  // namespace dart