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

runtime/vm/class_finalizer.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 "vm/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_classes, false, "Prints details about loaded classes.");
 DEFINE_FLAG(bool, trace_class_finalization, false, "Trace class finalization.");
 DEFINE_FLAG(bool, trace_type_finalization, false, "Trace type finalization.");
 DEFINE_FLAG(bool, verify_implements, false,
     "Verify that all classes implement their interface.");
 DECLARE_FLAG(bool, enable_type_checks);
-DECLARE_FLAG(bool, silent_warnings);
-DECLARE_FLAG(bool, warning_as_error);
 
 void ClassFinalizer::AddPendingClasses(
     const GrowableArray<const Class*>& classes) {
   if (!classes.is_empty()) {
     ObjectStore* object_store = Isolate::Current()->object_store();
     const Array& old_array = Array::Handle(object_store->pending_classes());
     const intptr_t old_length = old_array.Length();
     const int new_length = old_length + classes.length();
     const Array& new_array = Array::Handle(Array::Grow(old_array, new_length));
     // Add new classes.
@@ skipping 216 matching lines @@
                  err.ToErrorCString());
     OS::Exit(255);
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("VerifyBootstrapClasses END.\n");
   }
   Isolate::Current()->heap()->Verify();
 }
 
 
-// Resolve unresolved_class in the library of cls.
+// Resolve unresolved_class in the library of cls, or return null.
 RawClass* ClassFinalizer::ResolveClass(
     const Class& cls, const UnresolvedClass& unresolved_class) {
   const String& class_name = String::Handle(unresolved_class.ident());
   Library& lib = Library::Handle();
   Class& resolved_class = Class::Handle();
   if (unresolved_class.library_prefix() == LibraryPrefix::null()) {
     lib = cls.library();
     ASSERT(!lib.IsNull());
     resolved_class = lib.LookupClass(class_name);
   } else {
     LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
     lib_prefix = unresolved_class.library_prefix();
     ASSERT(!lib_prefix.IsNull());
     resolved_class = lib_prefix.LookupLocalClass(class_name);
   }
-  if (resolved_class.IsNull()) {
-    const Script& script = Script::Handle(cls.script());
-    ReportError(script, unresolved_class.token_index(),
-                "cannot resolve class name '%s' from '%s'.\n",
-                String::Handle(unresolved_class.Name()).ToCString(),
-                String::Handle(cls.Name()).ToCString());
-  }
   return resolved_class.raw();
 }
 
 
 // Resolve unresolved supertype (String -> Class).
 void ClassFinalizer::ResolveSuperType(const Class& cls) {
   if (cls.is_finalized()) {
     return;
   }
   Type& super_type = Type::Handle(cls.super_type());
   if (super_type.IsNull()) {
     return;
   }
   // Resolve failures lead to a longjmp.
-  ResolveType(cls, super_type);
+  ResolveType(cls, super_type, kFinalizeWellFormed);
   const Class& super_class = Class::Handle(super_type.type_class());
   if (cls.is_interface() != super_class.is_interface()) {
     String& class_name = String::Handle(cls.Name());
     String& super_class_name = String::Handle(super_class.Name());
     const Script& script = Script::Handle(cls.script());
     ReportError(script, cls.token_index(),
                 "class '%s' and superclass '%s' are not "
-                "both classes or both interfaces.\n",
+                "both classes or both interfaces",
                 class_name.ToCString(),
                 super_class_name.ToCString());
   }
   // If cls belongs to core lib or to core lib's implementation, restrictions
   // about allowed interfaces are lifted.
   if ((cls.library() != Library::CoreLibrary()) &&
       (cls.library() != Library::CoreImplLibrary())) {
     // Prevent extending core implementation classes Bool, Double, ObjectArray,
     // ImmutableArray, GrowableObjectArray, IntegerImplementation, Smi, Mint,
     // BigInt, OneByteString, TwoByteString, FourByteString.
@@ skipping 16 matching lines @@
         (super_class.raw() == object_store->external_byte_array_class()) ||
         (super_class.raw() == integer_implementation_class.raw()) ||
         (super_class.raw() == object_store->smi_class()) ||
         (super_class.raw() == object_store->mint_class()) ||
         (super_class.raw() == object_store->bigint_class()) ||
         (super_class.raw() == object_store->one_byte_string_class()) ||
         (super_class.raw() == object_store->two_byte_string_class()) ||
         (super_class.raw() == object_store->four_byte_string_class())) {
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_index(),
-                  "'%s' is not allowed to extend '%s'\n",
+                  "'%s' is not allowed to extend '%s'",
                   String::Handle(cls.Name()).ToCString(),
                   String::Handle(super_class.Name()).ToCString());
     }
   }
   return;
 }
 
 
 void ClassFinalizer::ResolveDefaultClass(const Class& interface) {
   ASSERT(interface.is_interface());
   if (interface.is_finalized() ||
       !interface.HasFactoryClass() ||
       interface.HasResolvedFactoryClass()) {
     return;
   }
   const UnresolvedClass& unresolved_factory_class =
       UnresolvedClass::Handle(interface.UnresolvedFactoryClass());
 
   // Lookup the factory class.
   const Class& factory_class =
       Class::Handle(ResolveClass(interface, unresolved_factory_class));
-  ASSERT(!factory_class.IsNull());
+  if (factory_class.IsNull()) {
+    const Script& script = Script::Handle(interface.script());
+    ReportError(script, unresolved_factory_class.token_index(),
+                "cannot resolve factory class name '%s' from '%s'",
+                String::Handle(unresolved_factory_class.Name()).ToCString(),
+                String::Handle(interface.Name()).ToCString());
+  }
   if (factory_class.is_interface()) {
     const String& interface_name = String::Handle(interface.Name());
     const String& factory_name = String::Handle(factory_class.Name());
     const Script& script = Script::Handle(interface.script());
     ReportError(script, unresolved_factory_class.token_index(),
-                "default clause of interface '%s' names non-class '%s'.\n",
+                "default clause of interface '%s' names non-class '%s'",
                 interface_name.ToCString(),
                 factory_name.ToCString());
   }
   interface.set_factory_class(factory_class);
   ResolveAndFinalizeUpperBounds(factory_class);
   const Class& factory_signature_class = Class::Handle(
       unresolved_factory_class.factory_signature_class());
   ASSERT(!factory_signature_class.IsNull());
   // If a type parameter list is included in the default factory clause (it
   // can be omitted), verify that it matches the list of type parameters of
@@ skipping 11 matching lines @@
     if (!AbstractTypeArguments::AreEqual(expected_type_parameters,
                                          actual_type_parameters) ||
         !AbstractTypeArguments::AreEqual(expected_type_parameter_bounds,
                                          actual_type_parameter_bounds)) {
       const String& interface_name = String::Handle(interface.Name());
       const String& factory_name = String::Handle(factory_class.Name());
       const Script& script = Script::Handle(interface.script());
       ReportError(script, unresolved_factory_class.token_index(),
                   "mismatch in number, names, or bounds of type parameters "
                   "between default clause of interface '%s' and actual factory "
-                  "class '%s'.\n",
+                  "class '%s'",
                   interface_name.ToCString(),
                   factory_name.ToCString());
     }
   }
   // Verify that the type parameters of the factory class and of the interface
   // have identical names.
   const TypeArguments& interface_type_parameters =
       TypeArguments::Handle(interface.type_parameters());
   const TypeArguments& factory_type_parameters =
       TypeArguments::Handle(factory_class.type_parameters());
   if (!AbstractTypeArguments::AreEqual(interface_type_parameters,
                                        factory_type_parameters)) {
     const String& interface_name = String::Handle(interface.Name());
     const String& factory_name = String::Handle(factory_class.Name());
     const Script& script = Script::Handle(interface.script());
     ReportError(script, unresolved_factory_class.token_index(),
                 "mismatch in number or names of type parameters between "
-                "interface '%s' and default factory class '%s'.\n",
+                "interface '%s' and default factory class '%s'",
                 interface_name.ToCString(),
                 factory_name.ToCString());
   }
 }
 
 
-void ClassFinalizer::ResolveType(const Class& cls, const AbstractType& type) {
-  if (type.IsResolved()) {
+void ClassFinalizer::ResolveType(const Class& cls,
+                                 const AbstractType& type,
+                                 FinalizationKind finalization) {
+  if (type.IsResolved() || type.IsFinalized()) {
     return;
   }
   if (FLAG_trace_type_finalization) {
     OS::Print("Resolve type '%s'\n", String::Handle(type.Name()).ToCString());
   }
 
   // Resolve the type class.
   if (!type.HasResolvedTypeClass()) {
     // Type parameters are always resolved in the parser in the correct
     // non-static scope or factory scope. That resolution scope is unknown here.
     // Being able to resolve a type parameter from class cls here would indicate
     // that the type parameter appeared in a static scope. Leaving the type as
     // unresolved is the correct thing to do.
 
     // Lookup the type class.
     const UnresolvedClass& unresolved_class =
         UnresolvedClass::Handle(type.unresolved_class());
     const Class& type_class =
         Class::Handle(ResolveClass(cls, unresolved_class));
 
     // Replace unresolved class with resolved type class.
     ASSERT(type.IsType());
     Type& parameterized_type = Type::Handle();
     parameterized_type ^= type.raw();
-    parameterized_type.set_type_class(Object::Handle(type_class.raw()));
+    if (!type_class.IsNull()) {
+      parameterized_type.set_type_class(Object::Handle(type_class.raw()));
+    } else {
+      // The type class could not be resolved. The type is malformed.
+      FinalizeMalformedType(cls, parameterized_type, finalization,
+                            "cannot resolve class name '%s' from '%s'",
+                            String::Handle(unresolved_class.Name()).ToCString(),
+                            String::Handle(cls.Name()).ToCString());
+      return;
+    }
   }
 
   // Resolve type arguments, if any.
   const AbstractTypeArguments& arguments =
       AbstractTypeArguments::Handle(type.arguments());
   if (!arguments.IsNull()) {
     intptr_t num_arguments = arguments.Length();
     AbstractType& type_argument = AbstractType::Handle();
     for (intptr_t i = 0; i < num_arguments; i++) {
       type_argument = arguments.TypeAt(i);
-      ResolveType(cls, type_argument);
+      ResolveType(cls, type_argument, finalization);
     }
   }
 }
 
 
 // Finalize the type argument vector 'arguments' of the type defined by the
 // class 'cls' parameterized with the type arguments 'cls_args'.
 // The vector 'cls_args' is already initialized as a subvector at the correct
 // position in the passed in 'arguments' vector.
 // The subvector 'cls_args' has length cls.NumTypeParameters() and starts at
 // offset cls.NumTypeArguments() - cls.NumTypeParameters() of the 'arguments'
 // vector.
 // Example:
 //   Declared: class C<K, V> extends B<V> { ... }
 //             class B<T> extends A<int> { ... }
 //   Input:    C<String, double> expressed as
 //             cls = C, arguments = [null, null, String, double],
 //             i.e. cls_args = [String, double], offset = 2, length = 2.
 //   Output:   arguments = [int, double, String, double]
 void ClassFinalizer::FinalizeTypeArguments(
-    const Class& cls, const AbstractTypeArguments& arguments) {
+    const Class& cls,
+    const AbstractTypeArguments& arguments,
+    FinalizationKind finalization) {
   ASSERT(arguments.Length() >= cls.NumTypeArguments());
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
-    super_type ^= FinalizeType(cls, super_type);
+    super_type ^= FinalizeType(cls, super_type, finalization);
     cls.set_super_type(super_type);
     const Class& super_class = Class::Handle(super_type.type_class());
     const AbstractTypeArguments& super_type_args =
         AbstractTypeArguments::Handle(super_type.arguments());
     const intptr_t num_super_type_params = super_class.NumTypeParameters();
     const intptr_t offset = super_class.NumTypeArguments();
     const intptr_t super_offset = offset - num_super_type_params;
     ASSERT(offset == (cls.NumTypeArguments() - cls.NumTypeParameters()));
     AbstractType& super_type_arg = AbstractType::Handle();
     for (intptr_t i = 0; i < num_super_type_params; i++) {
       super_type_arg = super_type_args.TypeAt(super_offset + i);
       if (!super_type_arg.IsInstantiated()) {
         super_type_arg = super_type_arg.InstantiateFrom(arguments);
       }
       super_type_arg = super_type_arg.Canonicalize();
       arguments.SetTypeAt(super_offset + i, super_type_arg);
     }
-    FinalizeTypeArguments(super_class, arguments);
+    FinalizeTypeArguments(super_class, arguments, finalization);
   }
 }
 
 
 RawAbstractType* ClassFinalizer::FinalizeType(const Class& cls,
-                                              const AbstractType& type) {
-  ASSERT(type.IsResolved());
+                                              const AbstractType& type,
+                                              FinalizationKind finalization) {
   if (type.IsFinalized()) {
     return type.raw();
   }
+  ASSERT(type.IsResolved());
+
   if (FLAG_trace_type_finalization) {
     OS::Print("Finalize type '%s'\n", String::Handle(type.Name()).ToCString());
   }
 
   if (type.IsTypeParameter()) {
     ASSERT(!cls.IsNull());
     TypeParameter& type_parameter = TypeParameter::Handle();
     type_parameter ^= type.raw();
     // The index must reflect the position of this type parameter in the type
     // arguments vector of the enclosing class. The offset to add is the number
     // of type arguments in the super type, which is equal to the difference in
     // number of type arguments and type parameters of the enclosing class.
     const intptr_t offset = cls.NumTypeArguments() - cls.NumTypeParameters();
     type_parameter.set_index(type_parameter.Index() + offset);
     type_parameter.set_is_finalized();
     // We do not canonicalize type parameters.
     return type_parameter.raw();
   }
 
   // At this point, we can only have a parameterized_type.
   Type& parameterized_type = Type::Handle();
   parameterized_type ^= type.raw();
 
   if (parameterized_type.IsBeingFinalized()) {
-    const Script& script = Script::Handle(cls.script());
-    ReportError(script, parameterized_type.token_index(),
-                "type '%s' illegally refers to itself\n",
-                String::Handle(parameterized_type.Name()).ToCString());
+    // Self reference detected. The type is malformed.
+    FinalizeMalformedType(
+        cls, parameterized_type, finalization,
+        "type '%s' illegally refers to itself",
+        String::Handle(parameterized_type.Name()).ToCString());
+    return parameterized_type.raw();
   }
 
   // Mark type as being finalized in order to detect illegal self reference.
   parameterized_type.set_is_being_finalized();
 
   // Finalize the current type arguments of the type, which are still the
   // parsed type arguments.
   AbstractTypeArguments& arguments =
       AbstractTypeArguments::Handle(parameterized_type.arguments());
   if (!arguments.IsNull()) {
     intptr_t num_arguments = arguments.Length();
     for (intptr_t i = 0; i < num_arguments; i++) {
       AbstractType& type_argument = AbstractType::Handle(arguments.TypeAt(i));
-      type_argument = FinalizeType(cls, type_argument);
+      type_argument = FinalizeType(cls, type_argument, finalization);
       arguments.SetTypeAt(i, type_argument);
     }
   }
 
   // The type class does not need to be finalized in order to finalize the type,
   // however, it must at least be resolved (this was done as part of resolving
   // the type itself, a precondition to calling FinalizeType) and the upper
   // bounds of its type parameters must be finalized (done here).
   Class& type_class = Class::Handle(parameterized_type.type_class());
 
   // If the type class is a signature class, we are finalizing its signature
   // type, thereby finalizing the result type and parameter types of its
   // signature function.
   // Do this before marking this type as finalized in order to detect cycles.
   if (type_class.IsSignatureClass()) {
     // Signature classes are finalized upon creation.
     ASSERT(type_class.is_finalized());
     // Resolve and finalize the result and parameter types of the signature
     // function of this signature class.
     ResolveAndFinalizeSignature(
         type_class, Function::Handle(type_class.signature_function()));
   }
 
+  // Illegally self referencing function types may get finalized indirectly.
+  if (parameterized_type.IsFinalized()) {
+    ASSERT(parameterized_type.IsMalformed());
+    return parameterized_type.raw();
+  }
+
   // The finalized type argument vector needs num_type_arguments types.
   const intptr_t num_type_arguments = type_class.NumTypeArguments();
   // The type class has num_type_parameters type parameters.
   const intptr_t num_type_parameters = type_class.NumTypeParameters();
 
   // Initialize the type argument vector.
   // Check the number of parsed type arguments, if any.
   // Specifying no type arguments indicates a raw type, which is not an error.
   // However, type parameter bounds are checked below, even for a raw type.
   if (!arguments.IsNull() && (arguments.Length() != num_type_parameters)) {
-    const Script& script = Script::Handle(cls.script());
-    ReportError(script, type.token_index(),
-                "wrong number of type arguments in type '%s'\n",
-                String::Handle(type.Name()).ToCString());
+    // Wrong number of type arguments. The type is malformed.
+    FinalizeMalformedType(
+        cls, parameterized_type, finalization,
+        "wrong number of type arguments in type '%s'",
+        String::Handle(parameterized_type.Name()).ToCString());
+    return parameterized_type.raw();
   }
   // The full type argument vector consists of the type arguments of the
   // super types of type_class, which may be initialized from the parsed
   // type arguments, followed by the parsed type arguments.
   if (num_type_arguments > 0) {
     TypeArguments& full_arguments = TypeArguments::Handle(
         TypeArguments::New(num_type_arguments));
     // Copy the parsed type arguments at the correct offset in the full type
     // argument vector.
     const intptr_t offset = num_type_arguments - num_type_parameters;
     AbstractType& type = AbstractType::Handle(Type::DynamicType());
     for (intptr_t i = 0; i < num_type_parameters; i++) {
       // If no type parameters were provided, a raw type is desired, so we
       // create a vector of DynamicType.
       if (!arguments.IsNull()) {
         type = arguments.TypeAt(i);
       }
       full_arguments.SetTypeAt(offset + i, type);
     }
     if (type_class.IsSignatureClass()) {
       const Function& signature_fun =
           Function::Handle(type_class.signature_function());
       ASSERT(!signature_fun.is_static());
       const Class& signature_fun_owner = Class::Handle(signature_fun.owner());
-      FinalizeTypeArguments(signature_fun_owner, full_arguments);
+      FinalizeTypeArguments(signature_fun_owner, full_arguments, finalization);
     } else {
-      FinalizeTypeArguments(type_class, full_arguments);
+      FinalizeTypeArguments(type_class, full_arguments, finalization);
     }
     // FinalizeTypeArguments can modify 'full_arguments',
     // canonicalize afterwards.
     full_arguments ^= full_arguments.Canonicalize();
     parameterized_type.set_arguments(full_arguments);
 
-    // Mark the type as finalized before finalizing the upper bounds, because
-    // cycles via upper bounds are legal at compile time.
+    // Mark the type as finalized.
     parameterized_type.set_is_finalized();
 
-    ResolveAndFinalizeUpperBounds(type_class);
     // No need to verify the upper bounds of the finalized type arguments, since
     // bound errors are static type errors, which are not reported by the VM.
   } else {
     parameterized_type.set_is_finalized();
   }
   return parameterized_type.Canonicalize();
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeSignature(const Class& cls,
                                                  const Function& function) {
   // Resolve result type.
   AbstractType& type = AbstractType::Handle(function.result_type());
-  ResolveType(cls, type);
-  type = FinalizeType(cls, type);
+  FinalizationKind result_finalization = kFinalize;
+  if (function.IsFactory()) {
+    // The name of a factory must always be resolved to a class or interface.
+    // The parser sets the factory result type to a type with an unresolved
+    // class whose name matches the factory name.
+    result_finalization = kFinalizeWellFormed;
+  }
+  ResolveType(cls, type, result_finalization);
+  type = FinalizeType(cls, type, result_finalization);
   function.set_result_type(type);
   // Resolve formal parameter types.
   const intptr_t num_parameters = function.NumberOfParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = function.ParameterTypeAt(i);
-    ResolveType(cls, type);
-    type = FinalizeType(cls, type);
+    ResolveType(cls, type, kFinalize);
+    type = FinalizeType(cls, type, kFinalize);
     function.SetParameterTypeAt(i, type);
   }
 }
 
 
 static RawClass* FindSuperOwnerOfInstanceMember(const Class& cls,
                                                 const String& name) {
   Class& super_class = Class::Handle();
   Function& function = Function::Handle();
   Field& field = Field::Handle();
@@ skipping 34 matching lines @@
 // Resolve and finalize the upper bounds of the type parameters of class cls.
 void ClassFinalizer::ResolveAndFinalizeUpperBounds(const Class& cls) {
   const intptr_t num_type_params = cls.NumTypeParameters();
   AbstractType& bound = AbstractType::Handle();
   const AbstractTypeArguments& bounds =
       AbstractTypeArguments::Handle(cls.type_parameter_bounds());
   ASSERT((bounds.IsNull() && (num_type_params == 0)) ||
          (bounds.Length() == num_type_params));
   for (intptr_t i = 0; i < num_type_params; i++) {
     bound = bounds.TypeAt(i);
-    ResolveType(cls, bound);
-    bound = FinalizeType(cls, bound);
+    if (bound.IsDynamicType()) {
+      continue;
+    }
+    ResolveType(cls, bound, kFinalize);
+    bound = FinalizeType(cls, bound, kFinalize);
     bounds.SetTypeAt(i, bound);
   }
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeMemberTypes(const Class& cls) {
   // Note that getters and setters are explicitly listed as such in the list of
   // functions of a class, so we do not need to consider fields as implicitly
   // generating getters and setters.
   // The only compile errors we report are therefore:
   // - a getter having the same name as a method (but not a getter) in a super
   //   class or in a subclass.
   // - a setter having the same name as a method (but not a setter) in a super
   //   class or in a subclass.
   // - a static field, instance field, or static method (but not an instance
   //   method) having the same name as an instance member in a super class.
 
   // Resolve type of fields and check for conflicts in super classes.
   Array& array = Array::Handle(cls.fields());
   Field& field = Field::Handle();
   AbstractType& type = AbstractType::Handle();
   String& name = String::Handle();
   Class& super_class = Class::Handle();
   intptr_t num_fields = array.Length();
   for (intptr_t i = 0; i < num_fields; i++) {
     field ^= array.At(i);
     type = field.type();
-    ResolveType(cls, type);
-    type = FinalizeType(cls, type);
+    ResolveType(cls, type, kFinalize);
+    type = FinalizeType(cls, type, kFinalize);
     field.set_type(type);
     name = field.name();
     super_class = FindSuperOwnerOfInstanceMember(cls, name);
     if (!super_class.IsNull()) {
       const String& class_name = String::Handle(cls.Name());
       const String& super_class_name = String::Handle(super_class.Name());
       const Script& script = Script::Handle(cls.script());
       ReportError(script, field.token_index(),
                   "field '%s' of class '%s' conflicts with instance "
-                  "member '%s' of super class '%s'.\n",
+                  "member '%s' of super class '%s'",
                   name.ToCString(),
                   class_name.ToCString(),
                   name.ToCString(),
                   super_class_name.ToCString());
     }
   }
   // Resolve function signatures and check for conflicts in super classes.
   array = cls.functions();
   Function& function = Function::Handle();
   Function& overridden_function = Function::Handle();
   intptr_t num_functions = array.Length();
   String& function_name = String::Handle();
   for (intptr_t i = 0; i < num_functions; i++) {
     function ^= array.At(i);
     ResolveAndFinalizeSignature(cls, function);
     function_name = function.name();
     if (function.is_static()) {
       super_class = FindSuperOwnerOfInstanceMember(cls, function_name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
         const Script& script = Script::Handle(cls.script());
         ReportError(script, function.token_index(),
                     "static function '%s' of class '%s' conflicts with "
-                    "instance member '%s' of super class '%s'.\n",
+                    "instance member '%s' of super class '%s'",
                     function_name.ToCString(),
                     class_name.ToCString(),
                     function_name.ToCString(),
                     super_class_name.ToCString());
       }
     } else {
       // TODO(regis): This arity check is still being debated. Revisit.
       super_class = cls.SuperClass();
       while (!super_class.IsNull()) {
         overridden_function = super_class.LookupDynamicFunction(function_name);
         if (!overridden_function.IsNull() &&
           !function.HasCompatibleParametersWith(overridden_function)) {
           // Function types are purposely not checked for subtyping.
           const String& class_name = String::Handle(cls.Name());
           const String& super_class_name = String::Handle(super_class.Name());
           const Script& script = Script::Handle(cls.script());
           ReportError(script, function.token_index(),
                       "class '%s' overrides function '%s' of super class '%s' "
-                      "with incompatible parameters.\n",
+                      "with incompatible parameters",
                       class_name.ToCString(),
                       function_name.ToCString(),
                       super_class_name.ToCString());
         }
         super_class = super_class.SuperClass();
       }
     }
     if (function.kind() == RawFunction::kGetterFunction) {
       name = Field::NameFromGetter(function_name);
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
         const Script& script = Script::Handle(cls.script());
         ReportError(script, function.token_index(),
                     "getter '%s' of class '%s' conflicts with "
-                    "function '%s' of super class '%s'.\n",
+                    "function '%s' of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     } else if (function.kind() == RawFunction::kSetterFunction) {
       name = Field::NameFromSetter(function_name);
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
         const Script& script = Script::Handle(cls.script());
         ReportError(script, function.token_index(),
                     "setter '%s' of class '%s' conflicts with "
-                    "function '%s' of super class '%s'.\n",
+                    "function '%s' of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     } else {
       name = Field::GetterName(function_name);
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
         const Script& script = Script::Handle(cls.script());
         ReportError(script, function.token_index(),
                     "function '%s' of class '%s' conflicts with "
-                    "getter '%s' of super class '%s'.\n",
+                    "getter '%s' of super class '%s'",
                     function_name.ToCString(),
                     class_name.ToCString(),
                     function_name.ToCString(),
                     super_class_name.ToCString());
       }
       name = Field::SetterName(function_name);
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
         const Script& script = Script::Handle(cls.script());
         ReportError(script, function.token_index(),
                     "function '%s' of class '%s' conflicts with "
-                    "setter '%s' of super class '%s'.\n",
+                    "setter '%s' of super class '%s'",
                     function_name.ToCString(),
                     class_name.ToCString(),
                     function_name.ToCString(),
                     super_class_name.ToCString());
       }
     }
   }
 }
 
 
 void ClassFinalizer::FinalizeClass(const Class& cls, bool generating_snapshot) {
   if (cls.is_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("Finalize %s\n", cls.ToCString());
   }
   // Signature classes are finalized upon creation.
   ASSERT(!cls.IsSignatureClass());
   if (!IsSuperCycleFree(cls)) {
     const String& name = String::Handle(cls.Name());
     const Script& script = Script::Handle(cls.script());
     ReportError(script, cls.token_index(),
-                "class '%s' has a cycle in its superclass relationship.\n",
+                "class '%s' has a cycle in its superclass relationship",
                 name.ToCString());
   }
   GrowableArray<const Class*> visited;
   ResolveInterfaces(cls, &visited);
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     // Finalize super class and super type.
     FinalizeClass(super_class, generating_snapshot);
-    super_type ^= FinalizeType(cls, super_type);
+    super_type ^= FinalizeType(cls, super_type, kFinalizeWellFormed);
     cls.set_super_type(super_type);
   }
   if (cls.is_interface()) {
     if (cls.HasFactoryClass()) {
       const Class& factory_class = Class::Handle(cls.FactoryClass());
       // Finalize factory class.
       if (!factory_class.is_finalized()) {
         FinalizeClass(factory_class, generating_snapshot);
         // Finalizing the factory class may indirectly finalize this interface.
         if (cls.is_finalized()) {
           return;
         }
       }
     }
   }
   // Finalize interface types (but not necessarily interface classes).
   Array& interface_types = Array::Handle(cls.interfaces());
   AbstractType& interface_type = AbstractType::Handle();
   for (intptr_t i = 0; i < interface_types.Length(); i++) {
     interface_type ^= interface_types.At(i);
-    interface_type = FinalizeType(cls, interface_type);
+    interface_type = FinalizeType(cls, interface_type, kFinalizeWellFormed);
     interface_types.SetAt(i, interface_type);
   }
   // Mark as finalized before resolving type parameter upper bounds and member
   // types in order to break cycles.
   cls.Finalize();
   ResolveAndFinalizeUpperBounds(cls);
   ResolveAndFinalizeMemberTypes(cls);
   // Run additional checks after all types are finalized.
   if (cls.is_const()) {
     CheckForLegalConstClass(cls);
@@ skipping 83 matching lines @@
 // we found a loop.
 void ClassFinalizer::ResolveInterfaces(const Class& cls,
                                        GrowableArray<const Class*>* visited) {
   ASSERT(visited != NULL);
   for (int i = 0; i < visited->length(); i++) {
     if ((*visited)[i]->raw() == cls.raw()) {
       // We have already visited interface class 'cls'. We found a cycle.
       const String& interface_name = String::Handle(cls.Name());
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_index(),
-                  "Cyclic reference found for interface '%s'\n",
+                  "cyclic reference found for interface '%s'",
                   interface_name.ToCString());
     }
   }
 
   // If the class/interface has no explicit interfaces, we are done.
   Array& super_interfaces = Array::Handle(cls.interfaces());
   if (super_interfaces.Length() == 0) {
     return;
   }
 
   // If cls belongs to core lib or to core lib's implementation, restrictions
   // about allowed interfaces are lifted.
   const bool cls_belongs_to_core_lib =
       (cls.library() == Library::CoreLibrary()) ||
       (cls.library() == Library::CoreImplLibrary());
 
   // Resolve and check the interfaces of cls.
   visited->Add(&cls);
   AbstractType& interface = AbstractType::Handle();
   for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
     interface ^= super_interfaces.At(i);
-    ResolveType(cls, interface);
+    ResolveType(cls, interface, kFinalizeWellFormed);
     if (interface.IsTypeParameter()) {
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_index(),
-                  "Type parameter '%s' cannot be used as interface\n",
+                  "type parameter '%s' cannot be used as interface",
                   String::Handle(interface.Name()).ToCString());
     }
     const Class& interface_class = Class::Handle(interface.type_class());
     if (!interface_class.is_interface()) {
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_index(),
-                  "Class '%s' is used where an interface is expected\n",
+                  "class '%s' is used where an interface is expected",
                   String::Handle(interface_class.Name()).ToCString());
     }
     // Verify that unless cls belongs to core lib, it cannot extend or implement
     // any of bool, num, int, double, String, Function, Dynamic.
     // The exception is signature classes, which are compiler generated and
     // represent a function type, therefore implementing the Function interface.
     if (!cls_belongs_to_core_lib) {
       if (interface.IsBoolInterface() ||
           interface.IsNumberInterface() ||
           interface.IsIntInterface() ||
           interface.IsDoubleInterface() ||
           interface.IsStringInterface() ||
           (interface.IsFunctionInterface() && !cls.IsSignatureClass()) ||
           interface.IsDynamicType()) {
         const Script& script = Script::Handle(cls.script());
         ReportError(script, cls.token_index(),
-                    "'%s' is not allowed to extend or implement '%s'\n",
+                    "'%s' is not allowed to extend or implement '%s'",
                     String::Handle(cls.Name()).ToCString(),
                     String::Handle(interface_class.Name()).ToCString());
       }
     }
     // Now resolve the super interfaces.
     ResolveInterfaces(interface_class, visited);
   }
   visited->RemoveLast();
 }
 
 
 // A class is marked as constant if it has one constant constructor.
 // A constant class:
 // - may extend only const classes.
 // - has only const instance fields.
 // Note: we must check for cycles before checking for const properties.
 void ClassFinalizer::CheckForLegalConstClass(const Class& cls) {
   ASSERT(cls.is_const());
   const Class& super = Class::Handle(cls.SuperClass());
   if (!super.IsNull() && !super.is_const()) {
     String& name = String::Handle(super.Name());
     const Script& script = Script::Handle(cls.script());
     ReportError(script, cls.token_index(),
-                "superclass '%s' must be const.\n", name.ToCString());
+                "superclass '%s' must be const", name.ToCString());
   }
   const Array& fields_array = Array::Handle(cls.fields());
   intptr_t len = fields_array.Length();
   Field& field = Field::Handle();
   for (intptr_t i = 0; i < len; i++) {
     field ^= fields_array.At(i);
     if (!field.is_static() && !field.is_final()) {
       const String& class_name = String::Handle(cls.Name());
       const String& field_name = String::Handle(field.name());
       const Script& script = Script::Handle(cls.script());
       ReportError(script, field.token_index(),
-                  "const class '%s' has non-final field '%s'\n",
+                  "const class '%s' has non-final field '%s'",
                   class_name.ToCString(), field_name.ToCString());
     }
   }
 }
 
 
 void ClassFinalizer::PrintClassInformation(const Class& cls) {
   HANDLESCOPE(Isolate::Current());
   const String& class_name = String::Handle(cls.Name());
   OS::Print("%s '%s'",
@@ skipping 24 matching lines @@
   const Array& fields_array = Array::Handle(cls.fields());
   Field& field = Field::Handle();
   len = fields_array.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= fields_array.At(i);
     OS::Print("  %s\n", field.ToCString());
   }
 }
 
 
+void ClassFinalizer::FinalizeMalformedType(const Class& cls,
+                                           const Type& type,
+                                           FinalizationKind finalization,
+                                           const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  LanguageError& error = LanguageError::Handle();
+  if ((finalization == kFinalizeWellFormed) || FLAG_enable_type_checks) {
+    const Script& script = Script::Handle(cls.script());
+    error ^=
+        Parser::FormatError(script, type.token_index(), "Error", format, args);
+    if (finalization == kFinalizeWellFormed) {
+      ReportError(error);
+    }
+  }
+  // Replace malformed type with Dynamic type.
+  type.set_type_class(Class::Handle(Object::dynamic_class()));
+  type.set_arguments(AbstractTypeArguments::Handle());
+  if (FLAG_enable_type_checks) {
+    // In checked mode, mark type as malformed.
+    type.set_malformed_error(error);
+  }
+  type.set_is_finalized();
+  type.Canonicalize();
+}
+
+
+void ClassFinalizer::ReportError(const Error& error) {
+  Isolate::Current()->long_jump_base()->Jump(1, error);
+  UNREACHABLE();
+}
+
+
 void ClassFinalizer::ReportError(const Script& script,
                                  intptr_t token_index,
                                  const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(script, token_index, "Error", format, args));
-  Isolate::Current()->long_jump_base()->Jump(1, error);
-  UNREACHABLE();
+  ReportError(error);
 }
 
 
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
-  Isolate::Current()->long_jump_base()->Jump(1, error);
-  UNREACHABLE();
-}
-
-
-void ClassFinalizer::ReportWarning(const Script& script,
-                                  intptr_t token_index,
-                                  const char* format, ...) {
-  if (FLAG_silent_warnings) return;
-  va_list args;
-  va_start(args, format);
-  const Error& error = Error::Handle(
-      Parser::FormatError(script, token_index, "Warning", format, args));
-  va_end(args);
-  if (FLAG_warning_as_error) {
-    Isolate::Current()->long_jump_base()->Jump(1, error);
-    UNREACHABLE();
-  } else {
-    OS::Print("%s", error.ToErrorCString());
-  }
+  ReportError(error);
 }
 
 }  // namespace dart