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

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 764 matching lines @@
   // truly local variable, and the scope of the variable is always the function
   // scope.
   // Let/const variables in harmony mode are always added to the immediately
   // enclosing scope.
   return DeclarationScope(mode)->NewUnresolved(factory(), name,
                                                scanner()->location().beg_pos,
                                                scanner()->location().end_pos);
 }
 
 
-Variable* Parser::Declare(Declaration* declaration, bool resolve, bool* ok) {
+Variable* Parser::Declare(Declaration* declaration, bool resolve,
+                          bool allow_redeclaration, bool* ok) {
   VariableProxy* proxy = declaration->proxy();
   DCHECK(proxy->raw_name() != NULL);
   const AstRawString* name = proxy->raw_name();
   VariableMode mode = declaration->mode();
   Scope* declaration_scope = DeclarationScope(mode);
   Variable* var = NULL;
 
   // If a suitable scope exists, then we can statically declare this
   // variable and also set its mode. In any case, a Declaration node
   // will be added to the scope so that the declaration can be added
   // to the corresponding activation frame at runtime if necessary.
   // For instance declarations inside an eval scope need to be added
   // to the calling function context.
   // Similarly, strict mode eval scope does not leak variable declarations to
   // the caller's scope so we declare all locals, too.
   if (declaration_scope->is_function_scope() ||
       declaration_scope->is_strict_eval_scope() ||
       declaration_scope->is_block_scope() ||
       declaration_scope->is_module_scope() ||
       declaration_scope->is_script_scope()) {
     // Declare the variable in the declaration scope.
     var = declaration_scope->LookupLocal(name);
-    if (var == NULL) {
+    if (var == NULL || allow_redeclaration) {
       // Declare the name.
       Variable::Kind kind = Variable::NORMAL;
       int declaration_group_start = -1;
       if (declaration->IsFunctionDeclaration()) {
         kind = Variable::FUNCTION;
       } else if (declaration->IsVariableDeclaration() &&
                  declaration->AsVariableDeclaration()->is_class_declaration()) {
         kind = Variable::CLASS;
         declaration_group_start =
             declaration->AsVariableDeclaration()->declaration_group_start();
       }
-      var = declaration_scope->DeclareLocal(
-          name, mode, declaration->initialization(), kind, kNotAssigned,
-          declaration_group_start);
+      if (var) {
+        DCHECK(declaration_scope->IsDeclaredParameter(name));
+        var = declaration_scope->RedeclareLocal(
+            name, mode, declaration->initialization(), kind, kNotAssigned,
+            declaration_group_start);
+      } else {
+        var = declaration_scope->DeclareLocal(
+            name, mode, declaration->initialization(), kind, kNotAssigned,
+            declaration_group_start);
+      }
     } else if (IsLexicalVariableMode(mode) ||
                IsLexicalVariableMode(var->mode()) ||
                ((mode == CONST_LEGACY || var->mode() == CONST_LEGACY) &&
                 !declaration_scope->is_script_scope())) {
       // The name was declared in this scope before; check for conflicting
       // re-declarations. We have a conflict if either of the declarations is
       // not a var (in script scope, we also have to ignore legacy const for
       // compatibility). There is similar code in runtime.cc in the Declare
       // functions. The function CheckConflictingVarDeclarations checks for
       // var and let bindings from different scopes whereas this is a check for
@@ skipping 1947 matching lines @@
     error_locs->eval_or_arguments = param_location;
   if (!error_locs->reserved.IsValid() && IsFutureStrictReserved(raw_name))
     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());
-
+  int pos = expr->AsVariableProxy()->position();
   bool is_rest = false;
-  bool is_duplicate = DeclareFormalParameter(scope, raw_name, is_rest);
+  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 10 matching lines @@
     // TODO(wingo): Make a better message.
     ReportMessageAt(params_loc, "malformed_arrow_function_parameter_list");
     *ok = false;
     return;
   }
 
   DeclareArrowFunctionParameters(scope, params, params_loc, error_locs, ok);
 }
 
 
+ZoneList<Statement*>* Parser::DesugarInitializeParameters(
+    Scope* scope, bool has_initializers, ZoneList<Expression*>* initializers) {
+  DCHECK(scope->is_function_scope());
+
+  ZoneList<Statement*>* body = new (zone()) ZoneList<Statement*>(0, zone());
+  if (has_initializers) {
+    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);
+      // BRITTLE: this illegally redeclares the variable, be careful about this
+      proxy =
+          factory()->NewVariableProxy(Declare(declaration, true, true), pos);
+      proxy->var()->set_maybe_assigned();
+
+      const AstRawString* fn_name = ast_value_factory()->empty_string();
+      const Runtime::Function* arguments =
+          Runtime::FunctionForId(Runtime::kInlineArguments);
+      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);
+      }
+    }
+  } else {
+    // If hasParameterExpressions is false, remove the unnecessary parameter
+    // block scopes. The function body scope can't be safely removed at this
+    // point.
+    ZoneList<Scope*>* scopes = scope->inner_scopes();
+    for (int i = 0; i < scopes->length(); ++i) {
+      Scope* scope = scopes->at(i);
+      if (!scope->is_function_body_scope()) {
+        DCHECK(scope->is_block_scope());
+        scope->FinalizeBlockScope();
+      }
+    }
+  }
+  return body;
+}
+
+
 FunctionLiteral* Parser::ParseFunctionLiteral(
     const AstRawString* 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 '}'
   //
   // Getter ::
   //   '(' ')' '{' FunctionBody '}'
@@ skipping 45 matching lines @@
   //   compiling a function in an inner declaration scope in the eval, e.g. a
   //   nested function, and hoisting works normally relative to that.
   Scope* declaration_scope = scope_->DeclarationScope();
   Scope* original_declaration_scope = original_scope_->DeclarationScope();
   Scope* scope = function_type == FunctionLiteral::DECLARATION &&
                          is_sloppy(language_mode()) &&
                          (original_scope_ == original_declaration_scope ||
                           declaration_scope != original_declaration_scope)
                      ? NewScope(declaration_scope, FUNCTION_SCOPE, kind)
                      : NewScope(scope_, FUNCTION_SCOPE, kind);
+  Scope* function_body = NewScope(scope, FUNCTION_BODY_SCOPE);
+  DCHECK_EQ(scope->function_body(), function_body);
   ZoneList<Statement*>* body = NULL;
   int materialized_literal_count = -1;
   int expected_property_count = -1;
   int handler_count = 0;
   FormalParameterErrorLocations error_locs;
   FunctionLiteral::EagerCompileHint eager_compile_hint =
       parenthesized_function_ ? FunctionLiteral::kShouldEagerCompile
                               : FunctionLiteral::kShouldLazyCompile;
   // Parse function body.
   {
     AstNodeFactory function_factory(ast_value_factory());
     FunctionState function_state(&function_state_, &scope_, scope, kind,
                                  &function_factory);
     scope_->SetScopeName(function_name);
+    function_body->SetScopeName(function_name);
 
     if (is_generator) {
       // For generators, allocating variables in contexts is currently a win
       // because it minimizes the work needed to suspend and resume an
       // activation.
       scope_->ForceContextAllocation();
 
       // Calling a generator returns a generator object.  That object is stored
       // in a temporary variable, a definition that is used by "yield"
       // 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);
+    function_body->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
     // function and let it refer to the function itself (closure).
     // NOTE: We create a proxy and resolve it here so that in the
     // future we can change the AST to only refer to VariableProxies
     // instead of Variables and Proxis as is the case now.
     Variable* fvar = NULL;
     Token::Value fvar_init_op = Token::INIT_CONST_LEGACY;
     if (function_type == FunctionLiteral::NAMED_EXPRESSION) {
       if (is_strict(language_mode())) {
         fvar_init_op = Token::INIT_CONST;
       }
       VariableMode fvar_mode =
           is_strict(language_mode()) ? CONST : CONST_LEGACY;
       DCHECK(function_name != NULL);
       fvar = new (zone())
           Variable(scope_, function_name, fvar_mode, Variable::NORMAL,
                    kCreatedInitialized, kNotAssigned);
       VariableProxy* proxy = factory()->NewVariableProxy(fvar);
       VariableDeclaration* fvar_declaration = factory()->NewVariableDeclaration(
           proxy, fvar_mode, scope_, RelocInfo::kNoPosition);
+      DCHECK(scope_->is_function_scope());
       scope_->DeclareFunctionVar(fvar_declaration);
     }
 
     // Determine if the function can be parsed lazily. Lazy parsing is different
     // from lazy compilation; we need to parse more eagerly than we compile.
 
     // We can only parse lazily if we also compile lazily. The heuristics for
     // lazy compilation are:
     // - It must not have been prohibited by the caller to Parse (some callers
     //   need a full AST).
@@ skipping 21 matching lines @@
     // possible reference to the variable in foo's scope. However, it's possible
     // that it will be compiled lazily.
 
     // To make this additional case work, both Parser and PreParser implement a
     // logic where only top-level functions will be parsed lazily.
     bool is_lazily_parsed = (mode() == PARSE_LAZILY &&
                              scope_->AllowsLazyCompilation() &&
                              !parenthesized_function_);
     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();
+    {
+      // Use the FUNCTION_BODY scope only if it's needed
+      // TODO(caitp): This is needed when ObjectBindingPatterns with
+      // computed property keys are used as well.
+      Scope* func_scope = has_initializers ? function_body : scope_;
+      if (func_scope != function_body) {
+        function_body->FinalizeBlockScope();
       }
-      SkipLazyFunctionBody(&materialized_literal_count,
-                           &expected_property_count, CHECK_OK);
-    } 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;
+      if (is_lazily_parsed) {
+        for (Scope* s = scope_->outer_scope();
+             s != nullptr && (s != s->DeclarationScope());
+             s = s->outer_scope()) {
+          s->ForceContextAllocation();
+        }
+        {
+          BlockState function_body_state(&scope_, func_scope);
+          SkipLazyFunctionBody(&materialized_literal_count,
+                               &expected_property_count, CHECK_OK);
+        }
+      } else {
+        body =
+            DesugarInitializeParameters(scope, has_initializers, initializers);
+        {
+          BlockState function_body_state(&scope_, func_scope);
+          ZoneList<Statement*>* inner_body = ParseEagerFunctionBody(
+              function_name, pos, fvar, fvar_init_op, kind, CHECK_OK);
+          body->AddAll(*inner_body, zone());
+        }
+        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;
+          }
         }
       }
     }
 
     // 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 = has_rest || IsConciseMethod(kind);
@@ skipping 71 matching lines @@
     return;
   }
   if (logger.has_error()) {
     ParserTraits::ReportMessageAt(
         Scanner::Location(logger.start(), logger.end()), logger.message(),
         logger.argument_opt(), logger.error_type());
     *ok = false;
     return;
   }
   scope_->set_end_position(logger.end());
+  if (scope_->is_function_body_scope()) {
+    DCHECK(scope_->outer_scope()->is_function_scope());
+    scope_->outer_scope()->set_end_position(scanner()->location().end_pos);
+  }
   Expect(Token::RBRACE, ok);
   if (!*ok) {
     return;
   }
   total_preparse_skipped_ += scope_->end_position() - function_block_pos;
   *materialized_literal_count = logger.literals();
   *expected_property_count = logger.properties();
   scope_->SetLanguageMode(logger.language_mode());
   if (logger.scope_uses_super_property()) {
     scope_->RecordSuperPropertyUsage();
@@ skipping 88 matching lines @@
   if (IsSubclassConstructor(kind)) {
     body->Add(
         factory()->NewReturnStatement(
             this->ThisExpression(scope_, factory(), RelocInfo::kNoPosition),
             RelocInfo::kNoPosition),
         zone());
   }
 
   Expect(Token::RBRACE, CHECK_OK);
   scope_->set_end_position(scanner()->location().end_pos);
+  if (scope_->is_function_body_scope()) {
+    DCHECK(scope_->outer_scope()->is_function_scope());
+    scope_->outer_scope()->set_end_position(scanner()->location().end_pos);
+  }
 
   return body;
 }
 
 
 PreParser::PreParseResult Parser::ParseLazyFunctionBodyWithPreParser(
     SingletonLogger* logger) {
   // This function may be called on a background thread too; record only the
   // main thread preparse times.
   if (pre_parse_timer_ != NULL) {
@@ skipping 1526 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