Remove parent_level field of function type parameters.

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 1163 matching lines @@
       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.
-  }
+  // ParseFunc has recorded the generic function type arguments variable.
+  ASSERT(!FLAG_generic_method_semantics ||
+         !parser.current_function().IsGeneric() ||
+         (parsed_function->function_type_arguments() != NULL));
 }
 
 
 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 2260 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(
+    // Lookup function type arguments variable in parent function scope, if any.
+    if (func.HasGenericParent()) {
+      const String* variable_name = &Symbols::FunctionTypeArgumentsVar();
+      LocalVariable* parent_type_arguments =
+          current_block_->scope->LookupVariable(*variable_name, true);
+      ASSERT(parent_type_arguments != NULL);
+      // TODO(regis): It may be too early to capture parent_type_arguments here.
+      // In case it is never used, we could save capturing and concatenating.
+      current_block_->scope->CaptureVariable(parent_type_arguments);
+      parsed_function_->set_parent_type_arguments(parent_type_arguments);
+    }
+    // Insert function type arguments variable to scope.
+    LocalVariable* function_type_arguments = new (Z) LocalVariable(
         TokenPosition::kNoSource, TokenPosition::kNoSource,
-        Symbols::FunctionInstantiatorVar(), Object::dynamic_type());
-    current_block_->scope->AddVariable(function_instantiator);
+        Symbols::FunctionTypeArgumentsVar(), Object::dynamic_type());
+    current_block_->scope->AddVariable(function_type_arguments);
+    parsed_function_->set_function_type_arguments(function_type_arguments);
   }
 
   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());
@@ skipping 142 matching lines @@
     // 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.
+    // their function type arguments.
     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());
@@ skipping 1875 matching lines @@
         ConsumeToken();
         // TODO(regis): Handle 'super' differently than 'extends'.
         // A bound may refer to the owner of the type parameter it applies to,
         // i.e. to the class or function currently being parsed.
         // 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();
       }
+      // Note that we cannot yet calculate the final index of a function type
+      // parameter, because we may not have parsed the parent function yet.
       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();
-      }
+          index, type_parameter_name, type_parameter_bound, declaration_pos);
       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 2173 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::CaptureFunctionInstantiators() {
+void Parser::CaptureFunctionTypeArguments() {
   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();
-  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);
+  const String* variable_name = &Symbols::FunctionTypeArgumentsVar();
+  current_block_->scope->CaptureVariable(
+      current_block_->scope->LookupVariable(*variable_name, true));
 }
 
 
 void Parser::CaptureAllInstantiators() {
   if (IsInstantiatorRequired()) {
     CaptureInstantiator();
   }
-  if (AreFunctionInstantiatorsRequired()) {
-    CaptureFunctionInstantiators();
+  if (innermost_function().HasGenericParent()) {
+    CaptureFunctionTypeArguments();
   }
 }
 
 
 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) {
@@ skipping 236 matching lines @@
     if (!FLAG_generic_method_syntax) {
       ReportError("generic functions not supported");
     }
     if (!found_func) {
       ParseTypeParameters(false);  // Not parameterizing class, but function.
     } else {
       TryParseTypeParameters();
     }
   }
 
-  if (!found_func && !result_type.IsFinalized()) {
-    // Now that type parameters are declared, the result type can be resolved
-    // and finalized.
-    ResolveType(&result_type);
-    result_type = CanonicalizeType(result_type);
-    function.set_result_type(result_type);
-  }
-
   CheckToken(Token::kLPAREN);
 
   // The function type needs to be finalized at compile time, since the closure
   // may be type checked at run time when assigned to a function variable,
   // passed as a function argument, or returned as a function result.
 
   LocalVariable* function_variable = NULL;
   Type& function_type = Type::ZoneHandle(Z);
   if (!is_literal) {
     // Since the function type depends on the signature of the closure function,
@@ skipping 26 matching lines @@
     }
   }
 
   Type& signature_type = Type::ZoneHandle(Z);
   SequenceNode* statements = NULL;
   if (!found_func) {
     // Parse the local function. As a side effect of the parsing, the
     // variables of this function's scope that are referenced by the local
     // function (and its inner nested functions) will be marked as captured.
 
-    ASSERT(AbstractType::Handle(Z, function.result_type()).IsResolved());
+    ResolveType(&result_type);  // Parameter types are resolved in ParseFunc.
+    function.set_result_type(result_type);
     statements = Parser::ParseFunc(function, !is_literal);
     INC_STAT(thread(), num_functions_parsed, 1);
 
-    // Now that the local function has formal parameters, lookup the signature
+    // Now that the local function has formal parameters, finalize its signature
     signature_type = function.SignatureType();
     signature_type ^= CanonicalizeType(signature_type);
     function.SetSignatureType(signature_type);
   } else {
     // The local function was parsed before. The captured variables are
     // saved in the function's context scope. Iterate over the context scope
     // and mark its variables as captured.
     const ContextScope& context_scope =
         ContextScope::Handle(Z, function.context_scope());
     ASSERT(!context_scope.IsNull());
@@ skipping 3816 matching lines @@
       // Make sure that the class instantiator is captured.
       CaptureInstantiator();
     }
     type_parameter ^= CanonicalizeType(type_parameter);
   } else {
     ASSERT(type_parameter.IsFunctionTypeParameter());
     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();
+    if (FunctionLevel() > 0) {
+      // Make sure that the parent function type arguments are captured.
+      CaptureFunctionTypeArguments();
     }
   }
   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;
@@ skipping 483 matching lines @@
           // 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;
           }
           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(
@@ skipping 117 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() ||
         innermost_function().HasGenericParent()) {
       return true;
     }
   }
   return false;
 }
@@ skipping 1150 matching lines @@
     // Factory call at runtime.
     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.
+      // Make sure that the instantiators are captured.
       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));
@@ skipping 1435 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