Prohibit use of dynamic when extending or implementing classes (was crashing).

runtime/vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 50 matching lines @@
       }
     }
   }
 #endif
 }
 
 
 void AddSuperType(const AbstractType& type,
                   GrowableArray<intptr_t>* finalized_super_classes) {
   ASSERT(type.HasResolvedTypeClass());
+  ASSERT(!type.IsDynamicType());
   if (type.IsObjectType()) {
     return;
   }
   const Class& cls = Class::Handle(type.type_class());
   ASSERT(cls.is_finalized());
   const intptr_t cid = cls.id();
   for (intptr_t i = 0; i < finalized_super_classes->length(); i++) {
     if ((*finalized_super_classes)[i] == cid) {
       // Already added.
       return;
@@ skipping 72 matching lines @@
     }
     if (FLAG_print_classes) {
       for (intptr_t i = 0; i < class_array.Length(); i++) {
         cls ^= class_array.At(i);
         PrintClassInformation(cls);
       }
     }
     // Clear pending classes array.
     class_array = GrowableObjectArray::New();
     object_store->set_pending_classes(class_array);
+    VerifyImplicitFieldOffsets();  // Verification after an error may fail.
   } else {
     retval = false;
   }
   isolate->set_long_jump_base(base);
   if (FLAG_use_cha) {
     RemoveOptimizedCode(added_subclasses_to_cids);
   }
-  VerifyImplicitFieldOffsets();
   return retval;
 }
 
 
 // Adds all interfaces of cls into 'collected'. Duplicate entries may occur.
 // No cycles are allowed.
 void ClassFinalizer::CollectInterfaces(const Class& cls,
                                        const GrowableObjectArray& collected) {
   const Array& interface_array = Array::Handle(cls.interfaces());
   AbstractType& interface = AbstractType::Handle();
@@ skipping 709 matching lines @@
   } else {
     return parameterized_type.raw();
   }
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeSignature(const Class& cls,
                                                  const Function& function) {
   // Resolve result type.
   AbstractType& type = AbstractType::Handle(function.result_type());
-  // TODO(regis): Remove this code once the parser checks the factory name and
-  // once the core library is fixed. See issue 6641.
-  // In case of a factory, the parser sets the factory result type to a type
-  // with an unresolved class whose name matches the factory name and no type
-  // arguments. We resolve the class and specify type arguments in case the
-  // class is generic.
-  if (function.IsFactory()) {
-    Type& factory_result_type = Type::Handle();
-    factory_result_type ^= type.raw();
-    ASSERT(factory_result_type.arguments() == TypeArguments::null());
-    const UnresolvedClass& unresolved_factory_class =
-        UnresolvedClass::Handle(factory_result_type.unresolved_class());
-    const Class& factory_class =
-        Class::Handle(ResolveClass(cls, unresolved_factory_class));
-    if (factory_class.IsNull()) {
-      type = NewFinalizedMalformedType(
-          Error::Handle(),  // No previous error.
-          cls,
-          unresolved_factory_class.token_pos(),
-          kTryResolve,  // No compile-time error.
-          "cannot resolve factory class name '%s' from '%s'",
-          String::Handle(unresolved_factory_class.Name()).ToCString(),
-          String::Handle(cls.Name()).ToCString());
-    } else {
-      type = Type::New(factory_class,
-                       TypeArguments::Handle(factory_class.type_parameters()),
-                       unresolved_factory_class.token_pos());
-    }
-  }
   // It is not a compile time error if this name does not resolve to a class or
   // interface.
   ResolveType(cls, type, kCanonicalize);
   type = FinalizeType(cls, type, kCanonicalize);
   // In production mode, a malformed result type is mapped to dynamic.
   if (!FLAG_enable_type_checks && type.IsMalformed()) {
     type = Type::DynamicType();
   }
   function.set_result_type(type);
   // Resolve formal parameter types.
@@ skipping 1083 matching lines @@
   expected_name ^= String::New("_offset");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
   field ^= fields_array.At(2);
   ASSERT(field.Offset() == TypedDataView::length_offset());
   name ^= field.name();
   ASSERT(name.Equals("length"));
 #endif
 }
 
 }  // namespace dart