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

runtime/vm/object.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 "vm/object.h"
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 1893 matching lines @@
 }
 
 
 bool AbstractType::IsBeingFinalized() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
+bool AbstractType::IsMalformed() const {
+  // AbstractType is an abstract class.
+  UNREACHABLE();
+  return false;
+}
+
+
+RawError* AbstractType::malformed_error() const {
+  // AbstractType is an abstract class.
+  UNREACHABLE();
+  return Error::null();
+}
+
+
+void AbstractType::set_malformed_error(const Error& value) const {
+  // AbstractType is an abstract class.
+  UNREACHABLE();
+}
+
+
 bool AbstractType::Equals(const AbstractType& other) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
 RawAbstractType* AbstractType::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments) const {
   // AbstractType is an abstract class.
@@ skipping 276 matching lines @@
   set_type_state(RawType::kFinalized);
 }
 
 
 void Type::set_is_being_finalized() const {
   ASSERT(!IsFinalized() && !IsBeingFinalized());
   set_type_state(RawType::kBeingFinalized);
 }
 
 
+bool Type::IsMalformed() const {
+  return raw_ptr()->malformed_error_ != Error::null();
+}
+
+
+void Type::set_malformed_error(const Error& value) const {
+  StorePointer(&raw_ptr()->malformed_error_, value.raw());
+}
+
+
+RawError* Type::malformed_error() const {
+  ASSERT(IsMalformed());
+  return raw_ptr()->malformed_error_;
+}
+
+
 bool Type::IsResolved() const {
   if (IsFinalized()) {
     return true;
   }
   if (!HasResolvedTypeClass()) {
     return false;
   }
   const AbstractTypeArguments& args =
       AbstractTypeArguments::Handle(arguments());
   return args.IsNull() || args.IsResolved();
@@ skipping 51 matching lines @@
   instantiated_type.set_is_finalized();
   return instantiated_type.raw();
 }
 
 
 bool Type::Equals(const AbstractType& other) const {
   ASSERT(IsFinalized() && other.IsFinalized());
   if (raw() == other.raw()) {
     return true;
   }
-  if (!other.IsType()) {
+  if (IsMalformed() || !other.IsType() || other.IsMalformed()) {
     return false;
   }
   Type& other_parameterized_type = Type::Handle();
   other_parameterized_type ^= other.raw();
   if (type_class() != other_parameterized_type.type_class()) {
     return false;
   }
   return AbstractTypeArguments::AreEqual(
       AbstractTypeArguments::Handle(arguments()),
       AbstractTypeArguments::Handle(other.arguments()));
@@ skipping 365 matching lines @@
 
 
 bool AbstractTypeArguments::IsDynamicTypes(intptr_t len) const {
   ASSERT(Length() >= len);
   AbstractType& type = AbstractType::Handle();
   Class& type_class = Class::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(i);
     ASSERT(!type.IsNull());
     if (!type.HasResolvedTypeClass()) {
-      ASSERT(type.IsTypeParameter());
+      ASSERT(type.IsTypeParameter() || type.IsMalformed());
       return false;
     }
     type_class = type.type_class();
     if (!type_class.IsDynamicClass()) {
       return false;
     }
   }
   return true;
 }
 
@@ skipping 781 matching lines @@
     const Script& script = Script::Handle(owner_class.script());
     signature_class = Class::NewSignatureClass(signature,
                                                closure_function,
                                                script);
     library.AddClass(signature_class);
   } else {
     closure_function.set_signature_class(signature_class);
   }
   const Type& signature_type = Type::Handle(signature_class.SignatureType());
   if (!signature_type.IsFinalized()) {
-    ClassFinalizer::FinalizeType(signature_class, signature_type);
+    ClassFinalizer::FinalizeType(
+        signature_class, signature_type, ClassFinalizer::kFinalize);
   }
   ASSERT(closure_function.signature_class() == signature_class.raw());
   set_implicit_closure_function(closure_function);
   ASSERT(closure_function.IsImplicitClosureFunction());
   return closure_function.raw();
 }
 
 
 template<typename T>
 static RawArray* NewArray(const GrowableArray<T*>& objs) {
@@ skipping 4886 matching lines @@
   result.set_num_args_tested(num_args_tested);
   // Number of array elements in one test entry (num_args_tested + 1)
   intptr_t len = num_args_tested + 1;
   // IC data array must be null terminated (sentinel entry).
   Array& ic_data = Array::Handle(Array::New(len, Heap::kOld));
   result.set_ic_data(ic_data);
   return result.raw();
 }
 
 }  // namespace dart