Support correct factory syntax in the VM as decribed in the spec.

runtime/vm/class_finalizer.cc

 // Copyright (c) 2011, 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"
 
 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 30 matching lines @@
   if (setjmp(*jump.Set()) == 0) {
     const Array& class_array = Array::Handle(object_store->pending_classes());
     ASSERT(!class_array.IsNull());
     Class& cls = Class::Handle();
     // First resolve all superclasses.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
       cls ^= class_array.At(i);
       if (FLAG_trace_class_finalization) {
         OS::Print("Resolving super and default: %s\n", cls.ToCString());
       }
-      ResolveSuperClass(cls);
+      ResolveSuperType(cls);
       if (cls.is_interface()) {
-        ResolveDefaultClass(cls);
+        ResolveFactoryClass(cls);
       }
     }
     // Finalize all classes.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
       cls ^= class_array.At(i);
       FinalizeClass(cls);
     }
     if (FLAG_print_classes) {
       for (intptr_t i = 0; i < class_array.Length(); i++) {
         cls ^= class_array.At(i);
@@ skipping 185 matching lines @@
     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 superclasses (String -> Class).
-void ClassFinalizer::ResolveSuperClass(const Class& cls) {
+// 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.
   super_type = ResolveType(cls, super_type);
   if (super_type.IsTypeParameter()) {
@@ skipping 44 matching lines @@
         (super_class.raw() == object_store->four_byte_string_class())) {
       ReportError("'%s' is not allowed to extend '%s'\n",
                   String::Handle(cls.Name()).ToCString(),
                   String::Handle(super_class.Name()).ToCString());
     }
   }
   return;
 }
 
 
-void ClassFinalizer::ResolveDefaultClass(const Class& interface) {
+void ClassFinalizer::ResolveFactoryClass(const Class& interface) {
   ASSERT(interface.is_interface());
-  if (interface.is_finalized()) {
+  if (interface.is_finalized() ||
+      !interface.HasFactoryClass() ||
+      interface.HasResolvedFactoryClass()) {
     return;
   }
-  Type& factory_type = Type::Handle(interface.factory_type());
-  if (factory_type.IsNull()) {
-    // No resolving needed.
+  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.is_interface()) {
+    const String& interface_name = String::Handle(interface.Name());
+    const String& factory_name = String::Handle(factory_class.Name());
+    ReportError("factory clause of interface '%s' names non-class '%s'.\n",
+                interface_name.ToCString(),
+                factory_name.ToCString());
+  }
+  interface.set_factory_class(factory_class);
+  // Check that the type parameter lists are identical.
+  const Class& factory_signature_class = Class::Handle(
+      unresolved_factory_class.factory_signature_class());
+  ASSERT(!factory_signature_class.IsNull());
+  ResolveAndFinalizeUpperBounds(factory_class);
+  ResolveAndFinalizeUpperBounds(factory_signature_class);
+  const intptr_t num_type_params = factory_signature_class.NumTypeParameters();
+  bool mismatch = factory_class.NumTypeParameters() != num_type_params;
+  if (mismatch && (num_type_params == 0)) {
+    // TODO(regis): For now, and until the core lib is fixed, we accept a
+    // factory clause with a class missing its list of type parameters.
+    // See bug 5408808.
+    const String& interface_name = String::Handle(interface.Name());
+    const String& factory_name = String::Handle(factory_class.Name());
+    ReportWarning("Warning: class '%s' in factory clause of interface '%s' is "
+                  "missing its type parameter list.\n",
+                  factory_name.ToCString(),
+                  interface_name.ToCString());
     return;
   }
-  // Resolve failures lead to a longjmp.
-  factory_type = ResolveType(interface, factory_type);
-  interface.set_factory_type(factory_type);
-  if (factory_type.IsInterfaceType()) {
+  String& expected_type_name = String::Handle();
+  String& actual_type_name = String::Handle();
+  Type& expected_type_extends = Type::Handle();
+  Type& actual_type_extends = Type::Handle();
+  const Array& expected_type_names =
+      Array::Handle(factory_signature_class.type_parameters());
+  const Array& actual_type_names =
+      Array::Handle(factory_class.type_parameters());
+  const TypeArray& expected_extends_array =
+      TypeArray::Handle(factory_signature_class.type_parameter_extends());
+  const TypeArray& actual_extends_array =
+      TypeArray::Handle(factory_class.type_parameter_extends());
+  for (intptr_t i = 0; !mismatch && (i < num_type_params); i++) {
+    expected_type_name ^= expected_type_names.At(i);
+    actual_type_name ^= actual_type_names.At(i);
+    expected_type_extends = expected_extends_array.TypeAt(i);
+    actual_type_extends = actual_extends_array.TypeAt(i);
+    if (!expected_type_name.Equals(actual_type_name) ||
+        !expected_type_extends.Equals(actual_type_extends)) {
+      mismatch = true;
+    }
+  }
+  if (mismatch) {
     const String& interface_name = String::Handle(interface.Name());
-    ReportError("default clause of interface '%s' does not name a class\n",
-                interface_name.ToCString());
+    const String& factory_name = String::Handle(factory_class.Name());
+    ReportError("mismatch in number or names of type parameters between "
+                "factory clause of interface '%s' and actual factory "
+                "class '%s'.\n",
+                interface_name.ToCString(),
+                factory_name.ToCString());
   }
 }
 
 
+// TODO(regis): Now that we do not resolve type parameters anymore, we could
+// make this function void and resolve the type in place.
 RawType* ClassFinalizer::ResolveType(const Class& cls, const Type& type) {
   if (type.IsResolved()) {
     return type.raw();
   }
   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 String& type_class_name = String::Handle(unresolved_class.ident());
-
-    // The type class name may be a type parameter of cls that was not resolved
-    // by the parser because it appeared as part of the declaration
-    // as T1 in B<T1, T2 extends A<T1>> or
-    // as T2 in B<T1 extends A<T2>, T2>>.
-    const TypeParameter& type_parameter = TypeParameter::Handle(
-        cls.LookupTypeParameter(type_class_name));
-    if (!type_parameter.IsNull()) {
-      // No need to check for proper instance scoping, since another type
-      // parameter must be involved for the type to still be unresolved.
-      // The scope checking was performed for the other type parameter already.
-
-      // A type parameter cannot be parameterized, so report an error if type
-      // arguments have previously been parsed.
-      if (type.arguments() != TypeArguments::null()) {
-        ReportError("type parameter '%s' cannot be parameterized",
-                    type_class_name.ToCString());
-      }
-      return type_parameter.raw();
-    }
-
-    // Lookup the type class.
     const Class& type_class =
         Class::Handle(ResolveClass(cls, unresolved_class));
 
     // Replace unresolved class with resolved type class.
     ASSERT(type.IsParameterizedType());
     ParameterizedType& parameterized_type = ParameterizedType::Handle();
     parameterized_type ^= type.raw();
     parameterized_type.set_type_class(Object::Handle(type_class.raw()));
   }
 
@@ skipping 71 matching lines @@
     type_extends = extends_array.TypeAt(i);
     if (!type_extends.IsDynamicType()) {
       type = arguments.TypeAt(offset + i);
       if (type.IsInstantiated()) {
         if (!type_extends.IsInstantiated()) {
           type_extends = type_extends.InstantiateFrom(arguments, offset);
         }
         // TODO(regis): Where do we check the constraints when the type is
         // generic?
         if (!type.IsSubtypeOf(type_extends)) {
-          const String& type_name = String::Handle(type.Name());
+          const String& type_argument_name = String::Handle(type.Name());
+          const String& class_name = String::Handle(cls.Name());
           const String& extends_name = String::Handle(type_extends.Name());
           ReportError("type argument '%s' of class '%s' "
                       "does not extend type '%s'\n",
-                      type_name.ToCString(),
+                      type_argument_name.ToCString(),
+                      class_name.ToCString(),
                       extends_name.ToCString());
         }
       }
     }
   }
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     ASSERT(super_type.IsFinalized());
     const Class& super_class = Class::Handle(super_type.type_class());
     VerifyUpperBounds(super_class, arguments);
@@ skipping 132 matching lines @@
   }
   UNREACHABLE();
   return Type::null();
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeSignature(const Class& cls,
                                                  const Function& function) {
   // Resolve result type.
   Type& type = Type::Handle(function.result_type());
-  type = ResolveType(cls, type);
-  function.set_result_type(type);
+  if (!type.IsResolved()) {
+    if (function.IsFactory()) {
+      // The signature class of the factory for a generic class holds the type
+      // parameters and their upper bounds. Copy the signature class from the
+      // result before it gets resolved.
+      const UnresolvedClass& unresolved_type_class =
+          UnresolvedClass::Handle(type.unresolved_class());
+      const Class& factory_signature_class =
+          Class::Handle(unresolved_type_class.factory_signature_class());
+      ASSERT(!factory_signature_class.IsNull());
+      function.set_signature_class(factory_signature_class);
+      type = ResolveType(cls, type);
+      function.set_result_type(type);
+      const Class& type_class = Class::Handle(type.type_class());
+      // Verify that the factory signature declares the same number of type
+      // parameters as the return type class or interface.
+      ResolveAndFinalizeUpperBounds(factory_signature_class);
+      if (factory_signature_class.NumTypeParameters() !=
+          type_class.NumTypeParameters()) {
+        const String& function_name = String::Handle(function.name());
+        if (factory_signature_class.NumTypeParameters() == 0) {
+          // TODO(regis): For now, and until the core lib is fixed, we accept a
+          // factory method with missing list of type parameters and use the
+          // list of the enclosing class.
+          // See bug 5408808.
+          const Class& enclosing_class = Class::Handle(function.owner());
+          function.set_signature_class(enclosing_class);
+          ReportWarning("Warning: factory method '%s' should declare a list of "
+                        "%d type parameter%s.\n",
+                        function_name.ToCString(),
+                        type_class.NumTypeParameters(),
+                        type_class.NumTypeParameters() > 1 ? "s" : "");
+        } else {
+          ReportError("factory method '%s' must declare %d type parameter%s.\n",
+                      function_name.ToCString(),
+                      type_class.NumTypeParameters(),
+                      type_class.NumTypeParameters() > 1 ? "s" : "");
+        }
+      }
+    } else {
+      type = ResolveType(cls, type);
+      function.set_result_type(type);
+    }
+  }
   type = FinalizeType(type);
   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);
     type = ResolveType(cls, type);
     function.SetParameterTypeAt(i, type);
     type = FinalizeType(type);
     function.SetParameterTypeAt(i, type);
@@ skipping 212 matching lines @@
   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);
     super_type = FinalizeType(super_type);
     cls.set_super_type(super_type);
   }
   if (cls.is_interface()) {
-    Type& factory_type = Type::Handle(cls.factory_type());
-    if (!factory_type.IsNull()) {
-      const Class& factory_class = Class::Handle(factory_type.type_class());
-      // Finalize factory class and factory type.
+    if (cls.HasFactoryClass()) {
+      const Class& factory_class = Class::Handle(cls.FactoryClass());
+      // Finalize factory class.
       if (!factory_class.is_finalized()) {
         FinalizeClass(factory_class);
         // Finalizing the factory class may indirectly finalize this interface.
         if (cls.is_finalized()) {
           return;
         }
       }
-      factory_type = FinalizeType(factory_type);
-      cls.set_factory_type(factory_type);
     }
   }
   // Finalize interface types (but not necessarily interface classes).
   Array& interface_types = Array::Handle(cls.interfaces());
   Type& interface_type = Type::Handle();
   for (intptr_t i = 0; i < interface_types.Length(); i++) {
     interface_type ^= interface_types.At(i);
     interface_type = FinalizeType(interface_type);
     interface_types.SetAt(i, interface_type);
   }
@@ skipping 247 matching lines @@
   char* msg_buffer = reinterpret_cast<char*>(zone->Allocate(kBufferLength + 1));
   ASSERT(msg_buffer != NULL);
   va_list args;
   va_start(args, format);
   OS::VSNPrint(msg_buffer, kBufferLength, format, args);
   va_end(args);
   isolate->long_jump_base()->Jump(1, msg_buffer);
   UNREACHABLE();
 }
 
+void ClassFinalizer::ReportWarning(const char* format, ...) {
+  if (FLAG_silent_warnings) return;
+  static const int kBufferLength = 1024;
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate != NULL);
+  Zone* zone = isolate->current_zone();
+  ASSERT(zone != NULL);
+  char* msg_buffer = reinterpret_cast<char*>(zone->Allocate(kBufferLength + 1));
+  ASSERT(msg_buffer != NULL);
+  va_list args;
+  va_start(args, format);
+  OS::VSNPrint(msg_buffer, kBufferLength, format, args);
+  va_end(args);
+  if (FLAG_warning_as_error) {
+    isolate->long_jump_base()->Jump(1, msg_buffer);
+    UNREACHABLE();
+  } else {
+    OS::Print(msg_buffer);
+  }
+}
+
 }  // namespace dart