[es6] implement default parameters via desugaring

src/parser.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 1116 matching lines @@
               ? FunctionLiteral::ANONYMOUS_EXPRESSION
               : FunctionLiteral::NAMED_EXPRESSION)
         : FunctionLiteral::DECLARATION;
     bool ok = true;
 
     if (shared_info->is_arrow()) {
       Scope* scope = NewScope(scope_, ARROW_SCOPE);
       scope->set_start_position(shared_info->start_position());
       FormalParameterErrorLocations error_locs;
       bool has_rest = false;
+      bool has_initializers = false;
+      ZoneList<Expression*>* initializers =
+          new (zone()) ZoneList<Expression*>(0, zone());
       if (Check(Token::LPAREN)) {
         // '(' StrictFormalParameters ')'
-        ParseFormalParameterList(scope, &error_locs, &has_rest, &ok);
+        ParseFormalParameterList(scope, &error_locs, initializers,
+                                 &has_initializers, &has_rest, &ok);
         if (ok) ok = Check(Token::RPAREN);
       } else {
         // BindingIdentifier
-        ParseFormalParameter(scope, &error_locs, has_rest, &ok);
+        ParseFormalParameter(scope, &error_locs, nullptr, nullptr, has_rest,
+                             &ok);
       }
 
       if (ok) {
         ExpressionClassifier classifier;
         Expression* expression = ParseArrowFunctionLiteral(
             scope, error_locs, has_rest, &classifier, &ok);
         ValidateExpression(&classifier, &ok);
         if (ok) {
           // Scanning must end at the same position that was recorded
           // previously. If not, parsing has been interrupted due to a stack
@@ skipping 903 matching lines @@
   // initialization code. Thus, inside the 'with' statement, we need
   // both access to the static and the dynamic context chain; the
   // runtime needs to provide both.
   if (resolve && var != NULL) {
     proxy->BindTo(var);
   }
   return var;
 }
 
 
+void Parser::ShadowParametersForExpressions(Scope* scope) {
+  scope->ShadowParametersForExpressions();
+}
+
+
 // Language extension which is only enabled for source files loaded
 // through the API's extension mechanism.  A native function
 // declaration is resolved by looking up the function through a
 // callback provided by the extension.
 Statement* Parser::ParseNativeDeclaration(bool* ok) {
   int pos = peek_position();
   Expect(Token::FUNCTION, CHECK_OK);
   // Allow "eval" or "arguments" for backward compatibility.
   const AstRawString* name =
       ParseIdentifier(kAllowRestrictedIdentifiers, CHECK_OK);
@@ skipping 1438 matching lines @@
 
   inner_scope->set_end_position(scanner()->location().end_pos);
   inner_block->set_scope(inner_scope);
   scope_ = for_scope;
 
   outer_loop->Initialize(NULL, NULL, NULL, inner_block);
   return outer_block;
 }
 
 
+ZoneList<Statement*>* Parser::DesugarInitializeParameters(
+    Scope* scope, bool has_initializers, ZoneList<Expression*>* initializers) {
+  DCHECK(scope->is_function_scope());
+

[arv (Not doing code reviews), 2015/05/06 20:32:38]

How about adding a comment block explaining how the desugaring is done?

+  if (has_initializers) {
+    ShadowParametersForExpressions(scope);
+    ZoneList<Statement*>* body = new (zone()) ZoneList<Statement*>(0, zone());
+    for (int i = 0; i < initializers->length(); ++i) {
+      Expression* initializer = initializers->at(i);
+
+      // Position of parameter VariableProxy, for hole-checking
+      int pos = scope->parameter_position(i);
+
+      // Lexically declare the initialized variable
+      static const VariableMode mode = LET;
+      VariableProxy* proxy =
+          NewUnresolved(scope->parameter(i)->raw_name(), mode);
+      VariableDeclaration* declaration = factory()->NewVariableDeclaration(
+          proxy, mode, scope, RelocInfo::kNoPosition);
+      bool ok = true;
+      proxy = factory()->NewVariableProxy(Declare(declaration, true, &ok), pos);
+      DCHECK(ok);
+      proxy->var()->set_maybe_assigned();
+
+      const AstRawString* fn_name = ast_value_factory()->empty_string();
+      const Runtime::Function* arguments =
+          Runtime::FunctionForId(Runtime::kInlineArguments);

[arv (Not doing code reviews), 2015/05/06 20:32:38]

I think Andreas wanted:

function f(x = expr) {}

to be desugared to:

function f(temp) {
  let x = IS_UNDEFINED(temp) ? expr : temp;
}

If you use %_Arguments(i), do you also need to check the number of arguments so
you do not index out of bounds?

[caitp (gmail), 2015/05/06 20:42:55]

I don't think bounds-checking is needed --- at least in testing, `(function(x =
1, y = 2) { return x + y; })();` works just fine. Maybe that becomes an issue
with the adapter frame issue

+      ZoneList<Expression*>* arguments_i0 =
+          new (zone()) ZoneList<Expression*>(0, zone());
+      arguments_i0->Add(factory()->NewSmiLiteral(i, RelocInfo::kNoPosition),
+                        zone());
+
+      // TODO(caitp): ensure proper TDZ behaviour --- need hole-check for
+      // all parameter bindings, including ones without initializers
+      if (initializer) {
+        // IS_UNDEFINED(%_Arguments(i)) ? <initializer> : %_Arguments(i);
+        ZoneList<Expression*>* arguments_i1 =
+            new (zone()) ZoneList<Expression*>(0, zone());
+        arguments_i1->Add(factory()->NewSmiLiteral(i, RelocInfo::kNoPosition),
+                          zone());
+
+        Expression* arg_or_default = factory()->NewConditional(
+            // condition:
+            factory()->NewCompareOperation(
+                Token::EQ_STRICT,
+                factory()->NewCallRuntime(fn_name, arguments, arguments_i0,
+                                          RelocInfo::kNoPosition),
+                factory()->NewUndefinedLiteral(RelocInfo::kNoPosition),
+                RelocInfo::kNoPosition),
+            // if true:
+            initializer,
+            // if false:
+            factory()->NewCallRuntime(fn_name, arguments, arguments_i1,
+                                      RelocInfo::kNoPosition),
+            RelocInfo::kNoPosition);
+
+        Expression* assign = factory()->NewAssignment(
+            Token::INIT_LET, proxy, arg_or_default, RelocInfo::kNoPosition);
+
+        body->Add(
+            factory()->NewExpressionStatement(assign, RelocInfo::kNoPosition),
+            zone());
+        proxy->var()->set_initializer_position(initializer->position());
+      } else {
+        // let <name> = %_Arguments(i)
+        Expression* assign = factory()->NewAssignment(
+            Token::INIT_LET, proxy,
+            factory()->NewCallRuntime(fn_name, arguments, arguments_i0,
+                                      RelocInfo::kNoPosition),
+            RelocInfo::kNoPosition);
+        body->Add(
+            factory()->NewExpressionStatement(assign, RelocInfo::kNoPosition),
+            zone());
+        proxy->var()->set_initializer_position(pos);
+      }
+    }
+    return body;
+  } else {

[arv (Not doing code reviews), 2015/05/06 20:32:38]

no else after return

+    // If hasParameterExpressions is false, remove the unnecessary parameter
+    // block scopes.
+    ZoneList<Scope*>* scopes = scope->inner_scopes();
+    for (int i = 0; i < scopes->length(); ++i) {
+      Scope* scope = scopes->at(i);
+      DCHECK(scope->is_block_scope());
+      scope->FinalizeBlockScope();
+    }
+    return nullptr;
+  }
+}
+
+
 Statement* Parser::ParseForStatement(ZoneList<const AstRawString*>* labels,
                                      bool* ok) {
   // ForStatement ::
   //   'for' '(' Expression? ';' Expression? ';' Expression? ')' Statement
 
   int stmt_pos = peek_position();
   bool is_const = false;
   Statement* init = NULL;
   ZoneList<const AstRawString*> lexical_bindings(1, zone());
 
@@ skipping 390 matching lines @@
     error_locs->reserved = param_location;
   if (!error_locs->undefined.IsValid() && IsUndefined(raw_name))
     error_locs->undefined = param_location;
 
   // When the formal parameter was originally seen, it was parsed as a
   // VariableProxy and recorded as unresolved in the scope.  Here we undo that
   // parse-time side-effect.
   parser_->scope_->RemoveUnresolved(expr->AsVariableProxy());
 
   bool is_rest = false;
-  bool is_duplicate = DeclareFormalParameter(scope, raw_name, is_rest);
+  int pos = expr->position();
+  bool is_duplicate = DeclareFormalParameter(scope, raw_name, is_rest, pos);
 
   if (is_duplicate) {
     // Arrow function parameter lists are parsed as StrictFormalParameters,
     // which means that they cannot have duplicates.  Note that this is a subset
     // of the restrictions placed on parameters to functions whose body is
     // strict.
     ReportMessageAt(param_location,
                     "duplicate_arrow_function_formal_parameter");
     *ok = false;
     return;
@@ skipping 108 matching lines @@
       // expressions. This also marks the FunctionState as a generator.
       Variable* temp = scope_->DeclarationScope()->NewTemporary(
           ast_value_factory()->dot_generator_object_string());
       function_state.set_generator_object_variable(temp);
     }
 
     bool has_rest = false;
     Expect(Token::LPAREN, CHECK_OK);
     int start_position = scanner()->location().beg_pos;
     scope_->set_start_position(start_position);
+    ZoneList<Expression*>* initializers =
+        new (zone()) ZoneList<Expression*>(0, zone());
+    bool has_initializers = false;
     num_parameters =
-        ParseFormalParameterList(scope, &error_locs, &has_rest, CHECK_OK);
+        ParseFormalParameterList(scope, &error_locs, initializers,
+                                 &has_initializers, &has_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);
 
     Expect(Token::LBRACE, CHECK_OK);
 
     // If we have a named function expression, we add a local variable
     // declaration to the body of the function with the name of the
@@ skipping 58 matching lines @@
     parenthesized_function_ = false;  // The bit was set for this function only.
 
     if (is_lazily_parsed) {
       for (Scope* s = scope_->outer_scope();
            s != nullptr && (s != s->DeclarationScope()); s = s->outer_scope()) {
         s->ForceContextAllocation();
       }
       SkipLazyFunctionBody(&materialized_literal_count,
                            &expected_property_count, CHECK_OK);
     } else {
-      body = ParseEagerFunctionBody(function_name, pos, fvar, fvar_init_op,
-                                    kind, CHECK_OK);
+      body = DesugarInitializeParameters(scope, has_initializers, initializers);
+      if (has_initializers) {
+        // TODO(caitp): Function body scope must be a declaration scope
+        Scope* function_body_scope = NewScope(scope, BLOCK_SCOPE);
+        function_body_scope->set_start_position(scope->start_position());
+        function_body_scope->SetScopeName(function_name);
+        BlockState function_body_state(&scope_, function_body_scope);
+        ZoneList<Statement*>* inner_body = ParseEagerFunctionBody(
+            function_name, pos, fvar, fvar_init_op, kind, CHECK_OK);
+        scope->set_end_position(function_body_scope->end_position());
+        body->AddAll(*inner_body, zone());
+      } else {
+        body = ParseEagerFunctionBody(function_name, pos, fvar, fvar_init_op,
+                                      kind, CHECK_OK);
+      }
       materialized_literal_count = function_state.materialized_literal_count();
       expected_property_count = function_state.expected_property_count();
       handler_count = function_state.handler_count();
 
       if (is_strong(language_mode()) && IsSubclassConstructor(kind)) {
         if (!function_state.super_location().IsValid()) {
           ReportMessageAt(function_name_location,
                           "strong_super_call_missing", kReferenceError);
           *ok = false;
           return nullptr;
@@ skipping 1735 matching lines @@
 
 Expression* Parser::SpreadCallNew(Expression* function,
                                   ZoneList<v8::internal::Expression*>* args,
                                   int pos) {
   args->InsertAt(0, function, zone());
 
   return factory()->NewCallRuntime(
       ast_value_factory()->reflect_construct_string(), NULL, args, pos);
 }
 } }  // namespace v8::internal