[kernel] Streaming ScopeBuilder

runtime/vm/kernel_to_il.h

 // Copyright (c) 2016, 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_KERNEL_TO_IL_H_
 #define RUNTIME_VM_KERNEL_TO_IL_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/growable_array.h"
@@ skipping 178 matching lines @@
 
 Fragment operator+(const Fragment& first, const Fragment& second);
 Fragment operator<<(const Fragment& fragment, Instruction* next);
 
 typedef ZoneGrowableArray<PushArgumentInstr*>* ArgumentArray;
 
 
 class ActiveClass {
  public:
   ActiveClass()
-      : kernel_class(NULL), klass(NULL), member(NULL), kernel_function(NULL) {}
+      : kernel_class(NULL),
+        class_type_parameters(0),
+        class_type_parameters_offset_start(-1),
+        klass(NULL),
+        member(NULL),
+        member_is_procedure(false),
+        member_is_factory_procedure(false),
+        member_type_parameters(0),
+        member_type_parameters_offset_start(-1) {}
 
   // The current enclosing kernel class (if available, otherwise NULL).
   Class* kernel_class;
+  intptr_t class_type_parameters;
+  intptr_t class_type_parameters_offset_start;
 
   // The current enclosing class (or the library top-level class).  When this is
   // a library's top-level class, the kernel_class will be NULL.
   const dart::Class* klass;
 
   // The enclosing member (e.g., Constructor, Procedure, or Field) if there
   // is one.
   Member* member;
-
-  // The current function.
-  FunctionNode* kernel_function;
+  bool member_is_procedure;
+  bool member_is_factory_procedure;
+  intptr_t member_type_parameters;
+  intptr_t member_type_parameters_offset_start;
 };
 
 
 class ActiveClassScope {
  public:
   ActiveClassScope(ActiveClass* active_class,
+                   intptr_t class_type_parameters,
+                   intptr_t class_type_parameters_offset_start,
+                   const dart::Class* klass)
+      : active_class_(active_class), saved_(*active_class) {
+    active_class_->kernel_class = NULL;
+    active_class_->class_type_parameters = class_type_parameters;
+    active_class_->class_type_parameters_offset_start =
+        class_type_parameters_offset_start;
+    active_class_->klass = klass;
+    active_class_->member = NULL;
+  }
+
+
+  ActiveClassScope(ActiveClass* active_class,
                    Class* kernel_class,
                    const dart::Class* klass)
       : active_class_(active_class), saved_(*active_class) {
     active_class_->kernel_class = kernel_class;
     active_class_->klass = klass;
     active_class_->member = NULL;
-    active_class_->kernel_function = NULL;
+
+    if (kernel_class != NULL) {
+      List<TypeParameter>& type_parameters = kernel_class->type_parameters();
+      active_class_->class_type_parameters = type_parameters.length();
+      active_class_->class_type_parameters_offset_start =
+          active_class_->class_type_parameters > 0
+              ? type_parameters[0]->kernel_offset()
+              : -1;
+    }
   }
 
   ~ActiveClassScope() { *active_class_ = saved_; }
 
  private:
   ActiveClass* active_class_;
   ActiveClass saved_;
 };
 
 
 class ActiveMemberScope {
  public:
+  ActiveMemberScope(ActiveClass* active_class,
+                    bool member_is_procedure,
+                    bool member_is_factory_procedure,
+                    intptr_t member_type_parameters,
+                    intptr_t member_type_parameters_offset_start)
+      : active_class_(active_class), saved_(*active_class) {
+    // The class and kernel_class is inherited.
+    active_class_->member = NULL;
+    active_class_->member_is_procedure = member_is_procedure;
+    active_class_->member_is_factory_procedure = member_is_factory_procedure;
+    active_class_->member_type_parameters = member_type_parameters;
+    active_class_->member_type_parameters_offset_start =
+        member_type_parameters_offset_start;
+  }
+
   ActiveMemberScope(ActiveClass* active_class, Member* member)
       : active_class_(active_class), saved_(*active_class) {
     // The class and kernel_class is inherited.
     active_class_->member = member;
-    active_class_->kernel_function = NULL;
+
+    active_class_->member_is_procedure = false;
+    active_class_->member_is_factory_procedure = false;
+    active_class_->member_type_parameters = 0;
+    active_class_->member_type_parameters_offset_start = -1;
+
+    if (member == NULL || !member->IsProcedure()) {
+      return;
+    }
+
+    Procedure* procedure = Procedure::Cast(member);
+    active_class_->member_is_procedure = true;
+    active_class->member_is_factory_procedure =
+        procedure->kind() == Procedure::kFactory;
+    if (procedure->function() != NULL) {
+      TypeParameterList& type_parameters =
+          procedure->function()->type_parameters();
+      if (type_parameters.length() > 0) {
+        active_class_->member_type_parameters = type_parameters.length();
+        active_class_->member_type_parameters_offset_start =
+            type_parameters.first_offset;
+      }
+    }
   }
 
   ~ActiveMemberScope() { *active_class_ = saved_; }
 
  private:
   ActiveClass* active_class_;
-  ActiveClass saved_;
-};
-
-
-class ActiveFunctionScope {
- public:
-  ActiveFunctionScope(ActiveClass* active_class, FunctionNode* kernel_function)
-      : active_class_(active_class), saved_(*active_class) {
-    // The class, kernel_class, and member are inherited.
-    active_class_->kernel_function = kernel_function;
-  }
-
-  ~ActiveFunctionScope() { *active_class_ = saved_; }
-
- private:
-  ActiveClass* active_class_;
   ActiveClass saved_;
 };
 
 
 class TranslationHelper {
  public:
   explicit TranslationHelper(dart::Thread* thread);
   virtual ~TranslationHelper() {}
 
   Thread* thread() { return thread_; }
@@ skipping 380 matching lines @@
   // level.
   GrowableArray<LocalVariable*> exception_variables;
   GrowableArray<LocalVariable*> stack_trace_variables;
   GrowableArray<LocalVariable*> catch_context_variables;
 
   // For-in iterators, one per for-in nesting level.
   GrowableArray<LocalVariable*> iterator_variables;
 };
 
 
-class ScopeBuilder : public RecursiveVisitor {
- public:
-  ScopeBuilder(ParsedFunction* parsed_function, TreeNode* node);
-
-  virtual ~ScopeBuilder() {}
-
-  ScopeBuildingResult* BuildScopes();
-
-  virtual void VisitName(Name* node) { /* NOP */
-  }
-
-  virtual void VisitThisExpression(ThisExpression* node);
-  virtual void VisitTypeParameterType(TypeParameterType* node);
-  virtual void VisitVariableGet(VariableGet* node);
-  virtual void VisitVariableSet(VariableSet* node);
-  virtual void VisitConditionalExpression(ConditionalExpression* node);
-  virtual void VisitLogicalExpression(LogicalExpression* node);
-  virtual void VisitFunctionExpression(FunctionExpression* node);
-  virtual void VisitLet(Let* node);
-  virtual void VisitBlock(Block* node);
-  virtual void VisitVariableDeclaration(VariableDeclaration* node);
-  virtual void VisitFunctionDeclaration(FunctionDeclaration* node);
-  virtual void VisitWhileStatement(WhileStatement* node);
-  virtual void VisitDoStatement(DoStatement* node);
-  virtual void VisitForStatement(ForStatement* node);
-  virtual void VisitForInStatement(ForInStatement* node);
-  virtual void VisitSwitchStatement(SwitchStatement* node);
-  virtual void VisitReturnStatement(ReturnStatement* node);
-  virtual void VisitTryCatch(TryCatch* node);
-  virtual void VisitTryFinally(TryFinally* node);
-  virtual void VisitYieldStatement(YieldStatement* node);
-  virtual void VisitAssertStatement(AssertStatement* node);
-
-  virtual void VisitFunctionNode(FunctionNode* node);
-
-  virtual void VisitConstructor(Constructor* node);
-
- private:
-  void EnterScope(TreeNode* node, TokenPosition start_position);
-  void ExitScope(TokenPosition end_position);
-
-  const Type& TranslateVariableType(VariableDeclaration* variable);
-  LocalVariable* MakeVariable(TokenPosition declaration_pos,
-                              TokenPosition token_pos,
-                              const dart::String& name,
-                              const AbstractType& type);
-
-  void AddParameters(FunctionNode* function, intptr_t pos = 0);
-  void AddParameter(VariableDeclaration* declaration, intptr_t pos);
-  void AddVariable(VariableDeclaration* declaration);
-  void AddExceptionVariable(GrowableArray<LocalVariable*>* variables,
-                            const char* prefix,
-                            intptr_t nesting_depth);
-  void AddTryVariables();
-  void AddCatchVariables();
-  void AddIteratorVariable();
-  void AddSwitchVariable();
-
-  // Record an assignment or reference to a variable.  If the occurrence is
-  // in a nested function, ensure that the variable is handled properly as a
-  // captured variable.
-  void LookupVariable(VariableDeclaration* declaration);
-
-  const dart::String& GenerateName(const char* prefix, intptr_t suffix);
-
-  void HandleLocalFunction(TreeNode* parent, FunctionNode* function);
-  void HandleSpecialLoad(LocalVariable** variable, const dart::String& symbol);
-  void LookupCapturedVariableByName(LocalVariable** variable,
-                                    const dart::String& name);
-
-  struct DepthState {
-    explicit DepthState(intptr_t function)
-        : loop_(0),
-          function_(function),
-          try_(0),
-          catch_(0),
-          finally_(0),
-          for_in_(0) {}
-
-    intptr_t loop_;
-    intptr_t function_;
-    intptr_t try_;
-    intptr_t catch_;
-    intptr_t finally_;
-    intptr_t for_in_;
-  };
-
-  ScopeBuildingResult* result_;
-  ParsedFunction* parsed_function_;
-  TreeNode* node_;
-
-  ActiveClass active_class_;
-
-  TranslationHelper translation_helper_;
-  Zone* zone_;
-  DartTypeTranslator type_translator_;
-
-  FunctionNode* current_function_node_;
-  LocalScope* current_function_scope_;
-  LocalScope* scope_;
-  DepthState depth_;
-
-  intptr_t name_index_;
-
-  bool needs_expr_temp_;
-};
-
 struct YieldContinuation {
   Instruction* entry;
   intptr_t try_index;
 
   YieldContinuation(Instruction* entry, intptr_t try_index)
       : entry(entry), try_index(try_index) {}
 
   YieldContinuation()
       : entry(NULL), try_index(CatchClauseNode::kInvalidTryIndex) {}
 };
@@ skipping 578 matching lines @@
 namespace kernel {
 
 RawObject* EvaluateMetadata(const dart::Field& metadata_field);
 RawObject* BuildParameterDescriptor(const Function& function);
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_TO_IL_H_