Fix parsing of factory calls (issue 500).

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 6447 matching lines @@
     intptr_t pos, Function& constructor, const TypeArguments& type_arguments) {
   if (!type_arguments.IsNull()) {
     Class& signature_class = Class::Handle();
     if (constructor.IsFactory()) {
       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, "incorrect number of type arguments, expected %d got %d",
-               signature_class.NumTypeArguments(),
-               type_arguments.Length());
+      ErrorMsg(pos, "wrong number of type arguments passed to constructor");
     }
   }
 }
 
 
 // Parse "[" [ expr { "," expr } ["," ] "]".
 // Note: if the array literal is empty and the brackets have no whitespace
 // between them, the scanner recognizes the opening and closing bracket
 // as one token of type Token::kINDEX.
 AstNode* Parser::ParseArrayLiteral(intptr_t type_pos,
@@ skipping 262 matching lines @@
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("type name expected");
   }
 
   // The grammar allows for an optional ('.' identifier)?, which is a named
   // constructor. For that reason, we cannot unconditionally call
   // ParseType(kMustResolve) after we see an identifier, because the named
   // constructor would be misinterpreted as a qualified type name.
   // TODO(regis): Revisit once we correctly support qualified identifiers.
   // For now, we inline a customized version of ParseType(kMustResolve).
-  Type& type = Type::Handle();
-  Class& type_class = Class::ZoneHandle();
-  String& type_class_name = String::Handle();
-  TypeArguments& type_arguments = TypeArguments::ZoneHandle();
-  String* named_constructor = NULL;
   const intptr_t  type_pos = token_index_;
   QualIdent type_name;
   ParseQualIdent(&type_name);
   if (type_name.is_local_scope_ident) {
     ErrorMsg(type_pos, "using '%s' in this context is invalid",
              type_name.ident->ToCString());
   }
+  String* named_constructor = NULL;
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     named_constructor = ExpectIdentifier("identifier expected after '.'");
   }
   const Class& scope_class = Class::Handle(TypeParametersScopeClass());
   if (!scope_class.IsNull()) {
     TypeParameter& type_parameter = TypeParameter::Handle();
     if (type_name.lib_prefix != NULL) {
       // Check if qualifier is a type parameter in scope.
       type_parameter ^= scope_class.LookupTypeParameter(*type_name.qualifier);
       if (!type_parameter.IsNull()) {
         ErrorMsg(type_pos, "type parameter '%s' cannot be used as qualifier",
                  String::Handle(type_parameter.Name()).ToCString());
       }
     }
     // Check if ident is a type parameter in scope.
     type_parameter = scope_class.LookupTypeParameter(*type_name.ident);
     if (!type_parameter.IsNull()) {
       ErrorMsg(type_pos, "type parameter '%s' cannot be instantiated",
                String::Handle(type_parameter.Name()).ToCString());
     }
   }
+  Class& type_class = Class::ZoneHandle();
   type_class ^= LookupTypeClass(type_name, kMustResolve);
+  String& type_class_name = String::Handle();
   type_class_name = type_class.Name();
+  TypeArguments& type_arguments = TypeArguments::ZoneHandle();
   // Type arguments are not allowed after the optional constructor name.
   if (named_constructor == NULL) {
     type_arguments = ParseTypeArguments(kMustResolve);
-    type = Type::NewParameterizedType(type_class, type_arguments);
-    String& errmsg = String::Handle();
-    type = ClassFinalizer::FinalizeAndCanonicalizeType(type, &errmsg);
-    if (!errmsg.IsNull()) {
-      ErrorMsg(errmsg.ToCString());
-    }
-    // The type argument vector may have been expanded with the type arguments
-    // of the super type when finalizing the type.
-    type_arguments = type.arguments();
   }
   if ((named_constructor == NULL) && (CurrentToken() == Token::kPERIOD)) {
     ConsumeToken();
     named_constructor = ExpectIdentifier("name of constructor expected");
   }
 
   // Parse constructor parameters.
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
@@ skipping 67 matching lines @@
              String::Handle(type_class.Name()).ToCString(),
              external_constructor_name.ToCString());
   }
   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.
+  {
+    Class& signature_class = Class::Handle();
+    if (constructor.IsFactory()) {
+      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(type, &errmsg);
+    if (!errmsg.IsNull()) {
+      ErrorMsg(errmsg.ToCString());
+    }
+    // The type argument vector may have been expanded with the type arguments
+    // of the super type when finalizing the type.
+    type_arguments = type.arguments();
+  }
+
+  // Make the constructor call.
   AstNode* new_object = NULL;
   if (is_const) {
     if (!constructor.is_const()) {
       ErrorMsg("'const' requires const constructor: '%s'",
           String::Handle(constructor.name()).ToCString());
     }
     const Instance& const_instance = Instance::ZoneHandle(
         EvaluateConstConstructorCall(type_class,
                                      type_arguments,
                                      constructor,
                                      arguments));
     if (const_instance.IsUnhandledException()) {
       new_object = CreateEvalConstConstructorThrow(new_pos, const_instance);
     } else {
       new_object = new LiteralNode(new_pos, const_instance);
     }
   } else {
     CheckFunctionIsCallable(new_pos, constructor);
+    CheckConstructorCallTypeArguments(new_pos, constructor, type_arguments);
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
     }
-    CheckConstructorCallTypeArguments(new_pos, constructor, type_arguments);
     new_object = new ConstructorCallNode(
         new_pos, type_arguments, constructor, arguments);
   }
   return new_object;
 }
 
 
 // A string literal consists of the concatenation of the next n tokens
 // that satisfy the EBNF grammar:
 // literal = kSTRING {{ interpol }+ kSTRING }
@@ skipping 424 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart