Check for a passed-in type argument vector in the prolog of generic functions.

runtime/vm/scopes.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/scopes.h"
 
 #include "vm/object.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 
@@ skipping 176 matching lines @@
     } else {
       ASSERT(context_level() == (*context_owner)->context_level());
     }
   }
   variable->set_index((*context_owner)->num_context_variables_++);
 }
 
 
 int LocalScope::AllocateVariables(int first_parameter_index,
                                   int num_parameters,
+                                  int type_args_slot,
                                   int first_frame_index,
                                   LocalScope* context_owner,
                                   bool* found_captured_variables) {
   // We should not allocate variables of nested functions while compiling an
   // enclosing function.
   ASSERT(function_level() == 0);
   ASSERT(num_parameters >= 0);
   // Parameters must be listed first and must all appear in the top scope.
   ASSERT(num_parameters <= num_variables());
   int pos = 0;                              // Current variable position.
@@ skipping 20 matching lines @@
   // No overlapping of parameters and locals.
   ASSERT(frame_index >= first_frame_index);
   frame_index = first_frame_index;
   while (pos < num_variables()) {
     LocalVariable* variable = VariableAt(pos);
     pos++;
     if (variable->owner() == this) {
       if (variable->is_captured()) {
         AllocateContextVariable(variable, &context_owner);
         *found_captured_variables = true;
+        if ((pos == num_parameters) && (type_args_slot == 1)) {
+          ASSERT(variable->name().Equals(Symbols::FunctionTypeArgumentsVar()));
+          // A captured type args variable has a slot allocated in the frame and
+          // one in the context, where it gets copied to.
+          frame_index--;
+        }
       } else {
         variable->set_index(frame_index--);
       }
     }
   }
   // Allocate variables of all children.
   int min_frame_index = frame_index;  // Frame index decreases with allocations.
   LocalScope* child = this->child();
   while (child != NULL) {
-    int const dummy_parameter_index = 0;    // Ignored, since no parameters.
-    int const num_parameters_in_child = 0;  // No parameters in children scopes.
+    const int dummy_parameter_index = 0;    // Ignored, since no parameters.
+    const int num_parameters_in_child = 0;  // No parameters in children scopes.
+    const int no_type_args_slot = 0;  // No type args slot in children scopes.
     int child_frame_index = child->AllocateVariables(
-        dummy_parameter_index, num_parameters_in_child, frame_index,
-        context_owner, found_captured_variables);
+        dummy_parameter_index, num_parameters_in_child, no_type_args_slot,
+        frame_index, context_owner, found_captured_variables);
     if (child_frame_index < min_frame_index) {
       min_frame_index = child_frame_index;
     }
     child = child->sibling();
   }
   return min_frame_index;
 }
 
 
 // The parser creates internal variables that start with ":"
@@ skipping 465 matching lines @@
     return fixed_parameter_count - (index() - kParamEndSlotFromFp);
   } else {
     // Shift negative indexes so that the lowest one is 0 (they are still
     // non-positive).
     return fixed_parameter_count - (index() - kFirstLocalSlotFromFp);
   }
 }
 
 
 }  // namespace dart