Pass type argument vector to generic functions (if --reify-generic-functions is

runtime/vm/parser.cc

 // Copyright (c) 2012, 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/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 1539 matching lines @@
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::ParseImplicitClosure(const Function& func) {
   TRACE_PARSER("ParseImplicitClosure");
   TokenPosition token_pos = func.token_pos();
 
   OpenFunctionBlock(func);
 
+  const Function& parent = Function::Handle(func.parent_function());
+  intptr_t type_args_len = 0;  // Length of type args vector passed to parent.
+  LocalVariable* type_args_var = NULL;
   if (FLAG_reify_generic_functions) {
     // The parent function of an implicit closure is the original function, i.e.
     // non-closurized. It is not an enclosing function in the usual sense of a
     // parent function. Do not set parent_type_arguments() in parsed_function_.
-    ASSERT(func.IsGeneric() == func.HasGenericParent());
+    ASSERT(func.IsGeneric() == parent.IsGeneric());
 
     if (func.IsGeneric()) {
+      type_args_len = func.NumTypeParameters();
       // Insert function type arguments variable to scope.
-      LocalVariable* function_type_arguments = new (Z) LocalVariable(
+      type_args_var = new (Z) LocalVariable(
           TokenPosition::kNoSource, TokenPosition::kNoSource,
           Symbols::FunctionTypeArgumentsVar(), Object::dynamic_type());
-      current_block_->scope->AddVariable(function_type_arguments);
+      current_block_->scope->AddVariable(type_args_var);
       ASSERT(FunctionLevel() == 0);
-      parsed_function_->set_function_type_arguments(function_type_arguments);
+      parsed_function_->set_function_type_arguments(type_args_var);
     }
   }
 
-  // TODO(regis): Pass the function type arguments if func is generic.
   ParamList params;
   params.AddFinalParameter(token_pos, &Symbols::ClosureParameter(),
                            &Object::dynamic_type());
 
-  const Function& parent = Function::Handle(func.parent_function());
   if (parent.IsImplicitSetterFunction()) {
     const TokenPosition ident_pos = func.token_pos();
     ASSERT(IsIdentifier());
     params.AddFinalParameter(ident_pos, &Symbols::Value(),
                              &Object::dynamic_type());
     ASSERT(func.num_fixed_parameters() == 2);  // closure, value.
   } else if (!parent.IsGetterFunction() && !parent.IsImplicitGetterFunction()) {
     // NOTE: For the `kernel -> flowgraph` we don't use the parser.
     if (parent.kernel_function() == NULL) {
       SkipFunctionPreamble();
       const bool use_function_type_syntax = false;
       const bool allow_explicit_default_values = true;
       const bool evaluate_metadata = false;
       ParseFormalParameterList(use_function_type_syntax,
                                allow_explicit_default_values, evaluate_metadata,
                                &params);
       FinalizeFormalParameterTypes(&params);
       SetupDefaultsForOptionalParams(params);
     }
   }
 
   // Populate function scope with the formal parameters.
   LocalScope* scope = current_block_->scope;
   AddFormalParamsToScope(&params, scope);
 
-  ArgumentListNode* func_args = new ArgumentListNode(token_pos);
+  ArgumentListNode* func_args =
+      new ArgumentListNode(token_pos, type_args_var, type_args_len);
   if (!func.is_static()) {
     func_args->Add(LoadReceiver(token_pos));
   }
   // Skip implicit parameter at 0.
   for (intptr_t i = 1; i < func.NumParameters(); ++i) {
     func_args->Add(new LoadLocalNode(token_pos, scope->VariableAt(i)));
   }
 
   if (func.HasOptionalNamedParameters()) {
     // TODO(srdjan): Must allocate array in old space, since it
@@ skipping 28 matching lines @@
     call = new StaticCallNode(token_pos, target, func_args);
   } else if (!parent.is_static()) {
     ASSERT(Isolate::Current()->HasAttemptedReload());
     // If a subsequent reload reintroduces the target in the middle of the
     // Invocation object being constructed, we won't be able to successfully
     // deopt because the generated AST will change.
     func.SetIsOptimizable(false);
 
     ArgumentListNode* arguments = BuildNoSuchMethodArguments(
         token_pos, func_name, *func_args, NULL, false);
+    const intptr_t kTypeArgsLen = 0;
     const intptr_t kNumArguments = 2;  // Receiver, InvocationMirror.
-    ArgumentsDescriptor args_desc(
-        Array::Handle(Z, ArgumentsDescriptor::New(kNumArguments)));
+    ArgumentsDescriptor args_desc(Array::Handle(
+        Z, ArgumentsDescriptor::New(kTypeArgsLen, kNumArguments)));
     Function& no_such_method =
         Function::ZoneHandle(Z, Resolver::ResolveDynamicForReceiverClass(
                                     owner, Symbols::NoSuchMethod(), args_desc));
     if (no_such_method.IsNull()) {
       // If noSuchMethod(i) is not found, call Object:noSuchMethod.
       no_such_method ^= Resolver::ResolveDynamicForReceiverClass(
           Class::Handle(Z, I->object_store()->object_class()),
           Symbols::NoSuchMethod(), args_desc);
     }
     call = new StaticCallNode(token_pos, no_such_method, arguments);
@@ skipping 120 matching lines @@
         Array::ZoneHandle(Z, Array::New(desc.NamedCount(), Heap::kOld));
     for (intptr_t i = 0; i < arg_names.Length(); ++i) {
       arg_names.SetAt(i, String::Handle(Z, desc.NameAt(i)));
     }
     func_args->set_names(arg_names);
   }
 
   const String& func_name = String::ZoneHandle(Z, func.name());
   ArgumentListNode* arguments =
       BuildNoSuchMethodArguments(token_pos, func_name, *func_args, NULL, false);
+  const intptr_t kTypeArgsLen = 0;
   const intptr_t kNumArguments = 2;  // Receiver, InvocationMirror.
   ArgumentsDescriptor args_desc(
-      Array::Handle(Z, ArgumentsDescriptor::New(kNumArguments)));
+      Array::Handle(Z, ArgumentsDescriptor::New(kTypeArgsLen, kNumArguments)));
   Function& no_such_method = Function::ZoneHandle(
       Z,
       Resolver::ResolveDynamicForReceiverClass(
           Class::Handle(Z, func.Owner()), Symbols::NoSuchMethod(), args_desc));
   if (no_such_method.IsNull()) {
     // If noSuchMethod(i) is not found, call Object:noSuchMethod.
     no_such_method ^= Resolver::ResolveDynamicForReceiverClass(
         Class::Handle(Z, I->object_store()->object_class()),
         Symbols::NoSuchMethod(), args_desc);
   }
@@ skipping 558 matching lines @@
                                       bool resolve_getter,
                                       bool* is_no_such_method) {
   const Class& super_class = Class::Handle(Z, current_class().SuperClass());
   if (super_class.IsNull()) {
     ReportError(token_pos, "class '%s' does not have a superclass",
                 String::Handle(Z, current_class().Name()).ToCString());
   }
   Function& super_func = Function::Handle(
       Z, Resolver::ResolveDynamicAnyArgs(Z, super_class, name));
   if (!super_func.IsNull() &&
-      !super_func.AreValidArguments(arguments->length(), arguments->names(),
+      !super_func.AreValidArguments(arguments->type_args_len(),
+                                    arguments->length(), arguments->names(),
                                     NULL)) {
     super_func = Function::null();
   } else if (super_func.IsNull() && resolve_getter) {
     const String& getter_name =
         String::ZoneHandle(Z, Field::LookupGetterSymbol(name));
     if (!getter_name.IsNull()) {
       super_func = Resolver::ResolveDynamicAnyArgs(Z, super_class, getter_name);
       ASSERT(super_func.IsNull() ||
              (super_func.kind() != RawFunction::kImplicitStaticFinalGetter));
     }
@@ skipping 17 matching lines @@
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   const TokenPosition args_pos = function_args.token_pos();
   // Build arguments to the call to the static
   // InvocationMirror._allocateInvocationMirror method.
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
   // The first argument is the original function name.
   arguments->Add(new LiteralNode(args_pos, function_name));
   // The second argument is the arguments descriptor of the original function.
   const Array& args_descriptor = Array::ZoneHandle(
-      ArgumentsDescriptor::New(function_args.length(), function_args.names()));
+      ArgumentsDescriptor::New(function_args.type_args_len(),
+                               function_args.length(), function_args.names()));
   arguments->Add(new LiteralNode(args_pos, args_descriptor));
   // The third argument is an array containing the original function arguments,
-  // including the receiver.
+  // including the function type arguments and the receiver.
   ArrayNode* args_array =
       new ArrayNode(args_pos, Type::ZoneHandle(Type::ArrayType()));
+  // The type_args_var is only used in the generated body of an implicit closure
+  // where noSuchMethod should never be called.
+  ASSERT(function_args.type_args_var() == NULL);
+  if (!function_args.type_arguments().IsNull()) {
+    // TODO(regis): Pass the original type arguments to the invocation mirror.
+  }
   for (intptr_t i = 0; i < function_args.length(); i++) {
     AstNode* arg = function_args.NodeAt(i);
     if ((temp_for_last_arg != NULL) && (i == function_args.length() - 1)) {
       LetNode* store_arg = new LetNode(arg->token_pos());
       store_arg->AddNode(
           new StoreLocalNode(arg->token_pos(), temp_for_last_arg, arg));
       store_arg->AddNode(
           new LoadLocalNode(arg->token_pos(), temp_for_last_arg));
       args_array->AddElement(store_arg);
     } else {
@@ skipping 25 matching lines @@
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
   arguments->Add(function_args.NodeAt(0));
   // The second argument is the invocation mirror.
   arguments->Add(
       BuildInvocationMirrorAllocation(call_pos, function_name, function_args,
                                       temp_for_last_arg, is_super_invocation));
   return arguments;
 }
 
 
-AstNode* Parser::ParseSuperCall(const String& function_name) {
+AstNode* Parser::ParseSuperCall(const String& function_name,
+                                const TypeArguments& func_type_args) {
   TRACE_PARSER("ParseSuperCall");
   ASSERT(CurrentToken() == Token::kLPAREN);
   const TokenPosition supercall_pos = TokenPos();
 
-  // 'this' parameter is the first argument to super call.
-  ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
+  // 'this' parameter is the first argument to super call (after the type args).
+  ArgumentListNode* arguments =
+      new ArgumentListNode(supercall_pos, func_type_args);
   AstNode* receiver = LoadReceiver(supercall_pos);
   arguments->Add(receiver);
-  ParseActualParameters(arguments, kAllowConst);
+  ParseActualParameters(arguments, Object::null_type_arguments(), kAllowConst);
 
   const bool kResolveGetter = true;
   bool is_no_such_method = false;
   const Function& super_function = Function::ZoneHandle(
       Z, GetSuperFunction(supercall_pos, function_name, arguments,
                           kResolveGetter, &is_no_such_method));
   if (super_function.IsGetterFunction() ||
       super_function.IsImplicitGetterFunction()) {
     const Class& super_class =
         Class::ZoneHandle(Z, current_class().SuperClass());
     AstNode* closure = new StaticGetterNode(
         supercall_pos, LoadReceiver(supercall_pos), super_class, function_name);
     // 'this' is not passed as parameter to the closure.
-    ArgumentListNode* closure_arguments = new ArgumentListNode(supercall_pos);
+    ArgumentListNode* closure_arguments =
+        new ArgumentListNode(supercall_pos, func_type_args);
     for (int i = 1; i < arguments->length(); i++) {
       closure_arguments->Add(arguments->NodeAt(i));
     }
     return BuildClosureCall(supercall_pos, closure, closure_arguments);
   }
   if (is_no_such_method) {
     arguments = BuildNoSuchMethodArguments(supercall_pos, function_name,
                                            *arguments, NULL, true);
   }
   return new StaticCallNode(supercall_pos, super_function, arguments);
@@ skipping 194 matching lines @@
     }
     ReportError(supercall_pos,
                 "unresolved implicit call to super constructor '%s()'",
                 String::Handle(Z, super_class.Name()).ToCString());
   }
   if (current_function().is_const() && !super_ctor.is_const()) {
     ReportError(supercall_pos, "implicit call to non-const super constructor");
   }
 
   String& error_message = String::Handle(Z);
-  if (!super_ctor.AreValidArguments(arguments->length(), arguments->names(),
+  if (!super_ctor.AreValidArguments(arguments->type_args_len(),
+                                    arguments->length(), arguments->names(),
                                     &error_message)) {
     ReportError(supercall_pos,
                 "invalid arguments passed to super constructor '%s()': %s",
                 String::Handle(Z, super_class.Name()).ToCString(),
                 error_message.ToCString());
   }
   return new StaticCallNode(supercall_pos, super_ctor, arguments);
 }
 
 
@@ skipping 14 matching lines @@
   }
   CheckToken(Token::kLPAREN, "parameter list expected");
 
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // 'this' parameter is the first argument to super class constructor.
   AstNode* implicit_argument = new LoadLocalNode(supercall_pos, receiver);
   arguments->Add(implicit_argument);
 
   // 'this' parameter must not be accessible to the other super call arguments.
   receiver->set_invisible(true);
-  ParseActualParameters(arguments, kAllowConst);
+  ParseActualParameters(arguments, Object::null_type_arguments(), kAllowConst);
   receiver->set_invisible(false);
 
   // Resolve the constructor.
   const Function& super_ctor =
       Function::ZoneHandle(Z, super_class.LookupConstructor(ctor_name));
   if (super_ctor.IsNull()) {
     if (super_class.LookupFactory(ctor_name) != Function::null()) {
       ReportError(supercall_pos,
                   "super class constructor '%s' "
                   "must not be a factory constructor",
                   ctor_name.ToCString());
     }
     ReportError(supercall_pos, "super class constructor '%s' not found",
                 ctor_name.ToCString());
   }
   if (current_function().is_const() && !super_ctor.is_const()) {
     ReportError(supercall_pos, "super constructor must be const");
   }
   String& error_message = String::Handle(Z);
-  if (!super_ctor.AreValidArguments(arguments->length(), arguments->names(),
+  if (!super_ctor.AreValidArguments(arguments->type_args_len(),
+                                    arguments->length(), arguments->names(),
                                     &error_message)) {
     ReportError(supercall_pos,
                 "invalid arguments passed to super class constructor '%s': %s",
                 ctor_name.ToCString(), error_message.ToCString());
   }
   return new StaticCallNode(supercall_pos, super_ctor, arguments);
 }
 
 
 AstNode* Parser::ParseInitializer(const Class& cls,
@@ skipping 351 matching lines @@
   }
   ctor_name = Symbols::FromConcatAll(T, pieces);
   CheckToken(Token::kLPAREN, "parameter list expected");
 
   ArgumentListNode* arguments = new ArgumentListNode(call_pos);
   // 'this' parameter is the first argument to constructor.
   AstNode* implicit_argument = new LoadLocalNode(call_pos, receiver);
   arguments->Add(implicit_argument);
 
   receiver->set_invisible(true);
-  ParseActualParameters(arguments, kAllowConst);
+  ParseActualParameters(arguments, Object::null_type_arguments(), kAllowConst);
   receiver->set_invisible(false);
   // Resolve the constructor.
   const Function& redirect_ctor =
       Function::ZoneHandle(Z, cls.LookupConstructor(ctor_name));
   if (redirect_ctor.IsNull()) {
     if (cls.LookupFactory(ctor_name) != Function::null()) {
       ReportError(call_pos,
                   "redirection constructor '%s' must not be a factory",
                   String::Handle(Z, String::ScrubName(ctor_name)).ToCString());
     }
     ReportError(call_pos, "constructor '%s' not found",
                 String::Handle(Z, String::ScrubName(ctor_name)).ToCString());
   }
   if (current_function().is_const() && !redirect_ctor.is_const()) {
     ReportError(call_pos, "redirection constructor '%s' must be const",
                 String::Handle(Z, redirect_ctor.UserVisibleName()).ToCString());
   }
   String& error_message = String::Handle(Z);
-  if (!redirect_ctor.AreValidArguments(arguments->length(), arguments->names(),
+  if (!redirect_ctor.AreValidArguments(arguments->type_args_len(),
+                                       arguments->length(), arguments->names(),
                                        &error_message)) {
     ReportError(call_pos, "invalid arguments passed to constructor '%s': %s",
                 String::Handle(Z, redirect_ctor.UserVisibleName()).ToCString(),
                 error_message.ToCString());
   }
   current_block_->statements->Add(
       new StaticCallNode(call_pos, redirect_ctor, arguments));
 }
 
 
@@ skipping 6446 matching lines @@
   return CloseBlock();
 }
 
 
 // Calling VM-internal helpers, uses implementation core library.
 AstNode* Parser::MakeStaticCall(const String& cls_name,
                                 const String& func_name,
                                 ArgumentListNode* arguments) {
   const Class& cls = Class::Handle(Z, Library::LookupCoreClass(cls_name));
   ASSERT(!cls.IsNull());
+  const intptr_t kTypeArgsLen = 0;  // Not passing type args to generic func.
   const Function& func = Function::ZoneHandle(
-      Z, Resolver::ResolveStatic(cls, func_name, arguments->length(),
-                                 arguments->names()));
+      Z, Resolver::ResolveStatic(cls, func_name, kTypeArgsLen,
+                                 arguments->length(), arguments->names()));
   ASSERT(!func.IsNull());
   return new (Z) StaticCallNode(arguments->token_pos(), func, arguments);
 }
 
 
 AstNode* Parser::ParseAssertStatement(bool is_const) {
   TRACE_PARSER("ParseAssertStatement");
   ConsumeToken();  // Consume assert keyword.
   ExpectToken(Token::kLPAREN);
   const TokenPosition condition_pos = TokenPos();
@@ skipping 1985 matching lines @@
     expr = let_expr;
   } else {
     expr = ParsePostfixExpr();
   }
   return expr;
 }
 
 
 ArgumentListNode* Parser::ParseActualParameters(
     ArgumentListNode* implicit_arguments,
+    const TypeArguments& func_type_args,
     bool require_const) {
   TRACE_PARSER("ParseActualParameters");
   ASSERT(CurrentToken() == Token::kLPAREN);
   const bool saved_mode = SetAllowFunctionLiterals(true);
   ArgumentListNode* arguments;
   if (implicit_arguments == NULL) {
-    arguments = new (Z) ArgumentListNode(TokenPos());
+    // TODO(regis): When require_const is true, do we need to check that
+    // func_type_args are null or instantiated?
+    arguments = new (Z) ArgumentListNode(TokenPos(), func_type_args);
   } else {
+    // If implicit arguments are provided, they include type arguments (if any).
+    ASSERT(func_type_args.IsNull());
     arguments = implicit_arguments;
   }
   const GrowableObjectArray& names =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New(Heap::kOld));
   bool named_argument_seen = false;
   if (LookaheadToken(1) != Token::kRPAREN) {
     String& arg_name = String::Handle(Z);
     do {
       ASSERT((CurrentToken() == Token::kLPAREN) ||
              (CurrentToken() == Token::kCOMMA));
@@ skipping 30 matching lines @@
   if (named_argument_seen) {
     arguments->set_names(Array::Handle(Z, Array::MakeArray(names)));
   }
   return arguments;
 }
 
 
 AstNode* Parser::ParseStaticCall(const Class& cls,
                                  const String& func_name,
                                  TokenPosition ident_pos,
+                                 const TypeArguments& func_type_args,
                                  const LibraryPrefix* prefix) {
   TRACE_PARSER("ParseStaticCall");
   const TokenPosition call_pos = TokenPos();
   ASSERT(CurrentToken() == Token::kLPAREN);
-  ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
+  ArgumentListNode* arguments =
+      ParseActualParameters(NULL, func_type_args, kAllowConst);
   const int num_arguments = arguments->length();
   const Function& func = Function::ZoneHandle(
-      Z, Resolver::ResolveStatic(cls, func_name, num_arguments,
-                                 arguments->names()));
+      Z, Resolver::ResolveStatic(cls, func_name, func_type_args.Length(),
+                                 num_arguments, arguments->names()));
   if (func.IsNull()) {
     // Check if there is a static field of the same name, it could be a closure
     // and so we try and invoke the closure.
     AstNode* closure = NULL;
     const Field& field = Field::ZoneHandle(Z, cls.LookupStaticField(func_name));
     Function& func = Function::ZoneHandle(Z);
     if (field.IsNull()) {
       // No field, check if we have an explicit getter function.
       const String& getter_name =
           String::ZoneHandle(Z, Field::LookupGetterSymbol(func_name));
       if (!getter_name.IsNull()) {
+        const int kTypeArgsLen = 0;   // no type arguments.
         const int kNumArguments = 0;  // no arguments.
-        func = Resolver::ResolveStatic(cls, getter_name, kNumArguments,
-                                       Object::empty_array());
+        func = Resolver::ResolveStatic(cls, getter_name, kTypeArgsLen,
+                                       kNumArguments, Object::empty_array());
         if (!func.IsNull()) {
           ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
           closure = new (Z) StaticGetterNode(
               call_pos, NULL, Class::ZoneHandle(Z, cls.raw()), func_name);
           return BuildClosureCall(call_pos, closure, arguments);
         }
       }
     } else {
       closure = GenerateStaticFieldLookup(field, call_pos);
       return BuildClosureCall(call_pos, closure, arguments);
     }
     // Could not resolve static method: throw a NoSuchMethodError.
     return ThrowNoSuchMethodError(ident_pos, cls, func_name, arguments,
                                   InvocationMirror::kStatic,
                                   InvocationMirror::kMethod,
                                   NULL,  // No existing function.
                                   prefix);
   } else if (cls.IsTopLevel() && (cls.library() == Library::CoreLibrary()) &&
-             (func.name() == Symbols::Identical().raw())) {
+             (func.name() == Symbols::Identical().raw()) &&
+             func_type_args.IsNull()) {
     // This is the predefined toplevel function identical(a,b).
     // Create a comparison node instead of a static call to the function.
     ASSERT(num_arguments == 2);
 
     // If both arguments are constant expressions of type string,
     // evaluate and canonicalize them.
     // This guarantees that identical("ab", "a"+"b") is true.
     // An alternative way to guarantee this would be to introduce
     // an AST node that canonicalizes a value.
     AstNode* arg0 = arguments->NodeAt(0);
@@ skipping 13 matching lines @@
     return new (Z) ComparisonNode(ident_pos, Token::kEQ_STRICT,
                                   arguments->NodeAt(0), arguments->NodeAt(1));
   }
   return new (Z) StaticCallNode(ident_pos, func, arguments);
 }
 
 
 AstNode* Parser::ParseInstanceCall(AstNode* receiver,
                                    const String& func_name,
                                    TokenPosition ident_pos,
+                                   const TypeArguments& func_type_args,
                                    bool is_conditional) {
   TRACE_PARSER("ParseInstanceCall");
   CheckToken(Token::kLPAREN);
-  ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
+  ArgumentListNode* arguments =
+      ParseActualParameters(NULL, func_type_args, kAllowConst);
   return new (Z) InstanceCallNode(ident_pos, receiver, func_name, arguments,
                                   is_conditional);
 }
 
 
-AstNode* Parser::ParseClosureCall(AstNode* closure) {
+AstNode* Parser::ParseClosureCall(AstNode* closure,
+                                  const TypeArguments& func_type_args) {
   TRACE_PARSER("ParseClosureCall");
   const TokenPosition call_pos = TokenPos();
   ASSERT(CurrentToken() == Token::kLPAREN);
-  ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
+  ArgumentListNode* arguments =
+      ParseActualParameters(NULL, func_type_args, kAllowConst);
   return BuildClosureCall(call_pos, closure, arguments);
 }
 
 
 AstNode* Parser::GenerateStaticFieldLookup(const Field& field,
                                            TokenPosition ident_pos) {
   // If the static field has an initializer, initialize the field at compile
   // time, which is only possible if the field is const.
   AstNode* initializing_getter = RunStaticFieldInitializer(field, ident_pos);
   if (initializing_getter != NULL) {
@@ skipping 179 matching lines @@
           // super calls handled in ParseSuperCall().
           ASSERT(!primary_node->IsSuper());
           left = LoadFieldIfUnresolved(left);
         }
       }
       const TokenPosition ident_pos = TokenPos();
       String* ident = ExpectIdentifier("identifier expected");
       if (IsArgumentPart()) {
         // Identifier followed by optional type arguments and opening paren:
         // method call.
+        TypeArguments& func_type_args = TypeArguments::ZoneHandle(Z);
         if (CurrentToken() == Token::kLT) {
           // Type arguments.
           if (!FLAG_generic_method_syntax) {
             ReportError("generic type arguments not supported.");
           }
-          // TODO(regis): Pass type arguments in generic call.
-          // For now, resolve type arguments and ignore.
-          ParseTypeArguments(ClassFinalizer::kCanonicalize);
+          func_type_args = ParseTypeArguments(ClassFinalizer::kCanonicalize);
+          if (!FLAG_reify_generic_functions) {
+            func_type_args = TypeArguments::null();
+          }
         }
         PrimaryNode* primary_node = left->AsPrimaryNode();
         if ((primary_node != NULL) && primary_node->primary().IsClass()) {
           // Static method call prefixed with class name.
           const Class& cls = Class::Cast(primary_node->primary());
-          selector =
-              ParseStaticCall(cls, *ident, ident_pos, primary_node->prefix());
+          selector = ParseStaticCall(cls, *ident, ident_pos, func_type_args,
+                                     primary_node->prefix());
         } else {
           if ((primary_node != NULL) && primary_node->is_deferred_reference()) {
             const Class& cls = Class::Handle(library_.toplevel_class());
-            selector =
-                ParseStaticCall(cls, *ident, ident_pos, primary_node->prefix());
+            selector = ParseStaticCall(cls, *ident, ident_pos, func_type_args,
+                                       primary_node->prefix());
           } else {
-            selector =
-                ParseInstanceCall(left, *ident, ident_pos, is_conditional);
+            selector = ParseInstanceCall(left, *ident, ident_pos,
+                                         func_type_args, is_conditional);
           }
         }
       } else {
         // Field access.
         Class& cls = Class::Handle(Z);
         bool is_deferred = false;
         if (left->IsPrimaryNode()) {
           PrimaryNode* primary_node = left->AsPrimaryNode();
           is_deferred = primary_node->is_deferred_reference();
           if (primary_node->primary().IsClass()) {
@@ skipping 48 matching lines @@
                                    primary_node->is_deferred_reference());
         } else if (primary_node->primary().IsTypeParameter()) {
           array = LoadTypeParameter(primary_node);
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       }
       selector = new (Z)
           LoadIndexedNode(bracket_pos, array, index, Class::ZoneHandle(Z));
     } else if (IsArgumentPart()) {
+      TypeArguments& func_type_args = TypeArguments::ZoneHandle(Z);
       if (CurrentToken() == Token::kLT) {
         // Type arguments.
         if (!FLAG_generic_method_syntax) {
           ReportError("generic type arguments not supported.");
         }
-        // TODO(regis): Pass type arguments in generic call.
-        // For now, resolve type arguments and ignore.
-        ParseTypeArguments(ClassFinalizer::kCanonicalize);
+        func_type_args = ParseTypeArguments(ClassFinalizer::kCanonicalize);
+        if (!FLAG_reify_generic_functions) {
+          func_type_args = TypeArguments::null();
+        }
       }
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
         const TokenPosition primary_pos = primary_node->token_pos();
         if (primary_node->primary().IsFunction()) {
           const Function& func = Function::Cast(primary_node->primary());
           const String& func_name = String::ZoneHandle(Z, func.name());
           if (func.is_static()) {
             // Parse static function call.
             Class& cls = Class::Handle(Z, func.Owner());
-            selector = ParseStaticCall(cls, func_name, primary_pos);
+            selector =
+                ParseStaticCall(cls, func_name, primary_pos, func_type_args);
           } else {
             // Dynamic function call on implicit "this" parameter.
             if (current_function().is_static()) {
               ReportError(primary_pos,
                           "cannot access instance method '%s' "
                           "from static function",
                           func_name.ToCString());
             }
-            selector =
-                ParseInstanceCall(LoadReceiver(primary_pos), func_name,
-                                  primary_pos, false /* is_conditional */);
+            selector = ParseInstanceCall(LoadReceiver(primary_pos), func_name,
+                                         primary_pos, func_type_args,
+                                         false /* is_conditional */);
           }
         } else if (primary_node->primary().IsString()) {
           // Primary is an unresolved name.
           if (primary_node->IsSuper()) {
             ReportError(primary_pos, "illegal use of super");
           }
           const String& name =
               String::Cast(Object::ZoneHandle(primary_node->primary().raw()));
           if (primary_node->is_deferred_reference()) {
             // The static call will be converted to throwing a NSM error.
             const Class& cls = Class::Handle(library_.toplevel_class());
-            selector =
-                ParseStaticCall(cls, name, primary_pos, primary_node->prefix());
+            selector = ParseStaticCall(cls, name, primary_pos, func_type_args,
+                                       primary_node->prefix());
           } else if (current_function().is_static()) {
             // The static call will be converted to throwing a NSM error.
-            selector = ParseStaticCall(current_class(), name, primary_pos);
+            selector = ParseStaticCall(current_class(), name, primary_pos,
+                                       func_type_args);
           } else {
             // Treat as call to unresolved (instance) method.
             selector =
                 ParseInstanceCall(LoadReceiver(primary_pos), name, primary_pos,
-                                  false /* is_conditional */);
+                                  func_type_args, false /* is_conditional */);
           }
         } else if (primary_node->primary().IsTypeParameter()) {
+          // TODO(regis): What about the parsed type arguments?
           selector = LoadTypeParameter(primary_node);
         } else if (primary_node->primary().IsClass()) {
+          // TODO(regis): What about the parsed type arguments?
           const Class& type_class = Class::Cast(primary_node->primary());
           AbstractType& type = Type::ZoneHandle(
               Z, Type::New(type_class, Object::null_type_arguments(),
                            primary_pos, Heap::kOld));
           type ^= CanonicalizeType(type);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
           selector = new (Z) TypeNode(primary_pos, type,
                                       primary_node->is_deferred_reference());
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       } else {
         // Left is not a primary node; this must be a closure call.
         AstNode* closure = left;
-        selector = ParseClosureCall(closure);
+        selector = ParseClosureCall(closure, func_type_args);
       }
     } else {
       // No (more) selectors to parse.
       left = LoadFieldIfUnresolved(left);
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
         const TokenPosition primary_pos = primary->token_pos();
         if (primary_node->primary().IsFunction()) {
           // Treat as implicit closure.
           left = LoadClosure(primary_node);
@@ skipping 529 matching lines @@
           StaticGetterNode(field_ref_pos, NULL, field_owner, field_name);
     }
   } else if (value.raw() == Object::sentinel().raw()) {
     // This field has not been referenced yet and thus the value has
     // not been evaluated. If the field is const, call the static getter method
     // to evaluate the expression and canonicalize the value.
     if (field.is_const()) {
       NoReloadScope no_reload_scope(isolate(), thread());
       NoOOBMessageScope no_msg_scope(thread());
       field.SetStaticValue(Object::transition_sentinel());
-      const int kNumArguments = 0;  // no arguments.
+      const int kTypeArgsLen = 0;   // No type argument vector.
+      const int kNumArguments = 0;  // No arguments.
       const Function& func = Function::Handle(
-          Z, Resolver::ResolveStatic(field_owner, getter_name, kNumArguments,
-                                     Object::empty_array()));
+          Z, Resolver::ResolveStatic(field_owner, getter_name, kTypeArgsLen,
+                                     kNumArguments, Object::empty_array()));
       ASSERT(!func.IsNull());
       ASSERT(func.kind() == RawFunction::kImplicitStaticFinalGetter);
       Object& const_value = Object::Handle(Z);
       const_value = DartEntry::InvokeFunction(func, Object::empty_array());
       if (const_value.IsError()) {
         const Error& error = Error::Cast(const_value);
         if (error.IsUnhandledException()) {
           // An exception may not occur in every parse attempt, i.e., the
           // generated AST is not deterministic. Therefore mark the function as
           // not optimizable.
@@ skipping 30 matching lines @@
 }
 
 
 RawObject* Parser::EvaluateConstConstructorCall(
     const Class& type_class,
     const TypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
   NoReloadScope no_reload_scope(isolate(), thread());
   NoOOBMessageScope no_msg_scope(thread());
+  // Factories and constructors are not generic functions.
+  const int kTypeArgsLen = 0;
   // Factories have one extra argument: the type arguments.
-  // Constructors have 1 extra arguments: receiver.
+  // Constructors have one extra arguments: receiver.
   const int kNumExtraArgs = 1;
   const int num_arguments = arguments->length() + kNumExtraArgs;
   const Array& arg_values =
       Array::Handle(Z, Array::New(num_arguments, Heap::kOld));
   Instance& instance = Instance::Handle(Z);
   if (!constructor.IsFactory()) {
     instance = Instance::New(type_class, Heap::kOld);
     if (!type_arguments.IsNull()) {
       if (!type_arguments.IsInstantiated()) {
         ReportError("type must be constant in const constructor");
       }
       instance.SetTypeArguments(
           TypeArguments::Handle(Z, type_arguments.Canonicalize()));
     }
     arg_values.SetAt(0, instance);
   } else {
     // Prepend type_arguments to list of arguments to factory.
     ASSERT(type_arguments.IsZoneHandle());
     arg_values.SetAt(0, type_arguments);
   }
   for (int i = 0; i < arguments->length(); i++) {
     AstNode* arg = arguments->NodeAt(i);
     // Arguments have been evaluated to a literal value already.
     ASSERT(arg->IsLiteralNode());
     arg_values.SetAt((i + kNumExtraArgs), arg->AsLiteralNode()->literal());
   }
-  const Array& args_descriptor = Array::Handle(
-      Z, ArgumentsDescriptor::New(num_arguments, arguments->names()));
+  const Array& args_descriptor =
+      Array::Handle(Z, ArgumentsDescriptor::New(kTypeArgsLen, num_arguments,
+                                                arguments->names()));
   const Object& result = Object::Handle(
       Z, DartEntry::InvokeFunction(constructor, arg_values, args_descriptor));
   if (result.IsError()) {
     // An exception may not occur in every parse attempt, i.e., the
     // generated AST is not deterministic. Therefore mark the function as
     // not optimizable.
     current_function().SetIsOptimizable(false);
     if (result.IsUnhandledException()) {
       return result.raw();
     } else {
@@ skipping 1283 matching lines @@
     ConsumeToken();
     named_constructor = ExpectIdentifier("name of constructor expected");
   }
 
   // Parse constructor parameters.
   TokenPosition call_pos = TokenPos();
   ArgumentListNode* arguments = NULL;
   if (!is_tearoff_expression) {
     CheckToken(Token::kLPAREN);
     call_pos = TokenPos();
-    arguments = ParseActualParameters(NULL, is_const);
+    arguments =
+        ParseActualParameters(NULL, TypeArguments::ZoneHandle(Z), is_const);
   } else {
     // Allocate dummy node with no arguments so we don't have to deal
     // with the NULL corner case below.
     arguments = new (Z) ArgumentListNode(TokenPos());
   }
 
   // Parsing is complete, so we can return a throw in case of a malformed or
   // malbounded type or report a compile-time error if the constructor is const.
   if (type.IsMalformedOrMalbounded()) {
     if (is_const) {
@@ skipping 158 matching lines @@
     if (!type_arguments.IsNull() && !type_arguments.IsInstantiated()) {
       CaptureAllInstantiators();
     }
     SequenceNode* tearoff_body = CloseBlock();
     ClosureNode* closure_obj =
         new (Z) ClosureNode(new_pos, tearoff_func, NULL, tearoff_body->scope());
     return closure_obj;
   }
 
   ASSERT(!is_tearoff_expression);
+  const int kTypeArgsLen = 0;
   String& error_message = String::Handle(Z);
-  if (!constructor.AreValidArguments(arguments_length, arguments->names(),
-                                     &error_message)) {
+  if (!constructor.AreValidArguments(kTypeArgsLen, arguments_length,
+                                     arguments->names(), &error_message)) {
     const String& external_constructor_name =
         (named_constructor ? constructor_name : type_class_name);
     if (is_const) {
       ReportError(call_pos,
                   "invalid arguments passed to constructor '%s' "
                   "for class '%s': %s",
                   external_constructor_name.ToCString(),
                   String::Handle(Z, type_class.Name()).ToCString(),
                   error_message.ToCString());
     }
@@ skipping 385 matching lines @@
     if (current_class().SuperClass() == Class::null()) {
       ReportError("class '%s' does not have a superclass",
                   String::Handle(Z, current_class().Name()).ToCString());
     }
     const TokenPosition super_pos = TokenPos();
     ConsumeToken();
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       const TokenPosition ident_pos = TokenPos();
       const String& ident = *ExpectIdentifier("identifier expected");
-      if (CurrentToken() == Token::kLPAREN) {
-        primary = ParseSuperCall(ident);
+      if (IsArgumentPart()) {
+        TypeArguments& func_type_args = TypeArguments::ZoneHandle(Z);
+        if (CurrentToken() == Token::kLT) {
+          // Type arguments.
+          if (!FLAG_generic_method_syntax) {
+            ReportError("generic type arguments not supported.");
+          }
+          func_type_args = ParseTypeArguments(ClassFinalizer::kCanonicalize);
+          if (!FLAG_reify_generic_functions) {
+            func_type_args = TypeArguments::null();
+          }
+        }
+        primary = ParseSuperCall(ident, func_type_args);
       } else {
         primary = ParseSuperFieldAccess(ident, ident_pos);
       }
     } else if ((CurrentToken() == Token::kLBRACK) ||
                Token::CanBeOverloaded(CurrentToken()) ||
                (CurrentToken() == Token::kNE)) {
       primary = ParseSuperOperator();
     } else if (CurrentToken() == Token::kQM_PERIOD) {
       ReportError("super call or super getter may not use ?.");
     } else {
@@ skipping 525 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME