Minor simplification and cleanup of graph builder.

src/compiler/ast-graph-builder.cc

 // 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.
 
 #include "src/compiler/ast-graph-builder.h"
 
 #include "src/compiler.h"
 #include "src/compiler/control-builders.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/full-codegen.h"
 #include "src/parser.h"
 #include "src/scopes.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
-AstGraphBuilder::AstGraphBuilder(CompilationInfo* info, JSGraph* jsgraph,
-                                 SourcePositionTable* source_positions)
+AstGraphBuilder::AstGraphBuilder(CompilationInfo* info, JSGraph* jsgraph)
     : StructuredGraphBuilder(jsgraph->graph(), jsgraph->common()),
       info_(info),
       jsgraph_(jsgraph),
-      source_positions_(source_positions),
       globals_(0, info->zone()),
       breakable_(NULL),
       execution_context_(NULL) {
   InitializeAstVisitor(info->zone());
 }
 
 
 Node* AstGraphBuilder::GetFunctionClosure() {
   if (!function_closure_.is_set()) {
     // Parameter -1 is special for the function closure
@@ skipping 13 matching lines @@
     function_context_.set(node);
   }
   return function_context_.get();
 }
 
 
 bool AstGraphBuilder::CreateGraph() {
   Scope* scope = info()->scope();
   DCHECK(graph() != NULL);
 
-  SourcePositionTable::Scope start_pos(
-      source_positions(),
-      SourcePosition(info()->shared_info()->start_position()));
-
   // Set up the basic structure of the graph.
-  graph()->SetStart(
-      graph()->NewNode(common()->Start(info()->num_parameters())));
+  int parameter_count = info()->num_parameters();
+  graph()->SetStart(graph()->NewNode(common()->Start(parameter_count)));
 
   // Initialize the top-level environment.
   Environment env(this, scope, graph()->start());
   set_environment(&env);
 
   // Build node to initialize local function context.
   Node* closure = GetFunctionClosure();
   Node* outer = GetFunctionContext();
   Node* inner = BuildLocalFunctionContext(outer, closure);
 
@@ skipping 16 matching lines @@
   // Visit declarations within the function scope.
   VisitDeclarations(scope->declarations());
 
   // TODO(mstarzinger): This should do an inlined stack check.
   NewNode(javascript()->Runtime(Runtime::kStackGuard, 0));
 
   // Visit statements in the function body.
   VisitStatements(info()->function()->body());
   if (HasStackOverflow()) return false;
 
-  SourcePositionTable::Scope end_pos(
-      source_positions(),
-      SourcePosition(info()->shared_info()->end_position() - 1));
-
   // Emit tracing call if requested to do so.
   if (FLAG_trace) {
     // TODO(mstarzinger): Only traces implicit return.
     Node* return_value = jsgraph()->UndefinedConstant();
     NewNode(javascript()->Runtime(Runtime::kTraceExit, 1), return_value);
   }
 
   // Return 'undefined' in case we can fall off the end.
   Node* control = NewNode(common()->Return(), jsgraph()->UndefinedConstant());
   UpdateControlDependencyToLeaveFunction(control);
@@ skipping 1836 matching lines @@
       UNREACHABLE();
       js_op = NULL;
   }
   return NewNode(js_op, left, right);
 }
 
 
 void AstGraphBuilder::BuildLazyBailout(Node* node, BailoutId ast_id) {
   if (OperatorProperties::CanLazilyDeoptimize(node->op())) {
     // The deopting node should have an outgoing control dependency.
-    DCHECK(GetControlDependency() == node);
+    DCHECK(environment()->GetControlDependency() == node);
 
-    StructuredGraphBuilder::Environment* continuation_env =
-        environment_internal();
+    StructuredGraphBuilder::Environment* continuation_env = environment();
     // Create environment for the deoptimization block, and build the block.
     StructuredGraphBuilder::Environment* deopt_env =
         CopyEnvironment(continuation_env);
     set_environment(deopt_env);
 
     NewNode(common()->LazyDeoptimization());
 
     Node* state_node = environment()->Checkpoint(ast_id);
 
     Node* deoptimize_node = NewNode(common()->Deoptimize(), state_node);
 
     UpdateControlDependencyToLeaveFunction(deoptimize_node);
 
     // Continue with the original environment.
     set_environment(continuation_env);
 
     NewNode(common()->Continuation());
   }
 }
 }
 }
 }  // namespace v8::internal::compiler