Minor simplification and cleanup of graph builder.

src/compiler/ast-graph-builder.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_COMPILER_AST_GRAPH_BUILDER_H_
 #define V8_COMPILER_AST_GRAPH_BUILDER_H_
 
 #include "src/v8.h"
 
 #include "src/ast.h"
 #include "src/compiler/graph-builder.h"
 #include "src/compiler/js-graph.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 class ControlBuilder;
 class LoopBuilder;
 class Graph;
 
 // The AstGraphBuilder produces a high-level IR graph, based on an
 // underlying AST. The produced graph can either be compiled into a
 // stand-alone function or be wired into another graph for the purposes
 // of function inlining.
 class AstGraphBuilder : public StructuredGraphBuilder, public AstVisitor {
  public:
-  AstGraphBuilder(CompilationInfo* info, JSGraph* jsgraph,
-                  SourcePositionTable* source_positions_);
+  AstGraphBuilder(CompilationInfo* info, JSGraph* jsgraph);
 
   // Creates a graph by visiting the entire AST.
   bool CreateGraph();
 
  protected:
   class AstContext;
   class AstEffectContext;
   class AstValueContext;
   class AstTestContext;
   class BreakableScope;
   class ContextScope;
   class Environment;
 
   Environment* environment() {
-    return reinterpret_cast<Environment*>(environment_internal());
+    return reinterpret_cast<Environment*>(
+        StructuredGraphBuilder::environment());
   }
 
   AstContext* ast_context() const { return ast_context_; }
   BreakableScope* breakable() const { return breakable_; }
   ContextScope* execution_context() const { return execution_context_; }
 
   void set_ast_context(AstContext* ctx) { ast_context_ = ctx; }
   void set_breakable(BreakableScope* brk) { breakable_ = brk; }
   void set_execution_context(ContextScope* ctx) { execution_context_ = ctx; }
 
   // Support for control flow builders. The concrete type of the environment
   // depends on the graph builder, but environments themselves are not virtual.
   typedef StructuredGraphBuilder::Environment BaseEnvironment;
   virtual BaseEnvironment* CopyEnvironment(BaseEnvironment* env);
 
-  SourcePositionTable* source_positions() { return source_positions_; }
-
   // TODO(mstarzinger): The pipeline only needs to be a friend to access the
   // function context. Remove as soon as the context is a parameter.
   friend class Pipeline;
 
   // Getters for values in the activation record.
   Node* GetFunctionClosure();
   Node* GetFunctionContext();
 
   //
   // The following build methods all generate graph fragments and return one
@@ skipping 35 matching lines @@
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 
   // Visiting function for declarations list is overridden.
   virtual void VisitDeclarations(ZoneList<Declaration*>* declarations);
 
  private:
   CompilationInfo* info_;
   AstContext* ast_context_;
   JSGraph* jsgraph_;
-  SourcePositionTable* source_positions_;
 
   // List of global declarations for functions and variables.
   ZoneList<Handle<Object> > globals_;
 
   // Stack of breakable statements entered by the visitor.
   BreakableScope* breakable_;
 
   // Stack of context objects pushed onto the chain by the visitor.
   ContextScope* execution_context_;
 
@@ skipping 284 matching lines @@
 };
 
 Scope* AstGraphBuilder::current_scope() const {
   return execution_context_->scope();
 }
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_AST_GRAPH_BUILDER_H_