Small cleanups in the Kernel FlowGraphBuilder

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 170 matching lines @@
   ~ActiveFunctionScope() { *active_class_ = saved_; }
 
  private:
   ActiveClass* active_class_;
   ActiveClass saved_;
 };
 
 
 class TranslationHelper {
  public:
-  TranslationHelper(dart::Thread* thread, dart::Zone* zone, Isolate* isolate)
+  explicit TranslationHelper(dart::Thread* thread)
       : thread_(thread),
-        zone_(zone),
-        isolate_(isolate),
-        allocation_space_(thread_->IsMutatorThread() ? Heap::kNew
-                                                     : Heap::kOld) {}
+        zone_(thread->zone()),
+        isolate_(thread->isolate()),
+        allocation_space_(thread->IsMutatorThread() ? Heap::kNew : Heap::kOld) {
+  }
   virtual ~TranslationHelper() {}
 
   Thread* thread() { return thread_; }
 
   Zone* zone() { return zone_; }
 
   Isolate* isolate() { return isolate_; }
 
   Heap::Space allocation_space() { return allocation_space_; }
 
@@ skipping 305 matching lines @@
   GrowableArray<LocalVariable*> iterator_variables;
 };
 
 
 class ScopeBuilder : public RecursiveVisitor {
  public:
   ScopeBuilder(ParsedFunction* parsed_function, TreeNode* node)
       : result_(NULL),
         parsed_function_(parsed_function),
         node_(node),
-        zone_(Thread::Current()->zone()),
-        translation_helper_(Thread::Current(), zone_, Isolate::Current()),
+        translation_helper_(Thread::Current()),
+        zone_(translation_helper_.zone()),
         type_translator_(&translation_helper_,
                          &active_class_,
                          /*finalize=*/true),
         current_function_scope_(NULL),
         scope_(NULL),
         depth_(0),
         name_index_(0) {}
 
   virtual ~ScopeBuilder() {}
 
@@ skipping 74 matching lines @@
     intptr_t finally_;
     intptr_t for_in_;
   };
 
   ScopeBuildingResult* result_;
   ParsedFunction* parsed_function_;
   TreeNode* node_;
 
   ActiveClass active_class_;
 
+  TranslationHelper translation_helper_;
   Zone* zone_;
-  TranslationHelper translation_helper_;
   DartTypeTranslator type_translator_;
 
   FunctionNode* current_function_node_;
   LocalScope* current_function_scope_;
   LocalScope* scope_;
   DepthState depth_;
 
   intptr_t name_index_;
 };
 
 
-class FlowGraphBuilder : public TreeVisitor {
+class FlowGraphBuilder : public ExpressionVisitor, public StatementVisitor {
  public:
   FlowGraphBuilder(TreeNode* node,
                    ParsedFunction* parsed_function,
                    const ZoneGrowableArray<const ICData*>& ic_data_array,
                    InlineExitCollector* exit_collector,
                    intptr_t osr_id,
                    intptr_t first_block_id = 1);
   virtual ~FlowGraphBuilder();
 
   FlowGraph* BuildGraph();
 
-  virtual void VisitDefaultTreeNode(TreeNode* node) { UNREACHABLE(); }
+  virtual void VisitDefaultExpression(Expression* node) { UNREACHABLE(); }
+  virtual void VisitDefaultStatement(Statement* node) { UNREACHABLE(); }
 
   virtual void VisitInvalidExpression(InvalidExpression* node);
   virtual void VisitNullLiteral(NullLiteral* node);
   virtual void VisitBoolLiteral(BoolLiteral* node);
   virtual void VisitIntLiteral(IntLiteral* node);
   virtual void VisitBigintLiteral(BigintLiteral* node);
   virtual void VisitDoubleLiteral(DoubleLiteral* node);
   virtual void VisitStringLiteral(StringLiteral* node);
   virtual void VisitSymbolLiteral(SymbolLiteral* node);
   virtual void VisitTypeLiteral(TypeLiteral* node);
@@ skipping 15 matching lines @@
   virtual void VisitLogicalExpression(LogicalExpression* node);
   virtual void VisitNot(Not* node);
   virtual void VisitThisExpression(ThisExpression* node);
   virtual void VisitStringConcatenation(StringConcatenation* node);
   virtual void VisitListLiteral(ListLiteral* node);
   virtual void VisitMapLiteral(MapLiteral* node);
   virtual void VisitFunctionExpression(FunctionExpression* node);
   virtual void VisitLet(Let* node);
   virtual void VisitThrow(Throw* node);
   virtual void VisitRethrow(Rethrow* node);
-  virtual void VisitBlockExpression(BlockExpression* node);
 
   virtual void VisitInvalidStatement(InvalidStatement* node);
   virtual void VisitEmptyStatement(EmptyStatement* node);
   virtual void VisitBlock(Block* node);
   virtual void VisitReturnStatement(ReturnStatement* node);
   virtual void VisitExpressionStatement(ExpressionStatement* node);
   virtual void VisitVariableDeclaration(VariableDeclaration* node);
   virtual void VisitFunctionDeclaration(FunctionDeclaration* node);
   virtual void VisitIfStatement(IfStatement* node);
   virtual void VisitWhileStatement(WhileStatement* node);
@@ skipping 157 matching lines @@
   void Push(Definition* definition);
   Value* Pop();
   Fragment Drop();
 
   bool IsInlining() { return exit_collector_ != NULL; }
 
   Token::Kind MethodKind(const dart::String& name);
 
   void InlineBailout(const char* reason);
 
+  TranslationHelper translation_helper_;
   Zone* zone_;
-  TranslationHelper translation_helper_;
 
   // The node we are currently compiling (e.g. FunctionNode, Constructor,
   // Field)
   TreeNode* node_;
 
   ParsedFunction* parsed_function_;
   intptr_t osr_id_;
   const ZoneGrowableArray<const ICData*>& ic_data_array_;
   InlineExitCollector* exit_collector_;
 
@@ skipping 72 matching lines @@
   friend class SwitchBlock;
   friend class TryCatchBlock;
   friend class TryFinallyBlock;
 };
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_TO_IL_H_