Stop resolving classes prematurely in the vm (issue 11023).

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 237 matching lines @@
     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, or return null.
-RawClass* ClassFinalizer::ResolveClass(
-    const Class& cls, const UnresolvedClass& unresolved_class) {
+RawClass* ClassFinalizer::ResolveClass(const Class& cls,
+                                       const UnresolvedClass& unresolved_class,
+                                       Error* ambiguity_error) {
   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);
+    // TODO(regis): Call lib.LookupClass(class_name, ambiguity_error) instead
+    // once it takes the ambiguity_error parameter.
+
+    // First check if name is found in the local scope of the library.
+    Object& obj = Object::Handle(lib.LookupLocalObject(class_name));
+    if (!obj.IsNull() && obj.IsClass()) {
+      return Class::Cast(obj).raw();
+    }
+    // Now check if class_name is found in any imported libs.
+    String& first_lib_url = String::Handle();
+    Namespace& import = Namespace::Handle();
+    Library& import_lib = Library::Handle();
+    for (intptr_t i = 0; i < lib.num_imports(); i++) {
+      import ^= lib.ImportAt(i);
+      obj = import.Lookup(class_name);
+      if (!obj.IsNull()) {
+        import_lib = import.library();
+        if (!first_lib_url.IsNull()) {
+          // Found duplicate definition.
+          const Script& script = Script::Handle(cls.script());
+          if (first_lib_url.raw() == lib.url()) {
+            *ambiguity_error = Parser::FormatErrorMsg(
+                script, unresolved_class.token_pos(), "Error",
+                "ambiguous reference to '%s', "
+                "as library '%s' is imported multiple times",
+                class_name.ToCString(),
+                first_lib_url.ToCString());
+          } else {
+            *ambiguity_error = Parser::FormatErrorMsg(
+                script, unresolved_class.token_pos(), "Error",
+                "ambiguous reference: "
+                "'%s' is defined in library '%s' and also in '%s'",
+                class_name.ToCString(),
+                first_lib_url.ToCString(),
+                String::Handle(lib.url()).ToCString());
+          }
+          return Class::null();
+        }
+        first_lib_url = lib.url();
+        if (obj.IsClass()) {
+          resolved_class = Class::Cast(obj).raw();
+        }
+      }
+    }
   } else {
     LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
     lib_prefix = unresolved_class.library_prefix();
     ASSERT(!lib_prefix.IsNull());
     resolved_class = lib_prefix.LookupLocalClass(class_name);
   }
   return resolved_class.raw();
 }
 
 
@@ skipping 33 matching lines @@
     OS::Print("Resolving redirecting factory: %s\n",
               String::Handle(factory.name()).ToCString());
   }
   ResolveType(cls, type, kCanonicalize);
   type ^= FinalizeType(cls, type, kCanonicalize);
   factory.SetRedirectionType(type);
   if (type.IsMalformed()) {
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
+  ASSERT(!type.IsTypeParameter());  // Resolved in parser.
+  if (type.IsDynamicType()) {
+    // Replace the type with a malformed type and compile a throw when called.
+    type = NewFinalizedMalformedType(
+        Error::Handle(),  // No previous error.
+        cls,
+        factory.token_pos(),
+        kResolveTypeParameters,  // No compile-time error.
+        "factory may not redirect to 'dynamic'");
+    factory.SetRedirectionType(type);
+    ASSERT(factory.RedirectionTarget() == Function::null());
+    return;
+  }
   const Class& target_class = Class::Handle(type.type_class());
   String& target_class_name = String::Handle(target_class.Name());
   String& target_name = String::Handle(
       String::Concat(target_class_name, Symbols::Dot()));
   const String& identifier = String::Handle(factory.RedirectionIdentifier());
   if (!identifier.IsNull()) {
     target_name = String::Concat(target_name, identifier);
   }
 
   // Verify that the target constructor of the redirection exists.
   target = target_class.LookupConstructor(target_name);
   if (target.IsNull()) {
     target = target_class.LookupFactory(target_name);
   }
   if (target.IsNull()) {
     const String& user_visible_target_name =
         identifier.IsNull() ? target_class_name : target_name;
     // Replace the type with a malformed type and compile a throw when called.
     type = NewFinalizedMalformedType(
         Error::Handle(),  // No previous error.
         cls,
         factory.token_pos(),
-        kTryResolve,  // No compile-time error.
+        kResolveTypeParameters,  // No compile-time error.
         "class '%s' has no constructor or factory named '%s'",
         target_class_name.ToCString(),
         user_visible_target_name.ToCString());
     factory.SetRedirectionType(type);
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
 
   // Verify that the target is compatible with the redirecting factory.
   if (!target.HasCompatibleParametersWith(factory)) {
     type = NewFinalizedMalformedType(
         Error::Handle(),  // No previous error.
         cls,
         factory.token_pos(),
-        kTryResolve,  // No compile-time error.
+        kResolveTypeParameters,  // No compile-time error.
         "constructor '%s' has incompatible parameters with "
         "redirecting factory '%s'",
         String::Handle(target.name()).ToCString(),
         String::Handle(factory.name()).ToCString());
     factory.SetRedirectionType(type);
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
 
   // Verify that the target is const if the the redirecting factory is const.
@@ skipping 62 matching lines @@
   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());
+    Error& ambiguous_error = Error::Handle();
     const Class& type_class =
-        Class::Handle(ResolveClass(cls, unresolved_class));
+        Class::Handle(ResolveClass(cls, unresolved_class, &ambiguous_error));
 
     // Replace unresolved class with resolved type class.
     const Type& parameterized_type = Type::Cast(type);
     if (!type_class.IsNull()) {
       parameterized_type.set_type_class(type_class);
     } else {
       // The type class could not be resolved. The type is malformed.
-      FinalizeMalformedType(Error::Handle(),  // No previous error.
+      FinalizeMalformedType(ambiguous_error,  // May be null.
                             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 =
@@ skipping 403 matching lines @@
   // function type to refer to itself via its parameter types and result type.
   if (type_class.IsSignatureClass()) {
     // The class may be created while parsing a function body, after all
     // pending classes have already been finalized.
     FinalizeTypesInClass(type_class);
   }
 
   // If a bound error occurred, return a BoundedType with a malformed bound.
   // The malformed bound will be ignored in production mode.
   if (!bound_error.IsNull()) {
-    FinalizationKind bound_finalization = kTryResolve;  // No compile error.
+    // No compile-time error during finalization.
+    FinalizationKind bound_finalization = kResolveTypeParameters;
     if (FLAG_enable_type_checks || FLAG_error_on_malformed_type) {
       bound_finalization = finalization;
     }
     const String& parameterized_type_name = String::Handle(
         parameterized_type.UserVisibleName());
     const Type& malformed_bound = Type::Handle(
         NewFinalizedMalformedType(bound_error,
                                   cls,
                                   parameterized_type.token_pos(),
                                   bound_finalization,
@@ skipping 171 matching lines @@
         const Script& script = Script::Handle(cls.script());
         ReportError(script, field.token_pos(),
                     "field '%s' of class '%s' conflicts with method '%s' "
                     "of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     }
+    if ((FLAG_enable_type_checks || FLAG_error_on_malformed_type) &&
+        field.is_static() && field.is_const() &&
+        (field.value() != Object::null()) &&
+        (field.value() != Object::sentinel().raw())) {
+      // The parser does not preset the value if the type is a type parameter or
+      // is parameterized unless the value is null.
+      Error& malformed_error = Error::Handle();
+      if (type.IsMalformed()) {
+        malformed_error = type.malformed_error();
+      } else {
+        ASSERT(type.IsInstantiated());
+      }
+      const Instance& const_value = Instance::Handle(field.value());
+      if (!malformed_error.IsNull() ||
+          (!type.IsDynamicType() &&
+           !const_value.IsInstanceOf(type,
+                                     AbstractTypeArguments::Handle(),
+                                     &malformed_error))) {
+        // If the failure is due to a malformed type error, display it instead.
+        if (!malformed_error.IsNull()) {
+          ReportError(malformed_error);
+        } else {
+          const AbstractType& const_value_type = AbstractType::Handle(
+              const_value.GetType());
+          const String& const_value_type_name = String::Handle(
+              const_value_type.UserVisibleName());
+          const String& type_name = String::Handle(type.UserVisibleName());
+          const Script& script = Script::Handle(cls.script());
+          ReportError(script, field.token_pos(),
+                      "error initializing const field '%s': type '%s' is not a "
+                      "subtype of type '%s'",
+                      name.ToCString(),
+                      const_value_type_name.ToCString(),
+                      type_name.ToCString());
+        }
+      }
+    }
   }
   // Collect interfaces, super interfaces, and super classes of this class.
   const GrowableObjectArray& interfaces =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   CollectInterfaces(cls, interfaces);
   // Include superclasses in list of interfaces and super interfaces.
   super_class = cls.SuperClass();
   while (!super_class.IsNull()) {
     interfaces.Add(super_class);
     CollectInterfaces(super_class, interfaces);
@@ skipping 627 matching lines @@
   // are lifted.
   const bool cls_belongs_to_core_lib = cls.library() == Library::CoreLibrary();
 
   // Resolve and check the super type and interfaces of cls.
   visited->Add(cls_index);
   AbstractType& interface = AbstractType::Handle();
   Class& interface_class = Class::Handle();
 
   // Resolve super type. Failures lead to a longjmp.
   ResolveType(cls, super_type, kCanonicalizeWellFormed);
+  if (super_type.IsDynamicType()) {
+    const Script& script = Script::Handle(cls.script());
+    ReportError(script, cls.token_pos(),
+                "class '%s' may not extend 'dynamic'",
+                String::Handle(cls.Name()).ToCString());
+  }
 
   interface_class = super_type.type_class();
   // If cls belongs to core lib or to core lib's implementation, restrictions
   // about allowed interfaces are lifted.
   if (!cls_belongs_to_core_lib) {
     // Prevent extending core implementation classes.
     bool is_error = false;
     switch (interface_class.id()) {
       case kNumberCid:
       case kIntegerCid:  // Class Integer, not int.
@@ skipping 38 matching lines @@
                   String::Handle(interface_class.Name()).ToCString());
     }
   }
   // Now resolve the super interfaces of the super type.
   ResolveSuperTypeAndInterfaces(interface_class, visited);
 
   // Resolve interfaces. Failures lead to a longjmp.
   for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
     interface ^= super_interfaces.At(i);
     ResolveType(cls, interface, kCanonicalizeWellFormed);
-    if (interface.IsTypeParameter()) {
+    ASSERT(!interface.IsTypeParameter());  // Should be detected by parser.
+    if (interface.IsDynamicType()) {
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_pos(),
-                  "type parameter '%s' cannot be used as interface",
-                  String::Handle(interface.Name()).ToCString());
+                  "'dynamic' may not be used as interface");
     }
     interface_class = interface.type_class();
     if (interface_class.IsSignatureClass()) {
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_pos(),
                   "'%s' is used where an interface or class name 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.
@@ skipping 250 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