Manage and capture class and function instantiators in the parser.

runtime/vm/parser.h

 // 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.
 
 #ifndef RUNTIME_VM_PARSER_H_
 #define RUNTIME_VM_PARSER_H_
 
 #include "include/dart_api.h"
 
 #include "platform/assert.h"
@@ skipping 78 matching lines @@
 // The class ParsedFunction holds the result of parsing a function.
 class ParsedFunction : public ZoneAllocated {
  public:
   ParsedFunction(Thread* thread, const Function& function)
       : thread_(thread),
         function_(function),
         code_(Code::Handle(zone(), function.unoptimized_code())),
         node_sequence_(NULL),
         regexp_compile_data_(NULL),
         instantiator_(NULL),
+        function_instantiator_(NULL),
         current_context_var_(NULL),
         expression_temp_var_(NULL),
         finally_return_temp_var_(NULL),
         deferred_prefixes_(new ZoneGrowableArray<const LibraryPrefix*>()),
         guarded_fields_(new ZoneGrowableArray<const Field*>()),
         default_parameter_values_(NULL),
         first_parameter_index_(0),
         first_stack_local_index_(0),
         num_copied_params_(0),
         num_stack_locals_(0),
@@ skipping 14 matching lines @@
   SequenceNode* node_sequence() const { return node_sequence_; }
   void SetNodeSequence(SequenceNode* node_sequence);
 
   RegExpCompileData* regexp_compile_data() const {
     return regexp_compile_data_;
   }
   void SetRegExpCompileData(RegExpCompileData* regexp_compile_data);
 
   LocalVariable* instantiator() const { return instantiator_; }
   void set_instantiator(LocalVariable* instantiator) {
-    // May be NULL.
+    ASSERT(instantiator != NULL);
     instantiator_ = instantiator;
   }
+  LocalVariable* function_instantiator() const {
+    return function_instantiator_;
+  }
+  void set_function_instantiator(LocalVariable* function_instantiator) {
+    ASSERT(function_instantiator != NULL);
+    function_instantiator_ = function_instantiator;
+  }
 
   void set_default_parameter_values(ZoneGrowableArray<const Instance*>* list) {
     default_parameter_values_ = list;
 #if defined(DEBUG)
     if (list == NULL) return;
     for (intptr_t i = 0; i < list->length(); i++) {
       ASSERT(list->At(i)->IsZoneHandle() || list->At(i)->InVMHeap());
     }
 #endif
   }
@@ skipping 71 matching lines @@
 
   kernel::ScopeBuildingResult* EnsureKernelScopes();
 
  private:
   Thread* thread_;
   const Function& function_;
   Code& code_;
   SequenceNode* node_sequence_;
   RegExpCompileData* regexp_compile_data_;
   LocalVariable* instantiator_;
+  LocalVariable* function_instantiator_;
   LocalVariable* current_context_var_;
   LocalVariable* expression_temp_var_;
   LocalVariable* finally_return_temp_var_;
   ZoneGrowableArray<const LibraryPrefix*>* deferred_prefixes_;
   ZoneGrowableArray<const Field*>* guarded_fields_;
   ZoneGrowableArray<const Instance*>* default_parameter_values_;
 
   int first_parameter_index_;
   int first_stack_local_index_;
   int num_copied_params_;
@@ skipping 426 matching lines @@
 
   void AddAsyncClosureParameters(ParamList* params);
   void AddContinuationVariables();
   void AddAsyncClosureVariables();
   void AddAsyncGeneratorVariables();
 
   LocalVariable* LookupReceiver(LocalScope* from_scope, bool test_only);
   LocalVariable* LookupTypeArgumentsParameter(LocalScope* from_scope,
                                               bool test_only);
   void CaptureInstantiator();
-  void CaptureFunctionInstantiator();
+  void CaptureFunctionInstantiators();
+  void CaptureAllInstantiators();
   AstNode* LoadReceiver(TokenPosition token_pos);
   AstNode* LoadFieldIfUnresolved(AstNode* node);
   AstNode* LoadClosure(PrimaryNode* primary);
   AstNode* LoadTypeParameter(PrimaryNode* primary);
   InstanceGetterNode* CallGetter(TokenPosition token_pos,
                                  AstNode* object,
                                  const String& name);
 
   AstNode* ParseAssertStatement(bool is_const = false);
   AstNode* ParseJump(String* label_name);
@@ skipping 143 matching lines @@
   AstNode* GenerateStaticFieldAccess(const Class& cls,
                                      const String& field_name,
                                      TokenPosition ident_pos);
 
   LocalVariable* LookupLocalScope(const String& ident);
   void CheckInstanceFieldAccess(TokenPosition field_pos,
                                 const String& field_name);
   bool ParsingStaticMember() const;
   const AbstractType* ReceiverType(const Class& cls);
   bool IsInstantiatorRequired() const;
+  bool AreFunctionInstantiatorsRequired() const;
+  bool InGenericFunctionScope() const;
   bool ResolveIdentInLocalScope(TokenPosition ident_pos,
                                 const String& ident,
                                 AstNode** node,
                                 intptr_t* function_level);
   static const bool kResolveLocally = true;
   static const bool kResolveIncludingImports = false;
 
   // Resolve a primary identifier in the library or prefix scope and
   // generate the corresponding AstNode.
   AstNode* ResolveIdentInCurrentLibraryScope(TokenPosition ident_pos,
@@ skipping 137 matching lines @@
 
   intptr_t recursion_counter_;
   friend class RecursionChecker;
 
   DISALLOW_COPY_AND_ASSIGN(Parser);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_PARSER_H_