Add support for malformed types and postpone some related errors from compile

runtime/lib/error.cc

-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// 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/error.h"
 
 #include "vm/bootstrap_natives.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
 #include "vm/runtime_entry.h"
 #include "vm/stack_frame.h"
@@ skipping 87 matching lines @@
   // Throw AssertionError instance.
   Exceptions::Throw(assertion_error);
   UNREACHABLE();
 }
 
 
 // Allocate, initialize, and throw a TypeError.
 static void ThrowTypeError(intptr_t location,
                            const String& src_type_name,
                            const String& dst_type_name,
-                           const String& dst_name) {
+                           const String& dst_name,
+                           const String& malformed_error) {
   // Allocate a new instance of TypeError.
   const Instance& type_error = Instance::Handle(NewInstance("TypeError"));
 
   // Initialize 'url', 'line', and 'column' fields.
   DartFrameIterator iterator;
   const Script& script = Script::Handle(GetCallerScript(&iterator));
   const Class& cls = Class::Handle(type_error.clazz());
   // Location fields are defined in AssertionError, the superclass of TypeError.
   const Class& assertion_error_class = Class::Handle(cls.SuperClass());
   SetLocationFields(type_error, assertion_error_class, script, location);
@@ skipping 12 matching lines @@
 
   // Initialize field 'srcType'.
   SetField(type_error, cls, "srcType", src_type_name);
 
   // Initialize field 'dstType'.
   SetField(type_error, cls, "dstType", dst_type_name);
 
   // Initialize field 'dstName'.
   SetField(type_error, cls, "dstName", dst_name);
 
+  // Initialize field 'malformedError'.
+  SetField(type_error, cls, "malformedError", malformed_error);
+
   // Type errors in the core library may be difficult to diagnose.
   // Print type error information before throwing the error when debugging.
   if (FLAG_print_stack_trace_at_throw) {
-    intptr_t line, column;
-    script.GetTokenLocation(location, &line, &column);
-    OS::Print("'%s': Failed type check: line %d pos %d: "
-              "type '%s' is not assignable to type '%s' of '%s'.\n",
-              String::Handle(script.url()).ToCString(),
-              line, column,
-              src_type_name.ToCString(),
-              dst_type_name.ToCString(),
-              dst_name.ToCString());
+    if (!malformed_error.IsNull()) {
+      OS::Print("%s", malformed_error.ToCString());
+    } else {
+      intptr_t line, column;
+      script.GetTokenLocation(location, &line, &column);
+      OS::Print("'%s': Failed type check: line %d pos %d: "
+                "type '%s' is not assignable to type '%s' of '%s'.\n",
+                String::Handle(script.url()).ToCString(),
+                line, column,
+                src_type_name.ToCString(),
+                dst_type_name.ToCString(),
+                dst_name.ToCString());
+    }
   }
   // Throw TypeError instance.
   Exceptions::Throw(type_error);
   UNREACHABLE();
 }
 
 
 // Allocate and throw a new TypeError.
 // Arg0: index of the token of the failed type check.
 // Arg1: src value.
 // Arg2: dst type name.
 // Arg3: dst name.
+// Arg4: malformed type error message.
 // Return value: none, throws an exception.
-DEFINE_NATIVE_ENTRY(TypeError_throwNew, 4) {
+DEFINE_NATIVE_ENTRY(TypeError_throwNew, 5) {
   intptr_t location = Smi::CheckedHandle(arguments->At(0)).Value();
   const Instance& src_value = Instance::CheckedHandle(arguments->At(1));
   const String& dst_type_name = String::CheckedHandle(arguments->At(2));
   const String& dst_name = String::CheckedHandle(arguments->At(3));
+  const String& malformed_error = String::CheckedHandle(arguments->At(4));
   const String& src_type_name =
       String::Handle(Type::Handle(src_value.GetType()).Name());
-  ThrowTypeError(location, src_type_name, dst_type_name, dst_name);
+  ThrowTypeError(location, src_type_name,
+                 dst_type_name, dst_name, malformed_error);
 }
 
 
 // Allocate and throw a new FallThroughError.
 // Arg0: index of the case clause token into which we fall through.
 // Return value: none, throws an exception.
 DEFINE_NATIVE_ENTRY(FallThroughError_throwNew, 1) {
   GET_NATIVE_ARGUMENT(Smi, smi_pos, arguments->At(0));
   intptr_t fallthrough_pos = smi_pos.Value();
 
@@ skipping 99 matching lines @@
     const String& src_type_name = String::Handle(src_type.Name());
     String& dst_type_name = String::Handle();
     if (!dst_type.IsInstantiated()) {
       // Instantiate dst_type before reporting the error.
       const AbstractType& instantiated_dst_type = AbstractType::Handle(
           dst_type.InstantiateFrom(dst_type_instantiator));
       dst_type_name = instantiated_dst_type.Name();
     } else {
       dst_type_name = dst_type.Name();
     }
-    ThrowTypeError(location, src_type_name, dst_type_name, dst_name);
+    const String& no_malformed_type_error =  String::Handle();
+    ThrowTypeError(location, src_type_name, dst_type_name, dst_name,
+                   no_malformed_type_error);
     UNREACHABLE();
   }
   arguments.SetReturn(src_instance);
 }
 
 
 // Report that the type of the given object is not bool in conditional context.
 // Arg0: index of the token of the assignment (source location).
 // Arg1: bad object.
 // Return value: none, throws a TypeError.
 DEFINE_RUNTIME_ENTRY(ConditionTypeError, 2) {
   ASSERT(arguments.Count() ==
       kConditionTypeErrorRuntimeEntry.argument_count());
   intptr_t location = Smi::CheckedHandle(arguments.At(0)).Value();
   const Instance& src_instance = Instance::CheckedHandle(arguments.At(1));
   ASSERT(src_instance.IsNull() || !src_instance.IsBool());
-  const char* msg = "boolean expression";
   const Type& bool_interface = Type::Handle(Type::BoolInterface());
   const Type& src_type = Type::Handle(src_instance.GetType());
   const String& src_type_name = String::Handle(src_type.Name());
   const String& bool_type_name = String::Handle(bool_interface.Name());
-  ThrowTypeError(location, src_type_name, bool_type_name,
-                 String::Handle(String::NewSymbol(msg)));
+  const String& expr = String::Handle(String::NewSymbol("boolean expression"));
+  const String& no_malformed_type_error =  String::Handle();
+  ThrowTypeError(location, src_type_name, bool_type_name, expr,
+                 no_malformed_type_error);
+  UNREACHABLE();
+}
+
+
+// Report that the type of the type check is malformed.
+// Arg0: index of the token of the failed type check.
+// Arg1: src value.
+// Arg2: malformed type error message.
+// Return value: none, throws an exception.
+DEFINE_RUNTIME_ENTRY(MalformedTypeError, 3) {
+  ASSERT(arguments.Count() ==
+      kMalformedTypeErrorRuntimeEntry.argument_count());
+  intptr_t location = Smi::CheckedHandle(arguments.At(0)).Value();
+  const Instance& src_value = Instance::CheckedHandle(arguments.At(1));
+  const String& malformed_error = String::CheckedHandle(arguments.At(2));
+  const String& dst_type_name =
+      String::Handle(String::NewSymbol("malformed type"));
+  const String& dst_name = String::Handle(String::NewSymbol(""));
+  const String& src_type_name =
+      String::Handle(Type::Handle(src_value.GetType()).Name());
+  ThrowTypeError(location, src_type_name,
+                 dst_type_name, dst_name, malformed_error);
   UNREACHABLE();
 }
 
 
 // Check that the type of each element of the given array is assignable to the
 // given type.
 // Arg0: index of the token of the rest argument declaration (source location).
 // Arg1: rest argument array.
 // Arg2: element declaration type.
 // Arg3: type arguments of the instantiator of the element declaration type.
@@ skipping 26 matching lines @@
       String& dst_type_name = String::Handle();
       if (!element_type.IsInstantiated()) {
         // Instantiate element_type before reporting the error.
         const AbstractType& instantiated_element_type = AbstractType::Handle(
             element_type.InstantiateFrom(element_type_instantiator));
         dst_type_name = instantiated_element_type.Name();
       } else {
         dst_type_name = element_type.Name();
       }
       const String& dst_name = String::Handle(String::New(buf));
-      ThrowTypeError(location, src_type_name, dst_type_name, dst_name);
+      const String& no_malformed_type_error =  String::Handle();
+      ThrowTypeError(location, src_type_name, dst_type_name, dst_name,
+                     no_malformed_type_error);
       UNREACHABLE();
     }
   }
 }
 
 }  // namespace dart