Change the list of statements that are inlineable into a black-list.

src/ast.cc

Index: src/ast.cc
===================================================================
--- src/ast.cc	(revision 7573)
+++ src/ast.cc	(working copy)
@@ -349,6 +349,11 @@
 // ----------------------------------------------------------------------------
 // Inlining support
 
+bool Declaration::IsInlineable() const {
+  return false;
+}
+
+
 bool Block::IsInlineable() const {
   const int count = statements_.length();
   for (int i = 0; i < count; ++i) {
@@ -364,16 +369,112 @@
 
 
 bool IfStatement::IsInlineable() const {
-  return condition()->IsInlineable() && then_statement()->IsInlineable() &&
-      else_statement()->IsInlineable();
+  return condition()->IsInlineable()
+      && then_statement()->IsInlineable()
+      && else_statement()->IsInlineable();
 }
 
 
+bool ForStatement::IsInlineable() const {
+  return false;

[Kevin Millikin (Chromium), 2011/04/12 07:23:00]

It won't stay sorted, but I think it's easiest to have all the blacklisted AST
types listed first and together, maybe even with a comment listing what they
are.

+}
+
+
+bool WhileStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool DoWhileStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool ForInStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool ContinueStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool BreakStatement::IsInlineable() const {
+  return false;
+}
+
+
 bool ReturnStatement::IsInlineable() const {
   return expression()->IsInlineable();
 }
 
 
+bool WithEnterStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool WithExitStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool SwitchStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool TargetCollector::IsInlineable() const {
+  return false;
+}
+
+bool TryStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool TryCatchStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool TryFinallyStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool DebuggerStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool EmptyStatement::IsInlineable() const {
+  return true;
+}
+
+
+bool Literal::IsInlineable() const {
+  return true;
+}
+
+
+bool MaterializedLiteral::IsInlineable() const {
+  return false;
+}
+
+
+bool CatchExtensionObject::IsInlineable() const {
+  return false;
+}
+
+
+bool Slot::IsInlineable() const {
+  UNREACHABLE();
+  return false;
+}
+
+
 bool Conditional::IsInlineable() const {
   return condition()->IsInlineable() && then_expression()->IsInlineable() &&
       else_expression()->IsInlineable();
@@ -390,6 +491,26 @@
 }
 
 
+bool Throw::IsInlineable() const {
+  return false;
+}
+
+
+bool FunctionLiteral::IsInlineable() const {
+  return false;
+}
+
+
+bool ThisFunction::IsInlineable() const {
+  return false;
+}
+
+
+bool SharedFunctionInfoLiteral::IsInlineable() const {
+  return false;
+}
+
+
 bool Property::IsInlineable() const {
   return obj()->IsInlineable() && key()->IsInlineable();
 }
@@ -449,6 +570,12 @@
 }
 
 
+bool ValidLeftHandSideSentinel::IsInlineable() const {
+  UNREACHABLE();
+  return false;
+}
+
+
 // ----------------------------------------------------------------------------
 // Recording of type feedback