diff --git a/src/ast-numbering.cc b/src/ast-numbering.cc
index e87842405e..8dfdccb966 100644
--- a/src/ast-numbering.cc
+++ b/src/ast-numbering.cc
@@ -39,7 +39,10 @@ class AstNumberingVisitor FINAL : public AstVisitor {
     return tmp;
   }
 
+  void IncrementNodeCount() { properties_.add_node_count(1); }
+
   int next_id_;
+  AstProperties properties_;
 
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
   DISALLOW_COPY_AND_ASSIGN(AstNumberingVisitor);
@@ -47,102 +50,127 @@ class AstNumberingVisitor FINAL : public AstVisitor {
 
 
 void AstNumberingVisitor::VisitVariableDeclaration(VariableDeclaration* node) {
+  IncrementNodeCount();
   VisitVariableProxy(node->proxy());
 }
 
 
 void AstNumberingVisitor::VisitExportDeclaration(ExportDeclaration* node) {
+  IncrementNodeCount();
   VisitVariableProxy(node->proxy());
 }
 
 
-void AstNumberingVisitor::VisitModuleUrl(ModuleUrl* node) {}
+void AstNumberingVisitor::VisitModuleUrl(ModuleUrl* node) {
+  IncrementNodeCount();
+}
 
 
-void AstNumberingVisitor::VisitEmptyStatement(EmptyStatement* node) {}
+void AstNumberingVisitor::VisitEmptyStatement(EmptyStatement* node) {
+  IncrementNodeCount();
+}
 
 
-void AstNumberingVisitor::VisitContinueStatement(ContinueStatement* node) {}
+void AstNumberingVisitor::VisitContinueStatement(ContinueStatement* node) {
+  IncrementNodeCount();
+}
 
 
-void AstNumberingVisitor::VisitBreakStatement(BreakStatement* node) {}
+void AstNumberingVisitor::VisitBreakStatement(BreakStatement* node) {
+  IncrementNodeCount();
+}
 
 
 void AstNumberingVisitor::VisitDebuggerStatement(DebuggerStatement* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(DebuggerStatement::num_ids()));
 }
 
 
 void AstNumberingVisitor::VisitNativeFunctionLiteral(
     NativeFunctionLiteral* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(NativeFunctionLiteral::num_ids()));
 }
 
 
 void AstNumberingVisitor::VisitLiteral(Literal* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(Literal::num_ids()));
 }
 
 
 void AstNumberingVisitor::VisitRegExpLiteral(RegExpLiteral* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(RegExpLiteral::num_ids()));
 }
 
 
 void AstNumberingVisitor::VisitVariableProxy(VariableProxy* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(VariableProxy::num_ids()));
 }
 
 
 void AstNumberingVisitor::VisitThisFunction(ThisFunction* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(ThisFunction::num_ids()));
 }
 
 
 void AstNumberingVisitor::VisitSuperReference(SuperReference* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(SuperReference::num_ids()));
   Visit(node->this_var());
 }
 
 
 void AstNumberingVisitor::VisitModuleDeclaration(ModuleDeclaration* node) {
+  IncrementNodeCount();
   VisitVariableProxy(node->proxy());
   Visit(node->module());
 }
 
 
 void AstNumberingVisitor::VisitImportDeclaration(ImportDeclaration* node) {
+  IncrementNodeCount();
   VisitVariableProxy(node->proxy());
   Visit(node->module());
 }
 
 
 void AstNumberingVisitor::VisitModuleVariable(ModuleVariable* node) {
+  IncrementNodeCount();
   Visit(node->proxy());
 }
 
 
 void AstNumberingVisitor::VisitModulePath(ModulePath* node) {
+  IncrementNodeCount();
   Visit(node->module());
 }
 
 
 void AstNumberingVisitor::VisitModuleStatement(ModuleStatement* node) {
+  IncrementNodeCount();
   Visit(node->body());
 }
 
 
 void AstNumberingVisitor::VisitExpressionStatement(ExpressionStatement* node) {
+  IncrementNodeCount();
   Visit(node->expression());
 }
 
 
 void AstNumberingVisitor::VisitReturnStatement(ReturnStatement* node) {
+  IncrementNodeCount();
   Visit(node->expression());
 }
 
 
 void AstNumberingVisitor::VisitYield(Yield* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(Yield::num_ids()));
   Visit(node->generator_object());
   Visit(node->expression());
@@ -150,24 +178,28 @@ void AstNumberingVisitor::VisitYield(Yield* node) {
 
 
 void AstNumberingVisitor::VisitThrow(Throw* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(Throw::num_ids()));
   Visit(node->exception());
 }
 
 
 void AstNumberingVisitor::VisitUnaryOperation(UnaryOperation* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(UnaryOperation::num_ids()));
   Visit(node->expression());
 }
 
 
 void AstNumberingVisitor::VisitCountOperation(CountOperation* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(CountOperation::num_ids()));
   Visit(node->expression());
 }
 
 
 void AstNumberingVisitor::VisitBlock(Block* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(Block::num_ids()));
   if (node->scope() != NULL) VisitDeclarations(node->scope()->declarations());
   VisitStatements(node->statements());
@@ -175,29 +207,34 @@ void AstNumberingVisitor::VisitBlock(Block* node) {
 
 
 void AstNumberingVisitor::VisitFunctionDeclaration(FunctionDeclaration* node) {
+  IncrementNodeCount();
   VisitVariableProxy(node->proxy());
   VisitFunctionLiteral(node->fun());
 }
 
 
 void AstNumberingVisitor::VisitModuleLiteral(ModuleLiteral* node) {
+  IncrementNodeCount();
   VisitBlock(node->body());
 }
 
 
 void AstNumberingVisitor::VisitCallRuntime(CallRuntime* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(CallRuntime::num_ids()));
   VisitArguments(node->arguments());
 }
 
 
 void AstNumberingVisitor::VisitWithStatement(WithStatement* node) {
+  IncrementNodeCount();
   Visit(node->expression());
   Visit(node->statement());
 }
 
 
 void AstNumberingVisitor::VisitDoWhileStatement(DoWhileStatement* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(DoWhileStatement::num_ids()));
   Visit(node->body());
   Visit(node->cond());
@@ -205,6 +242,7 @@ void AstNumberingVisitor::VisitDoWhileStatement(DoWhileStatement* node) {
 
 
 void AstNumberingVisitor::VisitWhileStatement(WhileStatement* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(WhileStatement::num_ids()));
   Visit(node->cond());
   Visit(node->body());
@@ -212,18 +250,21 @@ void AstNumberingVisitor::VisitWhileStatement(WhileStatement* node) {
 
 
 void AstNumberingVisitor::VisitTryCatchStatement(TryCatchStatement* node) {
+  IncrementNodeCount();
   Visit(node->try_block());
   Visit(node->catch_block());
 }
 
 
 void AstNumberingVisitor::VisitTryFinallyStatement(TryFinallyStatement* node) {
+  IncrementNodeCount();
   Visit(node->try_block());
   Visit(node->finally_block());
 }
 
 
 void AstNumberingVisitor::VisitProperty(Property* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(Property::num_ids()));
   Visit(node->key());
   Visit(node->obj());
@@ -231,6 +272,7 @@ void AstNumberingVisitor::VisitProperty(Property* node) {
 
 
 void AstNumberingVisitor::VisitAssignment(Assignment* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(Assignment::num_ids()));
   if (node->is_compound()) VisitBinaryOperation(node->binary_operation());
   Visit(node->target());
@@ -239,6 +281,7 @@ void AstNumberingVisitor::VisitAssignment(Assignment* node) {
 
 
 void AstNumberingVisitor::VisitBinaryOperation(BinaryOperation* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(BinaryOperation::num_ids()));
   Visit(node->left());
   Visit(node->right());
@@ -246,6 +289,7 @@ void AstNumberingVisitor::VisitBinaryOperation(BinaryOperation* node) {
 
 
 void AstNumberingVisitor::VisitCompareOperation(CompareOperation* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(CompareOperation::num_ids()));
   Visit(node->left());
   Visit(node->right());
@@ -253,6 +297,7 @@ void AstNumberingVisitor::VisitCompareOperation(CompareOperation* node) {
 
 
 void AstNumberingVisitor::VisitForInStatement(ForInStatement* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(ForInStatement::num_ids()));
   Visit(node->each());
   Visit(node->enumerable());
@@ -261,6 +306,7 @@ void AstNumberingVisitor::VisitForInStatement(ForInStatement* node) {
 
 
 void AstNumberingVisitor::VisitForOfStatement(ForOfStatement* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(ForOfStatement::num_ids()));
   Visit(node->assign_iterator());
   Visit(node->next_result());
@@ -271,6 +317,7 @@ void AstNumberingVisitor::VisitForOfStatement(ForOfStatement* node) {
 
 
 void AstNumberingVisitor::VisitConditional(Conditional* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(Conditional::num_ids()));
   Visit(node->condition());
   Visit(node->then_expression());
@@ -279,6 +326,7 @@ void AstNumberingVisitor::VisitConditional(Conditional* node) {
 
 
 void AstNumberingVisitor::VisitIfStatement(IfStatement* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(IfStatement::num_ids()));
   Visit(node->condition());
   Visit(node->then_statement());
@@ -289,6 +337,7 @@ void AstNumberingVisitor::VisitIfStatement(IfStatement* node) {
 
 
 void AstNumberingVisitor::VisitSwitchStatement(SwitchStatement* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(SwitchStatement::num_ids()));
   Visit(node->tag());
   ZoneList<CaseClause*>* cases = node->cases();
@@ -299,6 +348,7 @@ void AstNumberingVisitor::VisitSwitchStatement(SwitchStatement* node) {
 
 
 void AstNumberingVisitor::VisitCaseClause(CaseClause* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(CaseClause::num_ids()));
   if (!node->is_default()) Visit(node->label());
   VisitStatements(node->statements());
@@ -306,6 +356,7 @@ void AstNumberingVisitor::VisitCaseClause(CaseClause* node) {
 
 
 void AstNumberingVisitor::VisitForStatement(ForStatement* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(ForStatement::num_ids()));
   if (node->init() != NULL) Visit(node->init());
   if (node->cond() != NULL) Visit(node->cond());
@@ -315,6 +366,7 @@ void AstNumberingVisitor::VisitForStatement(ForStatement* node) {
 
 
 void AstNumberingVisitor::VisitClassLiteral(ClassLiteral* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(ClassLiteral::num_ids()));
   if (node->extends()) Visit(node->extends());
   if (node->constructor()) Visit(node->constructor());
@@ -325,6 +377,7 @@ void AstNumberingVisitor::VisitClassLiteral(ClassLiteral* node) {
 
 
 void AstNumberingVisitor::VisitObjectLiteral(ObjectLiteral* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(ObjectLiteral::num_ids()));
   for (int i = 0; i < node->properties()->length(); i++) {
     VisitObjectLiteralProperty(node->properties()->at(i));
@@ -340,6 +393,7 @@ void AstNumberingVisitor::VisitObjectLiteralProperty(
 
 
 void AstNumberingVisitor::VisitArrayLiteral(ArrayLiteral* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(node->num_ids()));
   for (int i = 0; i < node->values()->length(); i++) {
     Visit(node->values()->at(i));
@@ -348,6 +402,7 @@ void AstNumberingVisitor::VisitArrayLiteral(ArrayLiteral* node) {
 
 
 void AstNumberingVisitor::VisitCall(Call* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(Call::num_ids()));
   Visit(node->expression());
   VisitArguments(node->arguments());
@@ -355,6 +410,7 @@ void AstNumberingVisitor::VisitCall(Call* node) {
 
 
 void AstNumberingVisitor::VisitCallNew(CallNew* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(CallNew::num_ids()));
   Visit(node->expression());
   VisitArguments(node->arguments());
@@ -385,6 +441,7 @@ void AstNumberingVisitor::VisitArguments(ZoneList<Expression*>* arguments) {
 
 
 void AstNumberingVisitor::VisitFunctionLiteral(FunctionLiteral* node) {
+  IncrementNodeCount();
   node->set_base_id(ReserveIdRange(FunctionLiteral::num_ids()));
   // We don't recurse into the declarations or body of the function literal:
   // you have to separately Renumber() each FunctionLiteral that you compile.
@@ -392,6 +449,10 @@ void AstNumberingVisitor::VisitFunctionLiteral(FunctionLiteral* node) {
 
 
 void AstNumberingVisitor::Renumber(FunctionLiteral* node) {
+  properties_.flags()->Add(*node->flags());
+  properties_.increase_feedback_slots(node->slot_count());
+  properties_.increase_ic_feedback_slots(node->ic_slot_count());
+
   if (node->scope()->HasIllegalRedeclaration()) {
     node->scope()->VisitIllegalRedeclaration(this);
     return;
@@ -404,6 +465,8 @@ void AstNumberingVisitor::Renumber(FunctionLiteral* node) {
     Visit(scope->function());
   }
   VisitStatements(node->body());
+
+  node->set_ast_properties(&properties_);
 }
 
 
diff --git a/src/ast.cc b/src/ast.cc
index 11bb4ef360..1df668ddf7 100644
--- a/src/ast.cc
+++ b/src/ast.cc
@@ -998,36 +998,30 @@ CaseClause::CaseClause(Zone* zone, Expression* label,
 
 #define REGULAR_NODE(NodeType)                                   \
   void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
-    increase_node_count();                                       \
   }
 #define REGULAR_NODE_WITH_FEEDBACK_SLOTS(NodeType)               \
   void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
-    increase_node_count();                                       \
     add_slot_node(node);                                         \
   }
 #define DONT_OPTIMIZE_NODE(NodeType)                             \
   void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
-    increase_node_count();                                       \
     set_dont_crankshaft_reason(k##NodeType);                     \
     add_flag(kDontSelfOptimize);                                 \
   }
 #define DONT_OPTIMIZE_NODE_WITH_FEEDBACK_SLOTS(NodeType)         \
   void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
-    increase_node_count();                                       \
     add_slot_node(node);                                         \
     set_dont_crankshaft_reason(k##NodeType);                     \
     add_flag(kDontSelfOptimize);                                 \
   }
 #define DONT_TURBOFAN_NODE(NodeType)                             \
   void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
-    increase_node_count();                                       \
     set_dont_crankshaft_reason(k##NodeType);                     \
     set_dont_turbofan_reason(k##NodeType);                       \
     add_flag(kDontSelfOptimize);                                 \
   }
 #define DONT_TURBOFAN_NODE_WITH_FEEDBACK_SLOTS(NodeType)         \
   void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
-    increase_node_count();                                       \
     add_slot_node(node);                                         \
     set_dont_crankshaft_reason(k##NodeType);                     \
     set_dont_turbofan_reason(k##NodeType);                       \
@@ -1035,18 +1029,15 @@ CaseClause::CaseClause(Zone* zone, Expression* label,
   }
 #define DONT_SELFOPTIMIZE_NODE(NodeType)                         \
   void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
-    increase_node_count();                                       \
     add_flag(kDontSelfOptimize);                                 \
   }
 #define DONT_SELFOPTIMIZE_NODE_WITH_FEEDBACK_SLOTS(NodeType)     \
   void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
-    increase_node_count();                                       \
     add_slot_node(node);                                         \
     add_flag(kDontSelfOptimize);                                 \
   }
 #define DONT_CACHE_NODE(NodeType)                                \
   void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
-    increase_node_count();                                       \
     set_dont_crankshaft_reason(k##NodeType);                     \
     add_flag(kDontSelfOptimize);                                 \
     add_flag(kDontCache);                                        \
@@ -1120,7 +1111,6 @@ DONT_CACHE_NODE(ModuleLiteral)
 
 
 void AstConstructionVisitor::VisitCallRuntime(CallRuntime* node) {
-  increase_node_count();
   add_slot_node(node);
   if (node->is_jsruntime()) {
     // Don't try to optimize JS runtime calls because we bailout on them.
diff --git a/src/ast.h b/src/ast.h
index ae7ec1a659..6f6cb1e554 100644
--- a/src/ast.h
+++ b/src/ast.h
@@ -3144,7 +3144,6 @@ class AstConstructionVisitor BASE_EMBEDDED {
   AST_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 
-  void increase_node_count() { properties_.add_node_count(1); }
   void add_flag(AstPropertiesFlag flag) { properties_.flags()->Add(flag); }
   void set_dont_crankshaft_reason(BailoutReason reason) {
     dont_crankshaft_reason_ = reason;
diff --git a/src/compiler.cc b/src/compiler.cc
index 92331c6a02..fa8201bf54 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -647,11 +647,7 @@ static void RecordFunctionCompilation(Logger::LogEventsAndTags tag,
 
 static bool CompileUnoptimizedCode(CompilationInfo* info) {
   DCHECK(AllowCompilation::IsAllowed(info->isolate()));
-  DCHECK(info->function() != NULL);
-  if (!Rewriter::Rewrite(info)) return false;
-  if (!Scope::Analyze(info)) return false;
-  DCHECK(info->scope() != NULL);
-
+  if (!Compiler::Analyze(info)) return false;
   if (!FullCodeGenerator::MakeCode(info)) {
     Isolate* isolate = info->isolate();
     if (!isolate->has_pending_exception()) isolate->StackOverflow();
@@ -673,7 +669,6 @@ MUST_USE_RESULT static MaybeHandle<Code> GetUnoptimizedCodeCommon(
   shared->set_strict_mode(lit->strict_mode());
   SetExpectedNofPropertiesFromEstimate(shared, lit->expected_property_count());
   shared->set_bailout_reason(lit->dont_optimize_reason());
-  shared->set_ast_node_count(lit->ast_node_count());
 
   // Compile unoptimized code.
   if (!CompileUnoptimizedCode(info)) return MaybeHandle<Code>();
@@ -743,18 +738,33 @@ static void InsertCodeIntoOptimizedCodeMap(CompilationInfo* info) {
 }
 
 
-static bool CompileOptimizedPrologue(CompilationInfo* info) {
-  if (!Parser::Parse(info)) return false;
+static bool Renumber(CompilationInfo* info) {
+  if (!AstNumbering::Renumber(info->function(), info->zone())) return false;
+  if (!info->shared_info().is_null()) {
+    info->shared_info()->set_ast_node_count(info->function()->ast_node_count());
+  }
+  return true;
+}
+
+
+bool Compiler::Analyze(CompilationInfo* info) {
+  DCHECK(info->function() != NULL);
   if (!Rewriter::Rewrite(info)) return false;
   if (!Scope::Analyze(info)) return false;
-  if (!AstNumbering::Renumber(info->function(), info->zone())) return false;
+  if (!Renumber(info)) return false;
   DCHECK(info->scope() != NULL);
   return true;
 }
 
 
+bool Compiler::ParseAndAnalyze(CompilationInfo* info) {
+  if (!Parser::Parse(info)) return false;
+  return Compiler::Analyze(info);
+}
+
+
 static bool GetOptimizedCodeNow(CompilationInfo* info) {
-  if (!CompileOptimizedPrologue(info)) return false;
+  if (!Compiler::ParseAndAnalyze(info)) return false;
 
   TimerEventScope<TimerEventRecompileSynchronous> timer(info->isolate());
 
@@ -796,7 +806,7 @@ static bool GetOptimizedCodeLater(CompilationInfo* info) {
   }
 
   CompilationHandleScope handle_scope(info);
-  if (!CompileOptimizedPrologue(info)) return false;
+  if (!Compiler::ParseAndAnalyze(info)) return false;
   info->SaveHandles();  // Copy handles to the compilation handle scope.
 
   TimerEventScope<TimerEventRecompileSynchronous> timer(info->isolate());
@@ -910,6 +920,8 @@ bool Compiler::EnsureCompiled(Handle<JSFunction> function,
 // TODO(turbofan): In the future, unoptimized code with deopt support could
 // be generated lazily once deopt is triggered.
 bool Compiler::EnsureDeoptimizationSupport(CompilationInfo* info) {
+  DCHECK(info->function() != NULL);
+  DCHECK(info->scope() != NULL);
   if (!info->shared_info()->has_deoptimization_support()) {
     CompilationInfoWithZone unoptimized(info->shared_info());
     // Note that we use the same AST that we will use for generating the
@@ -1304,7 +1316,7 @@ Handle<SharedFunctionInfo> Compiler::BuildFunctionInfo(
     Handle<Code> code = isolate->builtins()->CompileLazy();
     info.SetCode(code);
     scope_info = Handle<ScopeInfo>(ScopeInfo::Empty(isolate));
-  } else if (FullCodeGenerator::MakeCode(&info)) {
+  } else if (Renumber(&info) && FullCodeGenerator::MakeCode(&info)) {
     DCHECK(!info.code().is_null());
     scope_info = ScopeInfo::Create(info.scope(), info.zone());
   } else {
diff --git a/src/compiler.h b/src/compiler.h
index 47579bd6a2..05b97a92dd 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -675,11 +675,16 @@ class Compiler : public AllStatic {
   MUST_USE_RESULT static MaybeHandle<Code> GetDebugCode(
       Handle<JSFunction> function);
 
+  // Parser::Parse, then Compiler::Analyze.
+  static bool ParseAndAnalyze(CompilationInfo* info);
+  // Rewrite, analyze scopes, and renumber.
+  static bool Analyze(CompilationInfo* info);
+  // Adds deoptimization support, requires ParseAndAnalyze.
+  static bool EnsureDeoptimizationSupport(CompilationInfo* info);
+
   static bool EnsureCompiled(Handle<JSFunction> function,
                              ClearExceptionFlag flag);
 
-  static bool EnsureDeoptimizationSupport(CompilationInfo* info);
-
   static void CompileForLiveEdit(Handle<Script> script);
 
   // Compile a String source within a context for eval.
diff --git a/src/compiler/js-inlining.cc b/src/compiler/js-inlining.cc
index bab3308cb8..b70a3d270b 100644
--- a/src/compiler/js-inlining.cc
+++ b/src/compiler/js-inlining.cc
@@ -59,17 +59,6 @@ void JSInliner::Inline() {
 }
 
 
-// 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.
@@ -385,7 +374,8 @@ void JSInliner::TryInlineJSCall(Node* call_node) {
   }
 
   CompilationInfoWithZone info(function);
-  Parse(function, &info);
+  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.
diff --git a/src/full-codegen.cc b/src/full-codegen.cc
index 9d31cd5230..f7efc5ce43 100644
--- a/src/full-codegen.cc
+++ b/src/full-codegen.cc
@@ -308,11 +308,6 @@ bool FullCodeGenerator::MakeCode(CompilationInfo* info) {
 
   TimerEventScope<TimerEventCompileFullCode> timer(info->isolate());
 
-  if (!AstNumbering::Renumber(info->function(), info->zone())) {
-    DCHECK(!isolate->has_pending_exception());
-    return false;
-  }
-
   Handle<Script> script = info->script();
   if (!script->IsUndefined() && !script->source()->IsUndefined()) {
     int len = String::cast(script->source())->length();
diff --git a/src/hydrogen.cc b/src/hydrogen.cc
index c2bdd6609b..d058ae0a59 100644
--- a/src/hydrogen.cc
+++ b/src/hydrogen.cc
@@ -7845,8 +7845,7 @@ bool HOptimizedGraphBuilder::TryInline(Handle<JSFunction> target,
   // step, but don't transfer ownership to target_info.
   target_info.SetAstValueFactory(top_info()->ast_value_factory(), false);
   Handle<SharedFunctionInfo> target_shared(target->shared());
-  if (!Parser::Parse(&target_info) || !Scope::Analyze(&target_info) ||
-      !AstNumbering::Renumber(target_info.function(), target_info.zone())) {
+  if (!Compiler::ParseAndAnalyze(&target_info)) {
     if (target_info.isolate()->has_pending_exception()) {
       // Parse or scope error, never optimize this function.
       SetStackOverflow();
diff --git a/test/cctest/compiler/function-tester.h b/test/cctest/compiler/function-tester.h
index eb6bd498cc..600f6a32ee 100644
--- a/test/cctest/compiler/function-tester.h
+++ b/test/cctest/compiler/function-tester.h
@@ -165,9 +165,7 @@ class FunctionTester : public InitializedHandleScope {
     if (flags_ & CompilationInfo::kTypingEnabled) {
       info.MarkAsTypingEnabled();
     }
-    CHECK(Rewriter::Rewrite(&info));
-    CHECK(Scope::Analyze(&info));
-    CHECK(AstNumbering::Renumber(info.function(), info.zone()));
+    CHECK(Compiler::Analyze(&info));
     CHECK(Compiler::EnsureDeoptimizationSupport(&info));
 
     Pipeline pipeline(&info);
@@ -215,9 +213,7 @@ class FunctionTester : public InitializedHandleScope {
     CHECK(Parser::Parse(&info));
     info.SetOptimizing(BailoutId::None(),
                        Handle<Code>(function->shared()->code()));
-    CHECK(Rewriter::Rewrite(&info));
-    CHECK(Scope::Analyze(&info));
-    CHECK(AstNumbering::Renumber(info.function(), info.zone()));
+    CHECK(Compiler::Analyze(&info));
     CHECK(Compiler::EnsureDeoptimizationSupport(&info));
 
     Pipeline pipeline(&info);
diff --git a/test/cctest/compiler/test-codegen-deopt.cc b/test/cctest/compiler/test-codegen-deopt.cc
index 799fa9438e..f01b0e13fa 100644
--- a/test/cctest/compiler/test-codegen-deopt.cc
+++ b/test/cctest/compiler/test-codegen-deopt.cc
@@ -47,9 +47,7 @@ class DeoptCodegenTester {
         bailout_id(-1) {
     CHECK(Parser::Parse(&info));
     info.SetOptimizing(BailoutId::None(), Handle<Code>(function->code()));
-    CHECK(Rewriter::Rewrite(&info));
-    CHECK(Scope::Analyze(&info));
-    CHECK(AstNumbering::Renumber(info.function(), info.zone()));
+    CHECK(Compiler::Analyze(&info));
     CHECK(Compiler::EnsureDeoptimizationSupport(&info));
 
     DCHECK(info.shared_info()->has_deoptimization_support());
diff --git a/test/cctest/compiler/test-pipeline.cc b/test/cctest/compiler/test-pipeline.cc
index 9d8a2d1b80..98b0baeefd 100644
--- a/test/cctest/compiler/test-pipeline.cc
+++ b/test/cctest/compiler/test-pipeline.cc
@@ -23,11 +23,7 @@ TEST(PipelineAdd) {
       *v8::Handle<v8::Function>::Cast(CompileRun(source)));
   CompilationInfoWithZone info(function);
 
-  CHECK(Parser::Parse(&info));
-  CHECK(Rewriter::Rewrite(&info));
-  CHECK(Scope::Analyze(&info));
-  CHECK(AstNumbering::Renumber(info.function(), info.zone()));
-  CHECK_NE(NULL, info.scope());
+  CHECK(Compiler::ParseAndAnalyze(&info));
 
   Pipeline pipeline(&info);
 #if V8_TURBOFAN_TARGET
diff --git a/test/cctest/test-parsing.cc b/test/cctest/test-parsing.cc
index 40281678d9..c1bb363a03 100644
--- a/test/cctest/test-parsing.cc
+++ b/test/cctest/test-parsing.cc
@@ -3273,9 +3273,7 @@ TEST(InnerAssignment) {
           i::Parser parser(&info, &parse_info);
           parser.set_allow_harmony_scoping(true);
           CHECK(parser.Parse());
-          CHECK(i::Rewriter::Rewrite(&info));
-          CHECK(i::Scope::Analyze(&info));
-          CHECK(i::AstNumbering::Renumber(info.function(), info.zone()));
+          CHECK(i::Compiler::Analyze(&info));
           CHECK(info.function() != NULL);
 
           i::Scope* scope = info.function()->scope();