Manage and capture class and function instantiators in the parser.

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 42 matching lines @@
 DEFINE_FLAG(bool,
             conditional_directives,
             true,
             "Enable conditional directives");
 DEFINE_FLAG(bool,
             generic_method_syntax,
             true,
             "Enable generic function syntax.");
 DEFINE_FLAG(bool,
             generic_method_semantics,
-            true,
+            false,
             "Enable generic function semantics (not yet supported).");
 DEFINE_FLAG(bool,
             initializing_formal_access,
             true,
             "Make initializing formal parameters visible in initializer list.");
 DEFINE_FLAG(bool,
             warn_super,
             false,
             "Warning if super initializer not last in initializer list.");
 DEFINE_FLAG(
@@ skipping 1082 matching lines @@
   if (parsed_function->has_expression_temp_var()) {
     node_sequence->scope()->AddVariable(parsed_function->expression_temp_var());
   }
   node_sequence->scope()->AddVariable(parsed_function->current_context_var());
   if (parsed_function->has_finally_return_temp_var()) {
     node_sequence->scope()->AddVariable(
         parsed_function->finally_return_temp_var());
   }
   parsed_function->SetNodeSequence(node_sequence);
 
-  // The instantiator may be required at run time for generic type checks or
+  // The instantiators may be required at run time for generic type checks or
   // allocation of generic types.
   if (parser.IsInstantiatorRequired()) {
     // In the case of a local function, only set the instantiator if the
     // receiver (or type arguments parameter of a factory) was captured.
     LocalVariable* instantiator = NULL;
     const bool kTestOnly = true;
     if (parser.current_function().IsInFactoryScope()) {
       instantiator = parser.LookupTypeArgumentsParameter(node_sequence->scope(),
                                                          kTestOnly);
     } else {
       instantiator = parser.LookupReceiver(node_sequence->scope(), kTestOnly);
     }
     if (!parser.current_function().IsLocalFunction() ||
         ((instantiator != NULL) && instantiator->is_captured())) {
       parsed_function->set_instantiator(instantiator);
     }
   }
+  if (FLAG_generic_method_semantics && parser.current_function().IsGeneric()) {
+    const String* variable_name = &Symbols::FunctionInstantiatorVar();
+    const bool kTestOnly = true;
+    LocalVariable* instantiator =
+        node_sequence->scope()->LookupVariable(*variable_name, kTestOnly);
+    ASSERT(instantiator != NULL);
+    parsed_function->set_function_instantiator(instantiator);
+    // Function instantiator variables of parent generic functions, if any, are
+    // captured and accessible via the context.
+  }
 }
 
 
 RawObject* Parser::ParseMetadata(const Field& meta_data) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* thread = Thread::Current();
     StackZone stack_zone(thread);
     Zone* zone = stack_zone.GetZone();
     const Class& owner_class = Class::Handle(zone, meta_data.Owner());
@@ skipping 2259 matching lines @@
 
   if (func.IsGenerativeConstructor()) {
     SequenceNode* statements = ParseConstructor(func);
     last_used_try_index_ = saved_try_index;
     return statements;
   }
 
   ASSERT(!func.IsGenerativeConstructor());
   OpenFunctionBlock(func);  // Build local scope for function.
 
+  if (FLAG_generic_method_semantics && func.IsGeneric()) {
+    // Insert function instantiator variable to scope.
+    LocalVariable* function_instantiator = new (Z) LocalVariable(
+        TokenPosition::kNoSource, TokenPosition::kNoSource,
+        Symbols::FunctionInstantiatorVar(), Object::dynamic_type());
+    current_block_->scope->AddVariable(function_instantiator);
+  }
+
   ParamList params;
   // An instance closure function may capture and access the receiver, but via
   // the context and not via the first formal parameter.
   if (func.IsClosureFunction()) {
     // The first parameter of a closure function is the closure object.
     ASSERT(!func.is_const());  // Closure functions cannot be const.
     params.AddFinalParameter(TokenPos(), &Symbols::ClosureParameter(),
                              &Object::dynamic_type());
   } else if (!func.is_static()) {
     // Static functions do not have a receiver.
@@ skipping 69 matching lines @@
     }
     ResolveSignature(func);
     if (!is_top_level_) {
       ClassFinalizer::FinalizeSignature(Class::Handle(Z, func.origin()), func);
     }
     SetupDefaultsForOptionalParams(params);
     ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
 
     // Populate function scope with the formal parameters.
     AddFormalParamsToScope(&params, current_block_->scope);
-
-    if (I->type_checks() && (FunctionLevel() > 0)) {
-      // We are parsing, but not compiling, a local function.
-      // The instantiator may be required at run time for generic type checks.
-      if (IsInstantiatorRequired()) {
-        // Make sure that the receiver of the enclosing instance function
-        // (or implicit first parameter of an enclosing factory) is marked as
-        // captured if type checks are enabled, because they may access it to
-        // instantiate types.
-        CaptureInstantiator();
-      }
-    }
   }
 
   const TokenPosition modifier_pos = TokenPos();
   RawFunction::AsyncModifier func_modifier = ParseFunctionModifier();
   if (!func.is_generated_body()) {
     // Don't add a modifier to the closure representing the body of
     // the asynchronous function or generator.
     func.set_modifier(func_modifier);
   }
 
@@ skipping 39 matching lines @@
     // The closure containing the body of an async* function is debuggable.
     ASSERT(func.is_debuggable());
     if (FLAG_causal_async_stacks) {
       // In order to collect causal asynchronous stacks efficiently we rely on
       // this function not being inlined.
       func.set_is_inlinable(false);
     }
     OpenAsyncGeneratorClosure();
   }
 
+  // Function level is now correctly set to parse the (possibly async) body.
+  if (I->type_checks() && (FunctionLevel() > 0)) {
+    // We are parsing, but not compiling, a local function.
+    // The instantiator may be required at run time for generic type checks.
+    // Note that the source of this local function may not reference the
+    // generic type explicitly. However, it may assign a value to a captured
+    // variable declared with its generic type in the enclosing function.
+    // Make sure that the receiver of the enclosing instance function
+    // (or implicit first parameter of an enclosing factory) is marked as
+    // captured if type checks are enabled, because they may access it to
+    // instantiate types.
+    // If any enclosing parent of the function being parsed is generic, capture
+    // their function instantiators.
+    CaptureAllInstantiators();
+  }
+
   BoolScope allow_await(&this->await_is_keyword_,
                         func.IsAsyncOrGenerator() || func.is_generated_body());
   TokenPosition end_token_pos = TokenPosition::kNoSource;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     if (String::Handle(Z, func.name()).Equals(Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(Z, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
@@ skipping 152 matching lines @@
     return LibraryPrefix::null();
   }
 
   // A library prefix with the name exists. Now check whether it is
   // shadowed by a local definition.
   if (!is_top_level_ &&
       ResolveIdentInLocalScope(TokenPos(), ident, NULL, NULL)) {
     return LibraryPrefix::null();
   }
   // Check whether the identifier is shadowed by a function type parameter.
-  // TODO(regis): Shortcut this lookup if no generic functions in scope.
-  if (!innermost_function().IsNull() &&
-      (innermost_function().LookupTypeParameter(ident, NULL) !=
-       TypeParameter::null())) {
+  if (InGenericFunctionScope() && (innermost_function().LookupTypeParameter(
+                                       ident, NULL) != TypeParameter::null())) {

[hausner, 2017/03/08 06:19:36]

Nit: weird formatting, but git cl format probably wants it this way.

[regis, 2017/03/08 16:18:49]

Yes, I had to run git cl format. I'll try to fix it before submitting. 

     return LibraryPrefix::null();
   }
   // Check whether the identifier is shadowed by a class type parameter.
   ASSERT(!current_class().IsNull());
   if (current_class().LookupTypeParameter(ident) != TypeParameter::null()) {
     return LibraryPrefix::null();
   }
 
   // We have a name that is not shadowed, followed by a period or #.
   // Consume the identifier, let the caller consume the . or #.
@@ skipping 1711 matching lines @@
         // Postpone resolution in order to avoid resolving the owner and its
         // type parameters, as they are not fully parsed yet.
         type_parameter_bound = ParseType(ClassFinalizer::kDoNotResolve);
       } else {
         type_parameter_bound = I->object_store()->object_type();
       }
       type_parameter = TypeParameter::New(
           parameterizing_class ? current_class() : Class::Handle(Z),
           parameterizing_class ? Function::Handle(Z) : innermost_function(),
           index, 0, type_parameter_name, type_parameter_bound, declaration_pos);
+      if (!parameterizing_class) {
+        type_parameter.SetIsFinalized();
+      }
       type_parameters_array.Add(
           &AbstractType::ZoneHandle(Z, type_parameter.raw()));
       if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
         library_.AddTypeParameterMetadata(type_parameter, metadata_pos);
       }
       index++;
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
@@ skipping 1475 matching lines @@
     // Finalize function type.
     Type& signature_type = Type::Handle(Z, closure.SignatureType());
     signature_type ^= CanonicalizeType(signature_type);
     closure.SetSignatureType(signature_type);
     ASSERT(AbstractType::Handle(Z, closure.result_type()).IsResolved());
     ASSERT(closure.NumParameters() == closure_params.parameters->length());
   }
   OpenFunctionBlock(closure);
   AddFormalParamsToScope(&closure_params, current_block_->scope);
   async_temp_scope_ = current_block_->scope;
-
-  // Capture instantiator in case it may be needed to generate the type
-  // check of the return value. (C.f. handling of Token::kRETURN.)
-  ASSERT(FunctionLevel() > 0);
-  if (I->type_checks() && IsInstantiatorRequired()) {
-    CaptureInstantiator();
-  }
   return closure.raw();
 }
 
 
 void Parser::AddContinuationVariables() {
   // Add to current block's scope:
   //   var :await_jump_var;
   //   var :await_ctx_var;
   LocalVariable* await_jump_var =
       new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
@@ skipping 668 matching lines @@
 void Parser::CaptureInstantiator() {
   ASSERT(FunctionLevel() > 0);
   const String* variable_name = current_function().IsInFactoryScope()
                                     ? &Symbols::TypeArgumentsParameter()
                                     : &Symbols::This();
   current_block_->scope->CaptureVariable(
       current_block_->scope->LookupVariable(*variable_name, true));
 }
 
 
-void Parser::CaptureFunctionInstantiator() {
+void Parser::CaptureFunctionInstantiators() {
+  ASSERT(InGenericFunctionScope());
   ASSERT(FunctionLevel() > 0);
+  if (!FLAG_generic_method_semantics) {
+    return;
+  }
+  // Capture function instantiators starting at parent of innermost function.
+  intptr_t variable_function_level = FunctionLevel() - 1;
   const String* variable_name = &Symbols::FunctionInstantiatorVar();
-  current_block_->scope->CaptureVariable(
-      current_block_->scope->LookupVariable(*variable_name, true));
+  LocalScope* scope = current_block_->scope;
+  do {
+    while (scope->function_level() > variable_function_level) {
+      scope = scope->parent();
+    }
+    // Function instantiator is in top scope at that function level.
+    LocalScope* parent_scope = scope->parent();
+    while ((parent_scope != NULL) &&
+           (parent_scope->function_level() == scope->function_level())) {
+      scope = parent_scope;
+      parent_scope = scope->parent();
+    }
+    LocalVariable* function_instantiator_var =
+        scope->LookupVariable(*variable_name, true);
+    if (function_instantiator_var != NULL) {
+      current_block_->scope->CaptureVariable(function_instantiator_var);
+    }
+    scope = scope->parent();
+    variable_function_level--;
+  } while (variable_function_level >= 0);
 }
 
 
+void Parser::CaptureAllInstantiators() {
+  if (IsInstantiatorRequired()) {
+    CaptureInstantiator();
+  }
+  if (AreFunctionInstantiatorsRequired()) {
+    CaptureFunctionInstantiators();
+  }
+}
+
+
 AstNode* Parser::LoadReceiver(TokenPosition token_pos) {
   // A nested function may access 'this', referring to the receiver of the
   // outermost enclosing function.
   const bool kTestOnly = false;
   LocalVariable* receiver = LookupReceiver(current_block_->scope, kTestOnly);
   if (receiver == NULL) {
     ReportError(token_pos, "illegal implicit access to receiver 'this'");
   }
   return new (Z) LoadLocalNode(TokenPos(), receiver);
 }
@@ skipping 320 matching lines @@
     SkipFunctionLiteral();
     signature_type = function.SignatureType();
   }
 
   // Local functions are registered in the enclosing class, but
   // ignored during class finalization. The enclosing class has
   // already been finalized.
   ASSERT(current_class().is_finalized());
   ASSERT(signature_type.IsFinalized());
 
-  // Make sure that the instantiator is captured.
-  if ((FunctionLevel() > 0) &&
-      Class::Handle(signature_type.type_class()).IsGeneric()) {
-    CaptureInstantiator();
+  // Make sure that the instantiators are captured.
+  if ((FunctionLevel() > 0) && !signature_type.IsInstantiated()) {
+    CaptureAllInstantiators();
   }
 
   // A local signature type itself cannot be malformed or malbounded, only its
   // signature function's result type or parameter types may be.
   ASSERT(!signature_type.IsMalformed());
   ASSERT(!signature_type.IsMalbounded());
 
   if (!is_literal) {
     // Patch the function type of the variable now that the signature is known.
     function_type.set_type_class(Class::Handle(Z, signature_type.type_class()));
@@ skipping 1852 matching lines @@
         catch_blocks.Last() = block;
       }
       // This catch clause will handle all exceptions. We can safely forget
       // all previous catch clause types.
       handler_types.SetLength(0);
       handler_types.Add(*exception_param.type);
     } else {
       // Has a type specification that is not malformed or malbounded.  Now
       // form an 'if type check' to guard the catch handler code.
       if (!exception_param.type->IsInstantiated() && (FunctionLevel() > 0)) {
-        // Make sure that the instantiator is captured.
-        CaptureInstantiator();
+        // Make sure that the instantiators are captured.
+        CaptureAllInstantiators();
       }
       TypeNode* exception_type =
           new (Z) TypeNode(catch_pos, *exception_param.type);
       AstNode* exception_value =
           new (Z) LoadLocalNode(catch_pos, exception_var);
       if (!exception_type->type().IsInstantiated()) {
         EnsureExpressionTemp();
       }
       type_tests.Add(new (Z) ComparisonNode(catch_pos, Token::kIS,
                                             exception_value, exception_type));
@@ skipping 1009 matching lines @@
       } else {
         // For 'is' and 'as' we expect the right operand to be a type.
         if ((op_kind == Token::kIS) && (CurrentToken() == Token::kNOT)) {
           ConsumeToken();
           op_kind = Token::kISNOT;
         }
         const TokenPosition type_pos = TokenPos();
         const AbstractType& type = AbstractType::ZoneHandle(
             Z, ParseTypeOrFunctionType(false, ClassFinalizer::kCanonicalize));
         if (!type.IsInstantiated() && (FunctionLevel() > 0)) {
-          // Make sure that the instantiator is captured.
-          CaptureInstantiator();
+          // Make sure that the instantiators are captured.
+          CaptureAllInstantiators();
         }
         right_operand = new (Z) TypeNode(type_pos, type);
         // In production mode, the type may be malformed.
         // In checked mode, the type may be malformed or malbounded.
         if (type.IsMalformedOrMalbounded()) {
           // Note that a type error is thrown in a type test or in
           // a type cast even if the tested value is null.
           // We need to evaluate the left operand for potential
           // side effects.
           LetNode* let = new (Z) LetNode(left_operand->token_pos());
@@ skipping 846 matching lines @@
   TypeParameter& type_parameter = TypeParameter::ZoneHandle(Z);
   type_parameter = TypeParameter::Cast(primary->primary()).raw();
   if (type_parameter.IsClassTypeParameter()) {
     if (ParsingStaticMember()) {
       const String& name = String::Handle(Z, type_parameter.name());
       ReportError(primary_pos,
                   "cannot access type parameter '%s' "
                   "from static function",
                   name.ToCString());
     }
-    // TODO(regis): Verify that CaptureInstantiator() was already called
-    // and remove call below.
     if (FunctionLevel() > 0) {
       // Make sure that the class instantiator is captured.
       CaptureInstantiator();
     }
     type_parameter ^= CanonicalizeType(type_parameter);
-    ASSERT(!type_parameter.IsMalformed());
-    return new (Z) TypeNode(primary_pos, type_parameter);
   } else {
     ASSERT(type_parameter.IsFunctionTypeParameter());
-    // TODO(regis): Verify that CaptureFunctionInstantiator() was already
-    // called if necessary.
-    // TODO(regis): Finalize type parameter and return as type node.
-    // For now, map to dynamic type.
-    Type& type = Type::ZoneHandle(Z, Type::DynamicType());
-    return new (Z) TypeNode(primary_pos, type);
+    if (!FLAG_generic_method_semantics) {
+      Type& type = Type::ZoneHandle(Z, Type::DynamicType());
+      return new (Z) TypeNode(primary_pos, type);
+    }
+    if (type_parameter.parent_level() > 0) {
+      // Make sure that the function instantiators are captured.
+      CaptureFunctionInstantiators();
+    }
   }
+  ASSERT(type_parameter.IsFinalized());
+  ASSERT(!type_parameter.IsMalformed());
+  return new (Z) TypeNode(primary_pos, type_parameter);
 }
 
 
 AstNode* Parser::ParseSelectors(AstNode* primary, bool is_cascade) {
   AstNode* left = primary;
   while (true) {
     AstNode* selector = NULL;
     if ((CurrentToken() == Token::kPERIOD) ||
         (CurrentToken() == Token::kQM_PERIOD)) {
       // Unconditional or conditional property extraction or method call.
@@ skipping 483 matching lines @@
     return;
   }
   // Resolve type class.
   if (!type->HasResolvedTypeClass()) {
     const UnresolvedClass& unresolved_class =
         UnresolvedClass::Handle(Z, type->unresolved_class());
     const String& unresolved_class_name =
         String::Handle(Z, unresolved_class.ident());
     if (unresolved_class.library_or_library_prefix() == Object::null()) {
       // First check if the type is a function type parameter.
-      if (!innermost_function().IsNull()) {
-        // TODO(regis): Shortcut this lookup if no generic functions in scope.
-        // A bit has_generic_parent() would be useful on Function.
-        // Unfortunately, all 32 kind bits are used in Function.
+      if (InGenericFunctionScope()) {
+        intptr_t type_param_func_level = FunctionLevel();
         TypeParameter& type_parameter = TypeParameter::ZoneHandle(
-            Z, innermost_function().LookupTypeParameter(unresolved_class_name,
-                                                        NULL));
+            Z, innermost_function().LookupTypeParameter(
+                   unresolved_class_name, &type_param_func_level));
         if (!type_parameter.IsNull()) {
           // A type parameter cannot be parameterized, so make the type
           // malformed if type arguments have previously been parsed.
           if (type->arguments() != TypeArguments::null()) {
             *type = ClassFinalizer::NewFinalizedMalformedType(
                 Error::Handle(Z),  // No previous error.
                 script_, type_parameter.token_pos(),
                 "type parameter '%s' cannot be parameterized",
                 String::Handle(Z, type_parameter.name()).ToCString());
             return;
           }
-          // TODO(regis): Mark function type parameter as finalized (its index
-          // does not need adjustment upon finalization) and return it.
-          // For now, resolve the function type parameter to dynamic.
-          *type = Type::DynamicType();
+          if (FLAG_generic_method_semantics) {
+            ASSERT(type_parameter.IsFinalized());
+            ASSERT(!type_parameter.IsMalformed());
+            *type = type_parameter.raw();
+          } else {
+            *type = Type::DynamicType();
+          }
           return;
         }
       }
       // Then check if the type is a class type parameter.
       const TypeParameter& type_parameter = TypeParameter::Handle(
           Z, current_class().LookupTypeParameter(unresolved_class_name));
       if (!type_parameter.IsNull()) {
         // A type parameter is considered to be a malformed type when
         // referenced by a static member.
         if (ParsingStaticMember()) {
@@ skipping 115 matching lines @@
 bool Parser::IsInstantiatorRequired() const {
   ASSERT(!current_function().IsNull());
   if (current_function().is_static() &&
       !current_function().IsInFactoryScope()) {
     return false;
   }
   return current_class().IsGeneric();
 }
 
 
+bool Parser::AreFunctionInstantiatorsRequired() const {
+  ASSERT(!innermost_function().IsNull());
+  Function& parent = Function::Handle(innermost_function().parent_function());
+  while (!parent.IsNull()) {
+    if (parent.IsGeneric()) {
+      return true;
+    }
+    parent = parent.parent_function();
+  }
+  return false;
+}
+
+
+bool Parser::InGenericFunctionScope() const {
+  if (!innermost_function().IsNull()) {
+    // With one more free tag bit in Function, we could cache this information.
+    if (innermost_function().IsGeneric()) {
+      return true;
+    }
+    Function& parent = Function::Handle(innermost_function().parent_function());
+    while (!parent.IsNull()) {
+      if (parent.IsGeneric()) {
+        return true;
+      }
+      parent = parent.parent_function();
+    }
+  }
+  return false;
+}
+
+
 void Parser::InsertCachedConstantValue(const Script& script,
                                        TokenPosition token_pos,
                                        const Instance& value) {
   ASSERT(Thread::Current()->IsMutatorThread());
   const intptr_t kInitialConstMapSize = 16;
   ASSERT(!script.InVMHeap());
   if (script.compile_time_constants() == Array::null()) {
     const Array& array = Array::Handle(
         HashTables::New<ConstantsMap>(kInitialConstMapSize, Heap::kNew));
     script.set_compile_time_constants(array);
@@ skipping 427 matching lines @@
 // throw NoSuchMethodError if we're compiling a static method.
 AstNode* Parser::ResolveIdent(TokenPosition ident_pos,
                               const String& ident,
                               bool allow_closure_names) {
   TRACE_PARSER("ResolveIdent");
   // First try to find the variable in the local scope (block scope or
   // class scope).
   AstNode* resolved = NULL;
   intptr_t resolved_func_level = 0;
   ResolveIdentInLocalScope(ident_pos, ident, &resolved, &resolved_func_level);
-  if (!innermost_function().IsNull()) {
-    // TODO(regis): Shortcut this lookup if no generic functions in scope.
+  if (InGenericFunctionScope()) {
     intptr_t type_param_func_level = FunctionLevel();
     const TypeParameter& type_parameter =
         TypeParameter::ZoneHandle(Z, innermost_function().LookupTypeParameter(
                                          ident, &type_param_func_level));
     if (!type_parameter.IsNull()) {
       if ((resolved == NULL) || (resolved_func_level < type_param_func_level)) {
         // The identifier is a function type parameter, possibly shadowing
         // 'resolved'.
-        if ((FunctionLevel() > 0) &&
-            (type_param_func_level < FunctionLevel())) {
-          // Make sure that the function instantiator is captured.
-          CaptureFunctionInstantiator();
+        if (!FLAG_generic_method_semantics) {
+          Type& type = Type::ZoneHandle(Z, Type::DynamicType());
+          return new (Z) TypeNode(ident_pos, type);
         }
-        // TODO(regis): Mark function type parameter as finalized (its index
-        // does not need adjustment upon finalization) and return as type node.
-        // For now, resolve the function type parameter to dynamic.
-        Type& type = Type::ZoneHandle(Z, Type::DynamicType());
-        return new (Z) TypeNode(ident_pos, type);
+        ASSERT(type_parameter.IsFinalized());
+        ASSERT(!type_parameter.IsMalformed());
+        return new (Z) TypeNode(ident_pos, type_parameter);
       }
     }
   }
   if (resolved == NULL) {
     // Check whether the identifier is a class type parameter.
     if (!current_class().IsNull()) {
       TypeParameter& type_parameter = TypeParameter::ZoneHandle(
           Z, current_class().LookupTypeParameter(ident));
       if (!type_parameter.IsNull()) {
-        if (FunctionLevel() > 0) {
-          // Make sure that the class instantiator is captured.
-          CaptureInstantiator();
-        }
         type_parameter ^= CanonicalizeType(type_parameter);
         ASSERT(!type_parameter.IsMalformed());
         return new (Z) TypeNode(ident_pos, type_parameter);
       }
     }
     // Not found in the local scope, and the name is not a type parameter.
     // Try finding the variable in the library scope (current library
     // and all libraries imported by it without a library prefix).
     resolved = ResolveIdentInCurrentLibraryScope(ident_pos, ident);
   }
@@ skipping 414 matching lines @@
     // Factory call at runtime.
     const Class& factory_class =
         Class::Handle(Z, Library::LookupCoreClass(Symbols::List()));
     ASSERT(!factory_class.IsNull());
     const Function& factory_method = Function::ZoneHandle(
         Z, factory_class.LookupFactory(
                Library::PrivateCoreLibName(Symbols::ListLiteralFactory())));
     ASSERT(!factory_method.IsNull());
     if (!list_type_arguments.IsNull() &&
         !list_type_arguments.IsInstantiated() && (FunctionLevel() > 0)) {
-      // Make sure that the instantiator is captured.
-      CaptureInstantiator();
+      // Make sure that the instantiators are captured.
+      CaptureAllInstantiators();
     }
     TypeArguments& factory_type_args =
         TypeArguments::ZoneHandle(Z, list_type_arguments.raw());
     // If the factory class extends other parameterized classes, adjust the
     // type argument vector.
     if (!factory_type_args.IsNull() && (factory_class.NumTypeArguments() > 1)) {
       ASSERT(factory_type_args.Length() == 1);
       Type& factory_type = Type::Handle(
           Z, Type::New(factory_class, factory_type_args, type_pos, Heap::kOld));
       // It is not strictly necessary to canonicalize factory_type, but only its
@@ skipping 229 matching lines @@
     const Class& factory_class =
         Class::Handle(Z, Library::LookupCoreClass(Symbols::Map()));
     ASSERT(!factory_class.IsNull());
     const Function& factory_method = Function::ZoneHandle(
         Z, factory_class.LookupFactory(
                Library::PrivateCoreLibName(Symbols::MapLiteralFactory())));
     ASSERT(!factory_method.IsNull());
     if (!map_type_arguments.IsNull() && !map_type_arguments.IsInstantiated() &&
         (FunctionLevel() > 0)) {
       // Make sure that the instantiator is captured.
-      CaptureInstantiator();
+      CaptureAllInstantiators();
     }
     TypeArguments& factory_type_args =
         TypeArguments::ZoneHandle(Z, map_type_arguments.raw());
     // If the factory class extends other parameterized classes, adjust the
     // type argument vector.
     if (!factory_type_args.IsNull() && (factory_class.NumTypeArguments() > 2)) {
       ASSERT(factory_type_args.Length() == 2);
       Type& factory_type = Type::Handle(
           Z, Type::New(factory_class, factory_type_args, type_pos, Heap::kOld));
       // It is not strictly necessary to canonicalize factory_type, but only its
@@ skipping 464 matching lines @@
     const Function& tearoff_func = Function::ZoneHandle(
         Z, BuildConstructorClosureFunction(constructor, new_pos));
 
     // Local functions normally get parsed when the enclosing function is
     // compiled. Since constructor tearoff closures don't get parsed here,
     // we need to duplicate some of the side effects of parsing, namely
     // creating a function scope, and capturing the instantiator of the
     // enclosing function if necessary.
     OpenFunctionBlock(tearoff_func);
     // If there are type arguments in the tearoff expression that are
-    // not yet instantiated, capture the instantiator.
-    if (IsInstantiatorRequired() && !type_arguments.IsNull() &&
-        !type_arguments.IsInstantiated()) {
-      CaptureInstantiator();
+    // not yet instantiated, capture the instantiators.
+    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);
   String& error_message = String::Handle(Z);
   if (!constructor.AreValidArguments(arguments_length, arguments->names(),
@@ skipping 63 matching lines @@
             "const factory result is not an instance of '%s'",
             String::Handle(Z, type_bound.UserVisibleName()).ToCString());
         new_object = ThrowTypeError(new_pos, type_bound);
       }
       type_bound = AbstractType::null();
     }
   } else {
     CheckConstructorCallTypeArguments(new_pos, constructor, type_arguments);
     if (!type_arguments.IsNull() && !type_arguments.IsInstantiated() &&
         (FunctionLevel() > 0)) {
-      // Make sure that the instantiator is captured.
-      CaptureInstantiator();
+      // Make sure that the instantiators are captured.
+      CaptureAllInstantiators();
     }
     // If the type argument vector is not instantiated, we verify in checked
     // mode at runtime that it is within its declared bounds.
     new_object = CreateConstructorCallNode(new_pos, type_arguments, constructor,
                                            arguments);
   }
   if (!type_bound.IsNull()) {
     new_object = new (Z) AssignableNode(new_pos, new_object, type_bound,
                                         Symbols::FactoryResult());
   }
@@ skipping 163 matching lines @@
         ExpectToken(Token::kPERIOD);
       }
     }
     String& ident = *CurrentLiteral();
     ConsumeToken();
     if (prefix.IsNull()) {
       intptr_t primary_func_level = 0;
       ResolveIdentInLocalScope(qual_ident_pos, ident, &primary,
                                &primary_func_level);
       // Check whether the identifier is shadowed by a function type parameter.
-      if (!innermost_function().IsNull()) {
-        // TODO(regis): Shortcut this lookup if no generic functions in scope.
+      if (InGenericFunctionScope()) {
         intptr_t type_param_func_level = FunctionLevel();
         TypeParameter& type_param = TypeParameter::ZoneHandle(
             Z, innermost_function().LookupTypeParameter(
                    ident, &type_param_func_level));
         if (!type_param.IsNull()) {
           if ((primary == NULL) ||
               (primary_func_level < type_param_func_level)) {
             // The identifier is a function type parameter, possibly shadowing
             // already resolved 'primary'.
-            if ((FunctionLevel() > 0) &&
-                (type_param_func_level < FunctionLevel())) {
-              // Make sure that the function instantiator is captured.
-              CaptureFunctionInstantiator();
-            }
             return new (Z) PrimaryNode(qual_ident_pos, type_param);
           }
         }
       }
       if (primary == NULL) {
         // Check whether the identifier is a type parameter.
         if (!current_class().IsNull()) {
           TypeParameter& type_param = TypeParameter::ZoneHandle(
               Z, current_class().LookupTypeParameter(ident));
           if (!type_param.IsNull()) {
@@ skipping 664 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