Properly handle implicit closure function when a generic function.

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);
 
+  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());
+
+    if (func.IsGeneric()) {
+      // Insert function type arguments variable to scope.
+      LocalVariable* function_type_arguments = new (Z) LocalVariable(
+          TokenPosition::kNoSource, TokenPosition::kNoSource,
+          Symbols::FunctionTypeArgumentsVar(), Object::dynamic_type());
+      current_block_->scope->AddVariable(function_type_arguments);
+      ASSERT(FunctionLevel() == 0);
+      parsed_function_->set_function_type_arguments(function_type_arguments);
+    }
+  }
+
+  // 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());
@@ skipping 1883 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_reify_generic_functions && func.IsGeneric()) {
+  if (FLAG_reify_generic_functions) {
     // 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);
+      if (FunctionLevel() == 0) {
+        parsed_function_->set_parent_type_arguments(parent_type_arguments);
+        if (!func.IsGeneric() && parent_type_arguments->is_captured()) {
+          parsed_function_->set_function_type_arguments(parent_type_arguments);
+        }
+      }
     }
-    // Insert function type arguments variable to scope.
-    LocalVariable* function_type_arguments = new (Z) LocalVariable(
-        TokenPosition::kNoSource, TokenPosition::kNoSource,
-        Symbols::FunctionTypeArgumentsVar(), Object::dynamic_type());
-    current_block_->scope->AddVariable(function_type_arguments);
-    parsed_function_->set_function_type_arguments(function_type_arguments);
+    if (func.IsGeneric()) {
+      // Insert function type arguments variable to scope.
+      LocalVariable* function_type_arguments = new (Z) LocalVariable(
+          TokenPosition::kNoSource, TokenPosition::kNoSource,
+          Symbols::FunctionTypeArgumentsVar(), Object::dynamic_type());
+      current_block_->scope->AddVariable(function_type_arguments);
+      if (FunctionLevel() == 0) {
+        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 11679 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