Make closures optimizable by Crankshaft compiler.

src/compiler.cc

Index: src/compiler.cc
diff --git a/src/compiler.cc b/src/compiler.cc
index e4864e48015df3ef51186b5f814920b6d5364518..88f2d6befb3eea622b9c290346b7a821e2625c0a 100755
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -665,6 +665,14 @@ Handle<SharedFunctionInfo> Compiler::BuildFunctionInfo(FunctionLiteral* literal,
       if (!MakeCrankshaftCode(&info)) {

[Kevin Millikin (Chromium), 2011/01/14 12:48:59]

The code here is confusing.  From my reading of the code:

MakeCrankshaftCode will check if the CompilationInfo allows optimizing, which
requires a closure.  Since we don't have one for BuildFunctionInfo, it's not
allowed from this call site.  Then it will mark the CompilationInfo as not to be
optimized (which it already is anyway) and then always compile with the baseline
compiler.

I think this does the same and is clearer:

if (V8::UseCrankshaft()) {
  if (!FullCodeGenerator::MakeCode(&info)) {
    return Handle...;
  }
  if (FLAG_optimize_closures ....

         return Handle<SharedFunctionInfo>::null();
       }
+      if (FLAG_optimize_closures
+          && !AlwaysFullCompiler()

[Kevin Millikin (Chromium), 2011/01/14 12:48:59]

I'm not sure all these checks are necessary.  I would expect (and hope) that you
don't have to check AlwaysFullCompiler() here because we should never get into
the crankshaft backend for AlwaysFullCompiler().  I don't think you need to
require a non-trivial outer context (do you?).

+          && !info.scope()->HasTrivialOuterContext()
+          && !info.scope()->outer_scope_calls_eval()
+          && !info.scope()->inside_with()) {
+        ASSERT(info.code()->kind() == Code::FUNCTION);
+        info.code()->set_optimizable(true);

[Kevin Millikin (Chromium), 2011/01/14 12:48:59]

Then, I'm not a fan of compiling with non-optimizable and then flipping a bit
after compilation to say that it actually is.  That is error-prone if we do
anything different for optimizable code during baseline compilation.  It would
be better to have these checks before compiling:

if (FLAG_optimize_closures && ...) {
  info->SetOptimizable()  // You'll have to implement this.
}

+      }
     } else {
       // The bodies of function literals have not yet been visited by the
       // AST optimizer/analyzer.