Do not create unresolved variables when parsing arrow functions lazily

src/parser.cc

Index: src/parser.cc
diff --git a/src/parser.cc b/src/parser.cc
index dff7de9e6b25c9c9370c866ab5bd4f52646852a6..0c0fe36f1b9635a772a0251ade4a29dfdf0afbd8 100644
--- a/src/parser.cc
+++ b/src/parser.cc
@@ -723,7 +723,14 @@ Expression* ParserTraits::ExpressionFromIdentifier(const AstRawString* name,
     PrintF("# Variable %.*s ", name->length(), name->raw_data());
 #endif
   Interface* interface = Interface::NewUnknown(parser_->zone());
-  return scope->NewUnresolved(factory, name, interface, pos);
+
+  // Arrow function parameters are parsed as an expression. When
+  // parsing lazily, it is enough to create a VariableProxy in order
+  // for Traits::DeclareArrowParametersFromExpression() to be able to
+  // pick the names of the parameters.
+  return parser_->parsing_lazy_arrow_parameters_
+      ? factory->NewVariableProxy(name, false, interface, pos)
+      : scope->NewUnresolved(factory, name, interface, pos);
 }
 
 
@@ -788,6 +795,7 @@ Parser::Parser(CompilationInfo* info, ParseInfo* parse_info)
       target_stack_(NULL),
       cached_parse_data_(NULL),
       info_(info),
+      parsing_lazy_arrow_parameters_(false),
       has_pending_error_(false),
       pending_error_message_(NULL),
       pending_error_arg_(NULL),
@@ -1061,6 +1069,10 @@ FunctionLiteral* Parser::ParseLazy(Utf16CharacterStream* source) {
     bool ok = true;
 
     if (shared_info->is_arrow()) {
+      // The first expression being parsed is the parameter list of the arrow
+      // function. Setting this avoids prevents ExpressionFromIdentifier()
+      // from creating unresolved variables in already-resolved scopes.
+      parsing_lazy_arrow_parameters_ = true;
       Expression* expression = ParseExpression(false, &ok);
       DCHECK(expression->IsFunctionLiteral());
       result = expression->AsFunctionLiteral();

[marja, 2015/01/29 09:53:01]

Why are setting parsing_lazy_arrow_parameters_ to true and false so far apart
(conceptually)? Can we set it to false right after ParseExpression here? (Then
it would be trivial to see that it is actually set back to false after we're
done.)

[aperez, 2015/01/29 14:38:03]

That does not work.

ParseExpression() here parses the whole arrow function, including the body,
which can itself en up calling ParseExpression().

The flag has to be active only for the “expressions” inside the parameter list
of the arrow function, that's why the flag is set to “false” in
DeclareArrowParametersFromExpression(): at that point it's certain that at least
one entire arrow function parameter list has been parsed.

Other arrow functions contained inside the top-level arrow function being parsed
lazily are always parsed eagerly, so for those the flag will be always “false”
because their parsing has not been started by ParseLazy().

I hope it is clearer now why the flag is reset inside
DeclareArrowParametersFromExpression().

@@ -3341,6 +3353,10 @@ int ParserTraits::DeclareArrowParametersFromExpression(
     Expression* expression, Scope* scope, Scanner::Location* dupe_loc,
     bool* ok) {
   int num_params = 0;
+  // Always reset the flag: It only needs to be set for the first expression
+  // parsed as arrow function parameter list, becauseonly top-level functions
+  // are parsed lazily.
+  parser_->parsing_lazy_arrow_parameters_ = false;
   *ok = CheckAndDeclareArrowParameter(this, expression, scope, &num_params,
                                       dupe_loc);
   return num_params;