Implement revised factories in the VM.

runtime/vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 13 matching lines @@
 DEFINE_FLAG(bool, enable_asserts, false, "Enable assert statements.");
 DEFINE_FLAG(bool, enable_type_checks, false, "Enable type checks.");
 DEFINE_FLAG(bool, trace_parser, false, "Trace parser operations.");
 DEFINE_FLAG(bool, warning_as_error, false, "Treat warnings as errors.");
 DEFINE_FLAG(bool, silent_warnings, false, "Silence warnings.");
 
 // All references to Dart names are listed here.
 static const char* kAssertionErrorName = "AssertionError";
 static const char* kFallThroughErrorName = "FallThroughError";
 static const char* kThrowNewName = "_throwNew";
-static const char* kLiteralFactoryClassName = "_LiteralFactory";
-static const char* kLiteralFactoryListFromLiteralName = "List.fromLiteral";
-static const char* kLiteralFactoryMapFromLiteralName = "Map.fromLiteral";
+static const char* kListLiteralFactoryClassName = "_ListLiteralFactory";
+static const char* kListLiteralFactoryName = "List.fromLiteral";
+static const char* kMapLiteralFactoryClassName = "_MapLiteralFactory";
+static const char* kMapLiteralFactoryName = "Map.fromLiteral";
 static const char* kImmutableMapName = "ImmutableMap";
 static const char* kImmutableMapConstructorName = "ImmutableMap._create";
 static const char* kStringClassName = "StringBase";
 static const char* kInterpolateName = "_interpolate";
 static const char* kThisName = "this";
 static const char* kPhaseParameterName = ":phase";
 static const char* kGetIteratorName = "iterator";
 
 #if defined(DEBUG)
 
@@ skipping 512 matching lines @@
     CompilerStats::parser_timer.Start();
   }
   SequenceNode* node_sequence = NULL;
   Array& default_parameter_values = Array::Handle();
   switch (func.kind()) {
     case RawFunction::kFunction:
     case RawFunction::kClosureFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction:
     case RawFunction::kConstructor:
-      ASSERT(!func.IsFactory() || (func.signature_class() != Class::null()));
       node_sequence = parser.ParseFunc(func, default_parameter_values);
       break;
     case RawFunction::kImplicitGetter:
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceGetter(func);
       break;
     case RawFunction::kImplicitSetter:
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceSetter(func);
       break;
@@ skipping 1739 matching lines @@
         member.type = &AbstractType::ZoneHandle(ParseType(kCanResolve));
       }
     }
   }
   // Optionally parse a (possibly named) constructor name or factory.
   if ((CurrentToken() == Token::kIDENT) &&
       (CurrentLiteral()->Equals(members->class_name()) || member.has_factory)) {
     member.name = CurrentLiteral();
     member.name_pos = this->token_index_;
     ConsumeToken();
-    // Resolution of the factory result type is always postponed until class
-    // finalization, so that the list of type parameters in the factory
-    // signature can be checked at the same time.
     if (member.has_factory) {
       String& qualifier = String::Handle();
       if (CurrentToken() == Token::kPERIOD) {
         LibraryPrefix& lib_prefix = LibraryPrefix::ZoneHandle();
         lib_prefix = current_class().LookupLibraryPrefix(*member.name);
         if (!lib_prefix.IsNull()) {
           // We have a library prefix qualified identifier.
           ConsumeToken();  // Consume the kPERIOD token.
           qualifier ^= member.name->raw();
           member.name = ExpectIdentifier("identifier expected");
         }
       }
+      // TODO(regis): Remove support for type parameters on factories.
+      // Once done, stop postponing resolution of the factory result type until
+      // class finalization.
       const UnresolvedClass& unresolved_factory_class =
           UnresolvedClass::Handle(UnresolvedClass::New(member.name_pos,
                                                        qualifier,
                                                        *(member.name)));
       const Class& signature_class = Class::Handle(
           Class::New(String::Handle(String::NewSymbol(":factory_signature")),
                      script_));
       signature_class.set_is_finalized();
       signature_class.set_library(library_);
       unresolved_factory_class.set_factory_signature_class(signature_class);
       // The type arguments of the result type are set during finalization.
       const TypeArguments& args = TypeArguments::Handle();
       member.type = &Type::ZoneHandle(
           Type::NewParameterizedType(unresolved_factory_class, args));
       ParseTypeParameters(signature_class);
+      if (signature_class.NumTypeParameters() > 0) {
+        Warning("factory method '%s' should not declare type parameters.\n",
+                member.name->ToCString());
+      } else {
+        // Remove factory signature class, since no type parameters declared.
+        unresolved_factory_class.set_factory_signature_class(Class::Handle());
+      }
     }
     // We must be dealing with a constructor or named constructor.
     member.kind = RawFunction::kConstructor;
     String& ctor_suffix = String::ZoneHandle(String::NewSymbol("."));
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
       ConsumeToken();
       const String* name = ExpectIdentifier("identifier expected");
       ctor_suffix = String::Concat(ctor_suffix, *name);
     }
@@ skipping 370 matching lines @@
   set_current_class(interface);
   ParseTypeParameters(interface);
 
   if (CurrentToken() == Token::kEXTENDS) {
     Array& interfaces = Array::Handle();
     const intptr_t interfaces_pos = token_index_;
     interfaces = ParseInterfaceList();
     AddInterfaces(interfaces_pos, interface, interfaces);
   }
 
-  if (CurrentToken() == Token::kFACTORY) {
+  // TODO(regis): Remove support for "factory" keyword.
+  if ((CurrentToken() == Token::kDEFAULT) ||
+      (CurrentToken() == Token::kFACTORY)) {
+    if (CurrentToken() == Token::kFACTORY) {
+      Warning("'factory' is obsolete, use 'default' instead.");
+    }
     ConsumeToken();
     const intptr_t factory_pos = token_index_;
     QualIdent factory_name;
     ParseQualIdent(&factory_name);
     if (factory_name.is_local_scope_ident) {
       ErrorMsg(factory_pos,
                "using '%s' in this context is invalid",
                factory_name.ident->ToCString());
     }
     String& qualifier = String::Handle();
     if (factory_name.qualifier != NULL) {
       qualifier ^= factory_name.qualifier->raw();
     }
     const UnresolvedClass& unresolved_factory_class = UnresolvedClass::Handle(
         UnresolvedClass::New(factory_pos, qualifier, *(factory_name.ident)));
-    const Class& signature_class = Class::Handle(
+    const Class& factory_class = Class::Handle(
         Class::New(String::Handle(String::NewSymbol(":factory_signature")),
                    script_));
-    signature_class.set_library(library_);
-    signature_class.set_is_finalized();
-    ParseTypeParameters(signature_class);
-    unresolved_factory_class.set_factory_signature_class(signature_class);
+    factory_class.set_library(library_);
+    factory_class.set_is_finalized();
+    ParseTypeParameters(factory_class);
+    unresolved_factory_class.set_factory_signature_class(factory_class);
     interface.set_factory_class(unresolved_factory_class);
+    // Verify that the type parameters of the factory class and of the interface
+    // have identical names.
+    const intptr_t num_type_params = factory_class.NumTypeParameters();
+    bool mismatch = interface.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());
+      Warning(factory_pos,
+              "class '%s' in default clause of interface '%s' is "
+              "missing its type parameter list.\n",
+              factory_name.ToCString(),
+              interface_name.ToCString());
+    } else {
+      String& interface_type_param_name = String::Handle();
+      String& factory_type_param_name = String::Handle();
+      const Array& interface_type_param_names =
+          Array::Handle(interface.type_parameters());
+      const Array& factory_type_param_names =
+          Array::Handle(factory_class.type_parameters());
+      for (intptr_t i = 0; !mismatch && (i < num_type_params); i++) {
+        interface_type_param_name ^= interface_type_param_names.At(i);
+        factory_type_param_name ^= factory_type_param_names.At(i);
+        if (!interface_type_param_name.Equals(factory_type_param_name)) {
+          mismatch = true;
+        }
+      }
+      if (mismatch) {
+        const String& interface_name = String::Handle(interface.Name());
+        const String& factory_name = String::Handle(factory_class.Name());
+        ErrorMsg(factory_pos,
+                 "mismatch in number or names of type parameters between "
+                 "interface '%s' and default factory class '%s'.\n",
+                 interface_name.ToCString(),
+                 factory_name.ToCString());
+      }
+    }
   }
 
   ExpectToken(Token::kLBRACE);
   ClassDesc members(interface, interface_name, true, interface_pos);
   while (CurrentToken() != Token::kRBRACE) {
     ParseClassMemberDefinition(&members);
   }
   ExpectToken(Token::kRBRACE);
 
   interface.SetFields(Array::Handle(NewArray<Field>(members.fields())));
@@ skipping 3372 matching lines @@
 RawClass* Parser::TypeParametersScopeClass() {
   // Type parameters cannot be referred to from a static function, except from
   // a constructor or from a factory.
   // A constructor is considered as non-static by the compiler.
   if (is_top_level_) {
     if ((current_member_ != NULL) && current_member_->has_factory) {
       const AbstractType& factory_result_type = *current_member_->type;
       ASSERT(!factory_result_type.IsNull());
       const UnresolvedClass& unresolved_factory_class =
           UnresolvedClass::Handle(factory_result_type.unresolved_class());
-      // 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.
-      // Therefore, we temporarily return the current class instead of the
-      // factory signature class if the latter one does not declare any type
-      // parameters.
-      const Class& factory_signature_class =
-          Class::Handle(unresolved_factory_class.factory_signature_class());
-      if (factory_signature_class.NumTypeParameters() == 0) {
-        return current_class().raw();
-      } else {
-        return factory_signature_class.raw();
+      // TODO(regis): Remove support for type parameters declared by factory
+      // methods.
+      if (unresolved_factory_class.factory_signature_class() != Class::null()) {
+        return unresolved_factory_class.factory_signature_class();
       }
+      return current_class().raw();
     }
     if ((current_member_ == NULL) || !current_member_->has_static) {
       return current_class().raw();
     }
   } else {
     if (!current_function().IsNull()) {
       Function& outer_function = Function::Handle(current_function().raw());
       while (outer_function.IsLocalFunction()) {
         outer_function = outer_function.parent_function();
       }
       if (outer_function.IsFactory()) {
-        return outer_function.signature_class();
+        // TODO(regis): Remove support for type parameters declared by factory
+        // methods.
+        if (outer_function.signature_class() != Class::null()) {
+          return outer_function.signature_class();
+        }
+        return current_class().raw();
       }
       if (!outer_function.is_static()) {
         return current_class().raw();
       }
     }
   }
   return Class::null();
 }
 
 
 bool Parser::IsInstantiatorRequired() const {
   ASSERT(!current_function().IsNull());
   Function& outer_function = Function::Handle(current_function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
-    const Class& signature_class =
-        Class::Handle(outer_function.signature_class());
+    // TODO(regis): Remove support for type parameters on factories.
+    Class& signature_class = Class::Handle(outer_function.signature_class());
+    if (signature_class.IsNull()) {
+      return current_class().NumTypeParameters() > 0;
+    }
     return signature_class.NumTypeParameters() > 0;
   }
   if (!outer_function.is_static()) {
     return current_class().NumTypeParameters() > 0;
   }
   return false;
 }
 
 
 void Parser::RunStaticFieldInitializer(const Field& field) {
@@ skipping 392 matching lines @@
     }
   }
   return type.raw();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
     intptr_t pos, Function& constructor,
     const AbstractTypeArguments& type_arguments) {
   if (!type_arguments.IsNull()) {
+    // TODO(regis): Remove support for type parameters on factories.
     Class& signature_class = Class::Handle();
-    if (constructor.IsFactory()) {
+    if (constructor.IsFactory() &&
+        (constructor.signature_class() != Class::null())) {
       signature_class = constructor.signature_class();
     } else {
       signature_class = constructor.owner();
     }
     ASSERT(!signature_class.IsNull());
     ASSERT(signature_class.is_finalized());
     // Do not report the expected vs. actual number of type arguments, because
     // the type argument vector is flattened and raw types are allowed.
     if (type_arguments.Length() != signature_class.NumTypeArguments()) {
       ErrorMsg(pos, "wrong number of type arguments passed to constructor");
@@ skipping 94 matching lines @@
                  i,
                  String::Handle(element_type.Name()).ToCString());
       }
       const_list.SetAt(i, elem->AsLiteralNode()->literal());
     }
     const_list ^= const_list.Canonicalize();
     const_list.MakeImmutable();
     return new LiteralNode(literal_pos, const_list);
   } else {
     // Factory call at runtime.
-    String& literal_factory_class_name = String::Handle(
-        String::NewSymbol(kLiteralFactoryClassName));
-    const Class& literal_factory_class =
-        Class::Handle(LookupCoreClass(literal_factory_class_name));
-    ASSERT(!literal_factory_class.IsNull());
-    const String& literal_list_factory_name =
-        String::Handle(String::NewSymbol(kLiteralFactoryListFromLiteralName));
-    const Function& literal_list_factory = Function::ZoneHandle(
-        literal_factory_class.LookupFactory(literal_list_factory_name));
-    ASSERT(!literal_list_factory.IsNull());
+    String& list_literal_factory_class_name = String::Handle(
+        String::NewSymbol(kListLiteralFactoryClassName));
+    const Class& list_literal_factory_class =
+        Class::Handle(LookupCoreClass(list_literal_factory_class_name));
+    ASSERT(!list_literal_factory_class.IsNull());
+    const String& list_literal_factory_name =
+        String::Handle(String::NewSymbol(kListLiteralFactoryName));
+    const Function& list_literal_factory = Function::ZoneHandle(
+        list_literal_factory_class.LookupFactory(list_literal_factory_name));
+    ASSERT(!list_literal_factory.IsNull());
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
     }
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
     factory_param->Add(list);
     AbstractTypeArguments& canonical_type_arguments =
         AbstractTypeArguments::ZoneHandle(type_arguments.Canonicalize());
     return new ConstructorCallNode(literal_pos,
                                    canonical_type_arguments,
-                                   literal_list_factory,
+                                   list_literal_factory,
                                    factory_param);
   }
 }
 
 
 static void AddKeyValuePair(ArrayNode* pairs,
                             bool is_const,
                             AstNode* key,
                             AstNode* value) {
   if (is_const) {
@@ skipping 160 matching lines @@
                                      map_type_arguments,
                                      map_constr,
                                      constr_args));
     if (const_instance.IsUnhandledException()) {
       return CreateEvalConstConstructorThrow(literal_pos, const_instance);
     } else {
       return new LiteralNode(literal_pos, const_instance);
     }
   } else {
     // Factory call at runtime.
-    String& literal_factory_class_name = String::Handle(
-        String::NewSymbol(kLiteralFactoryClassName));
-    const Class& literal_factory_class =
-        Class::Handle(LookupCoreClass(literal_factory_class_name));
-    ASSERT(!literal_factory_class.IsNull());
-    const String& literal_map_factory_name =
-        String::Handle(String::NewSymbol(kLiteralFactoryMapFromLiteralName));
-    const Function& literal_map_factory = Function::ZoneHandle(
-        literal_factory_class.LookupFactory(literal_map_factory_name));
-    ASSERT(!literal_map_factory.IsNull());
+    String& map_literal_factory_class_name = String::Handle(
+        String::NewSymbol(kMapLiteralFactoryClassName));
+    const Class& map_literal_factory_class =
+        Class::Handle(LookupCoreClass(map_literal_factory_class_name));
+    ASSERT(!map_literal_factory_class.IsNull());
+    const String& map_literal_factory_name =
+        String::Handle(String::NewSymbol(kMapLiteralFactoryName));
+    const Function& map_literal_factory = Function::ZoneHandle(
+        map_literal_factory_class.LookupFactory(map_literal_factory_name));
+    ASSERT(!map_literal_factory.IsNull());
     if (!map_type_arguments.IsNull() &&
         !map_type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
     }
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
     factory_param->Add(kv_pairs);
     return new ConstructorCallNode(literal_pos,
                                    map_type_arguments,
-                                   literal_map_factory,
+                                   map_literal_factory,
                                    factory_param);
   }
 }
 
 
 AstNode* Parser::ParseCompoundLiteral() {
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
     ConsumeToken();
@@ skipping 167 matching lines @@
   if (!constructor.AreValidArguments(arguments_length, arguments->names())) {
     ErrorMsg(new_pos, "invalid arguments passed to constructor '%s' "
              "for class '%s'",
              external_constructor_name.ToCString(),
              String::Handle(type_class.Name()).ToCString());
   }
 
   // Now that the constructor to be called is identified, finalize the type
   // argument vector to be passed.
   {
+    // TODO(regis): Remove support for type parameters on factories.
     Class& signature_class = Class::Handle();
-    if (constructor.IsFactory()) {
+    if (constructor.IsFactory() &&
+        (constructor.signature_class() != Class::null())) {
       signature_class = constructor.signature_class();
     } else {
       signature_class = constructor.owner();
       ASSERT(signature_class.raw() == type_class.raw());
     }
     // TODO(regis): Temporary type should be allocated in new gen heap.
     Type& type = Type::Handle(
         Type::NewParameterizedType(signature_class, type_arguments));
     String& errmsg = String::Handle();
     type ^= ClassFinalizer::FinalizeAndCanonicalizeType(signature_class,
@@ skipping 471 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart