Require legacy form of type parameters in factories and report errors if a factory class does not...

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 6371 matching lines @@
     String& errmsg = String::Handle();
     type = ClassFinalizer::FinalizeAndCanonicalizeType(type, &errmsg);
     if (!errmsg.IsNull()) {
       ErrorMsg(errmsg.ToCString());
     }
   }
   return type.raw();
 }
 
 
+void Parser::CheckConstructorCallTypeArguments(
+    intptr_t pos, Function& constructor, const TypeArguments& type_arguments) {
+  if (!type_arguments.IsNull() &&
+      (type_arguments.Length() !=
+          Class::Handle(constructor.owner()).NumTypeArguments())) {
+    ErrorMsg(pos, "Incorrect number of type arguments, expected %d got %d",
+        Class::Handle(constructor.owner()).NumTypeArguments(),
+        type_arguments.Length());
+  }
+}
+
+
 // 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,
                                    bool is_const,
                                    const TypeArguments& type_arguments) {
   ASSERT(CurrentToken() == Token::kLBRACK || CurrentToken() == Token::kINDEX);
   intptr_t literal_pos = token_index_;
   bool is_empty_literal = CurrentToken() == Token::kINDEX;
@@ skipping 60 matching lines @@
         String::NewSymbol(kGrowableObjectArrayName));
     const Class& growable_array_class = Class::Handle(
         LookupImplClass(growable_object_array_class_name));
     String& ctor_name =
         String::Handle(String::NewSymbol(kGrowableObjectArrayFromArrayName));
     Function& array_ctor = Function::ZoneHandle(
         growable_array_class.LookupConstructor(ctor_name));
     ASSERT(!array_ctor.IsNull());
     ArgumentListNode* ctor_args = new ArgumentListNode(literal_pos);
     ctor_args->Add(array);
+    CheckConstructorCallTypeArguments(literal_pos, array_ctor, type_arguments);
     return new ConstructorCallNode(
         literal_pos, type_arguments, array_ctor, ctor_args);
   }
 }
 
 
 static void AddKeyValuePair(ArrayNode* pairs,
                             bool is_const,
                             AstNode* key,
                             AstNode* value) {
@@ skipping 344 matching lines @@
       new_object = new LiteralNode(new_pos, const_instance);
     }
   } else {
     CheckFunctionIsCallable(new_pos, constructor);
     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