Always lazy compile arrow functions

src/preparser.h

 // Copyright 2012 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.
 
 #ifndef V8_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/bailout-reason.h"
 #include "src/expression-classifier.h"
 #include "src/func-name-inferrer.h"
@@ skipping 1065 matching lines @@
     return TypeField::decode(code_) == kBinaryOperationExpression;
   }
 
   // Dummy implementation for making expression->somefunc() work in both Parser
   // and PreParser.
   PreParserExpression* operator->() { return this; }
 
   // More dummy implementations of things PreParser doesn't need to track:
   void set_index(int index) {}  // For YieldExpressions
   void set_should_eager_compile() {}
+  FunctionKind kind() const { return FunctionKind::kNormalFunction; }
 
   int position() const { return RelocInfo::kNoPosition; }
   void set_function_token_position(int position) {}
 
  private:
   enum Type {
     kExpression,
     kIdentifierExpression,
     kStringLiteralExpression,
     kBinaryOperationExpression,
@@ skipping 2176 matching lines @@
           pos = position();
         } else {
           // For other kinds of calls we record position of the parenthesis as
           // position of the call. Note that this is extremely important for
           // expressions of the form function(){...}() for which call position
           // should not point to the closing brace otherwise it will intersect
           // with positions recorded for function literal and confuse debugger.
           pos = peek_position();
           // Also the trailing parenthesis are a hint that the function will
           // be called immediately. If we happen to have parsed a preceding
-          // function literal eagerly, we can also compile it eagerly.
-          if (result->IsFunctionLiteral() && mode() == PARSE_EAGERLY) {
+          // function literal eagerly, we can also compile it eagerly (unless
+          // that literal was an arrow function, in which case we always
+          // compile lazily in order to get scoping right for its parameters,
+          // see https://code.google.com/p/v8/issues/detail?id=4395).
+          if (result->IsFunctionLiteral() && mode() == PARSE_EAGERLY &&
+              !IsArrowFunction(result->AsFunctionLiteral()->kind())) {

[caitp (gmail), 2015/09/19 21:34:36]

The only time you _need_ to force re-parsing of arrows is when the parameter
list contains expressions (eg an initializer), so we could probably add an extra
condition to escape lazy parsing here. But, it might not matter that much
anyway, so.

[rossberg, 2015/09/22 15:33:05]

That's a good point. It might make sense to avoid enforcing lazy parsing for
arrow functions with simple parameters. I expect arrow IIFE to become a not
too-uncommon use case.

             result->AsFunctionLiteral()->set_should_eager_compile();
           }
         }
         Scanner::Location spread_pos;
         typename Traits::Type::ExpressionList args =
             ParseArguments(&spread_pos, classifier, CHECK_OK);
 
         // Keep track of eval() calls since they disable all local variable
         // optimizations.
         // The calls that need special treatment are the
@@ skipping 884 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H