[es6] implement optional parameters via desugaring (with scoping)

src/preparser.cc

 // Copyright 2011 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.
 
 #include <cmath>
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/conversions-inl.h"
 #include "src/conversions.h"
@@ skipping 90 matching lines @@
 PreParser::PreParseResult PreParser::PreParseLazyFunction(
     LanguageMode language_mode, FunctionKind kind, ParserRecorder* log) {
   log_ = log;
   // Lazy functions always have trivial outer scopes (no with/catch scopes).
   Scope* top_scope = NewScope(scope_, SCRIPT_SCOPE);
   PreParserFactory top_factory(NULL);
   FunctionState top_state(&function_state_, &scope_, top_scope, kNormalFunction,
                           &top_factory);
   scope_->SetLanguageMode(language_mode);
   Scope* function_scope = NewScope(scope_, FUNCTION_SCOPE);
+  Scope* function_body = NewScope(function_scope, FUNCTION_BODY_SCOPE);
+  DCHECK_EQ(function_scope->function_body(), function_body);
   PreParserFactory function_factory(NULL);
   FunctionState function_state(&function_state_, &scope_, function_scope, kind,
                                &function_factory);
   DCHECK_EQ(Token::LBRACE, scanner()->current_token());
   bool ok = true;
   int start_position = peek_position();
-  ParseLazyFunctionLiteralBody(&ok);
+  {
+    DCHECK(scope_->is_function_scope());
+    BlockState(&scope_, function_body);
+    ParseLazyFunctionLiteralBody(&ok);
+  }
   if (stack_overflow()) return kPreParseStackOverflow;
   if (!ok) {
     ReportUnexpectedToken(scanner()->current_token());
   } else {
     DCHECK_EQ(Token::RBRACE, scanner()->peek());
     if (is_strict(scope_->language_mode())) {
       int end_pos = scanner()->location().end_pos;
       CheckStrictOctalLiteral(start_position, end_pos, &ok);
       if (!ok) return kPreParseSuccess;
 
@@ skipping 861 matching lines @@
     Identifier function_name, Scanner::Location function_name_location,
     bool name_is_strict_reserved, FunctionKind kind, int function_token_pos,
     FunctionLiteral::FunctionType function_type,
     FunctionLiteral::ArityRestriction arity_restriction, bool* ok) {
   // Function ::
   //   '(' FormalParameterList? ')' '{' FunctionBody '}'
 
   // Parse function body.
   bool outer_is_script_scope = scope_->is_script_scope();
   Scope* function_scope = NewScope(scope_, FUNCTION_SCOPE);
+  Scope* function_body = NewScope(function_scope, FUNCTION_BODY_SCOPE);

[arv (Not doing code reviews), 2015/05/01 18:31:33]

I wonder if it is not better to change the order of these:

function f(x = 1, y = 2) {}

function f() {
  {  // FUNCTION_PARAM_SCOPE
    let x = $_Argument(0) === undefined ? ....
    let y = $_Argument(1) === undefined ? ....
    { // FUNCTION_SCOPE
      ...
    }
}

The main reason might be to make sure FunctionDeclarations are not hoisted up
into the same scope as the parameters...   
  

Also it might be easier/better for enforcing eval introduced variables in the
initializer, as in:

function f(x = eval('var y = 2')) {
  assert(typeof y === 'undefined');
}

[caitp (gmail), 2015/05/01 19:03:35]

Is what you're saying "make the parameter scope a child scope of the function
body scope"?

That's the approach taken in the other CL, and it works nicely --- but it still
requires some extra hacks to make sure the parameter scope won't resolve
declarations in the function body. I think that hack might be simpler than the
series of other hacks required to make sure everything is allocated properly.

I'm not sure which is the right way to go, right now it seems like they both
need hacks to work properly :(

+  DCHECK_EQ(function_scope->function_body(), function_body);
   PreParserFactory factory(NULL);
   FunctionState function_state(&function_state_, &scope_, function_scope, kind,
                                &factory);
   FormalParameterErrorLocations error_locs;
 
   bool is_rest = false;
   Expect(Token::LPAREN, CHECK_OK);
   int start_position = scanner()->location().beg_pos;
   function_scope->set_start_position(start_position);
   int num_parameters;
   {
     DuplicateFinder duplicate_finder(scanner()->unicode_cache());
-    num_parameters = ParseFormalParameterList(&duplicate_finder, &error_locs,
-                                              &is_rest, CHECK_OK);
+    PreParserExpressionList initializers = NewExpressionList(0, zone());
+    bool has_initializers = false;
+
+    num_parameters =
+        ParseFormalParameterList(&duplicate_finder, &error_locs, initializers,
+                                 &has_initializers, &is_rest, CHECK_OK);
   }
   Expect(Token::RPAREN, CHECK_OK);
   int formals_end_position = scanner()->location().end_pos;
 
   CheckArityRestrictions(num_parameters, arity_restriction, start_position,
                          formals_end_position, CHECK_OK);
 
   // See Parser::ParseFunctionLiteral for more information about lazy parsing
   // and lazy compilation.
   bool is_lazily_parsed =
       (outer_is_script_scope && allow_lazy() && !parenthesized_function_);
   parenthesized_function_ = false;
 
   Expect(Token::LBRACE, CHECK_OK);
-  if (is_lazily_parsed) {
-    ParseLazyFunctionLiteralBody(CHECK_OK);
-  } else {
-    ParseStatementList(Token::RBRACE, CHECK_OK);
+  {
+    BlockState function_body_state(&scope_, function_body);
+    if (is_lazily_parsed) {
+      ParseLazyFunctionLiteralBody(CHECK_OK);
+    } else {
+      ParseStatementList(Token::RBRACE, CHECK_OK);
+    }
   }
   Expect(Token::RBRACE, CHECK_OK);
 
   // Validate name and parameter names. We can do this only after parsing the
   // function, since the function can declare itself strict.
   CheckFunctionName(language_mode(), kind, function_name,
                     name_is_strict_reserved, function_name_location, CHECK_OK);
   const bool use_strict_params = is_rest || IsConciseMethod(kind);
   CheckFunctionParameterNames(language_mode(), use_strict_params, error_locs,
                               CHECK_OK);
@@ skipping 106 matching lines @@
 
   DCHECK(!spread_pos.IsValid());
 
   return Expression::Default();
 }
 
 #undef CHECK_OK
 
 
 } }  // v8::internal