Move AST node counting to post-pass

src/compiler/js-inlining.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/ast.h"
 #include "src/ast-numbering.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/ast-graph-builder.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/generic-node-inl.h"
@@ skipping 41 matching lines @@
   JSInliner* inliner_;
 };
 
 
 void JSInliner::Inline() {
   InlinerVisitor visitor(this);
   jsgraph_->graph()->VisitNodeInputsFromEnd(&visitor);
 }
 
 
-// TODO(sigurds) Find a home for this function and reuse it everywhere (esp. in
-// test cases, where similar code is currently duplicated).
-static void Parse(Handle<JSFunction> function, CompilationInfoWithZone* info) {
-  CHECK(Parser::Parse(info));
-  CHECK(Rewriter::Rewrite(info));
-  CHECK(Scope::Analyze(info));
-  CHECK(AstNumbering::Renumber(info->function(), info->zone()));
-  CHECK(Compiler::EnsureDeoptimizationSupport(info));
-}
-
-
 // A facade on a JSFunction's graph to facilitate inlining. It assumes the
 // that the function graph has only one return statement, and provides
 // {UnifyReturn} to convert a function graph to that end.
 class Inlinee {
  public:
   Inlinee(Node* start, Node* end) : start_(start), end_(end) {}
 
   // Returns the last regular control node, that is
   // the last control node before the end node.
   Node* end_block() { return NodeProperties::GetControlInput(unique_return()); }
@@ skipping 295 matching lines @@
     if (FLAG_trace_turbo_inlining) {
       SmartArrayPointer<char> name =
           function->shared()->DebugName()->ToCString();
       PrintF("Not Inlining %s into %s because inlinee is native\n", name.get(),
              info_->shared_info()->DebugName()->ToCString().get());
     }
     return;
   }
 
   CompilationInfoWithZone info(function);
-  Parse(function, &info);
+  // TODO(wingo): ParseAndAnalyze can fail due to stack overflow.

[wingo, 2014/10/28 08:31:02]

Here I added this TODO.  Should we just return if parse/analyze fails?  I would
think so.

+  CHECK(Compiler::ParseAndAnalyze(&info));
+  CHECK(Compiler::EnsureDeoptimizationSupport(&info));
 
   if (info.scope()->arguments() != NULL && info.strict_mode() != STRICT) {
     // For now do not inline functions that use their arguments array.
     SmartArrayPointer<char> name = function->shared()->DebugName()->ToCString();
     if (FLAG_trace_turbo_inlining) {
       PrintF(
           "Not Inlining %s into %s because inlinee uses arguments "
           "array\n",
           name.get(), info_->shared_info()->DebugName()->ToCString().get());
     }
@@ skipping 99 matching lines @@
              info_->shared_info()->DebugName()->ToCString().get());
     }
     NodeProperties::ReplaceWithValue(call_node, r.first, r.second);
     call_node->RemoveAllInputs();
     DCHECK_EQ(0, call_node->UseCount());
   }
 }
 }
 }
 }  // namespace v8::internal::compiler