Revert of [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 866 matching lines @@
   set_allow_harmony_classes(FLAG_harmony_classes);
   set_allow_harmony_object_literals(FLAG_harmony_object_literals);
   set_allow_harmony_sloppy(FLAG_harmony_sloppy);
   set_allow_harmony_unicode(FLAG_harmony_unicode);
   set_allow_harmony_computed_property_names(
       FLAG_harmony_computed_property_names);
   set_allow_harmony_rest_params(FLAG_harmony_rest_parameters);
   set_allow_harmony_spreadcalls(FLAG_harmony_spreadcalls);
   set_allow_harmony_destructuring(FLAG_harmony_destructuring);
   set_allow_harmony_spread_arrays(FLAG_harmony_spread_arrays);
-  set_allow_harmony_default_parameters(FLAG_harmony_default_parameters);
   set_allow_strong_mode(FLAG_strong_mode);
   for (int feature = 0; feature < v8::Isolate::kUseCounterFeatureCount;
        ++feature) {
     use_counts_[feature] = 0;
   }
   if (info->ast_value_factory() == NULL) {
     // info takes ownership of AstValueFactory.
     info->set_ast_value_factory(new AstValueFactory(zone(), info->hash_seed()));
     info->set_ast_value_factory_owned();
     ast_value_factory_ = info->ast_value_factory();
@@ skipping 244 matching lines @@
               : FunctionLiteral::NAMED_EXPRESSION)
         : FunctionLiteral::DECLARATION;
     bool ok = true;
 
     if (shared_info->is_arrow()) {
       Scope* scope =
           NewScope(scope_, ARROW_SCOPE, FunctionKind::kArrowFunction);
       scope->set_start_position(shared_info->start_position());
       ExpressionClassifier formals_classifier;
       bool has_rest = false;
-      bool has_parameter_expressions = false;
-
-      // TODO(caitp): make default parameters work in arrow functions
-      ZoneList<Expression*>* initializers =
-          new (zone()) ZoneList<Expression*>(0, zone());
       if (Check(Token::LPAREN)) {
         // '(' StrictFormalParameters ')'
-        ParseFormalParameterList(scope, initializers,
-                                 &has_parameter_expressions, &has_rest,
-                                 &formals_classifier, &ok);
+        ParseFormalParameterList(scope, &has_rest, &formals_classifier, &ok);
         if (ok) ok = Check(Token::RPAREN);
       } else {
         // BindingIdentifier
         ParseFormalParameter(scope, has_rest, &formals_classifier, &ok);
       }
 
       if (ok) {
         Expression* expression =
             ParseArrowFunctionLiteral(scope, has_rest, formals_classifier, &ok);
         if (ok) {
@@ skipping 2233 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_parameter_expressions,
-    ZoneList<Expression*>* initializers) {
-  DCHECK(scope->is_function_scope());
-
-  if (has_parameter_expressions) {
-    // If has_parameter_expressions for the function is true, each parameter is
-    // desugared as follows:
-    //
-    // SingleNameBinding :
-    //   let <name> = %_Arguments(<index>);
-    // SingleNameBinding Initializer
-    //   let <name> = IS_UNDEFINED(%_Arguments(<index>)) ? <initializer>
-    //                                                   : %_Arguments(<index>);
-    //
-    // TODO(caitp, dslomov): support BindingPatterns & rest parameters
-    //
-    scope->UndeclareParametersForExpressions();
-    ZoneList<Statement*>* body =
-        new (zone()) ZoneList<Statement*>(initializers->length(), 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);
-
-      static const int kCapacity = 1;
-      static const bool kIsInitializerBlock = true;
-      Block* param_block =
-          factory()->NewBlock(nullptr, kCapacity, kIsInitializerBlock, pos);
-
-      VariableProxy* proxy =
-          NewUnresolved(scope->parameter(i)->raw_name(), LET);
-      VariableDeclaration* declaration = factory()->NewVariableDeclaration(
-          proxy, LET, scope, RelocInfo::kNoPosition);
-
-      bool ok = true;
-      // All formal parameters have been removed from the scope VariableMap,
-      // and so Declare() should not be able to fail.
-      proxy = factory()->NewVariableProxy(Declare(declaration, true, &ok), pos);
-      DCHECK(ok);
-
-      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*>(1, zone());
-      arguments_i0->Add(factory()->NewSmiLiteral(i, RelocInfo::kNoPosition),
-                        zone());
-
-      if (initializer == nullptr) {
-        // let <name> = %_Arguments(i)
-        Expression* assign = factory()->NewAssignment(
-            Token::INIT_LET, proxy,
-            factory()->NewCallRuntime(fn_name, arguments, arguments_i0,
-                                      RelocInfo::kNoPosition),
-            RelocInfo::kNoPosition);
-        param_block->AddStatement(
-            factory()->NewExpressionStatement(assign, RelocInfo::kNoPosition),
-            zone());
-        proxy->var()->set_initializer_position(pos);
-      } else {
-        // IS_UNDEFINED(%_Arguments(i)) ? <initializer> : %_Arguments(i);
-        ZoneList<Expression*>* arguments_i1 =
-            new (zone()) ZoneList<Expression*>(1, 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);
-
-        param_block->AddStatement(
-            factory()->NewExpressionStatement(assign, RelocInfo::kNoPosition),
-            zone());
-        proxy->var()->set_initializer_position(initializer->position());
-      }
-      body->Add(param_block, zone());
-    }
-    return body;
-  } else {
-    // If has_parameter_expressions 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 350 matching lines @@
   const AstRawString* raw_name = expr->AsVariableProxy()->raw_name();
   Scanner::Location param_location(expr->position(),
                                    expr->position() + raw_name->length());
 
   // 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;
-  int pos = expr->position();
-  bool is_duplicate = DeclareFormalParameter(scope, raw_name, is_rest, pos);
+  bool is_duplicate = DeclareFormalParameter(scope, raw_name, is_rest);
 
   if (is_duplicate && !duplicate_loc->IsValid()) {
     *duplicate_loc = param_location;
   }
 }
 
 
 void ParserTraits::ParseArrowFunctionFormalParameters(
     Scope* scope, Expression* params, const Scanner::Location& params_loc,
     bool* is_rest, Scanner::Location* duplicate_loc, bool* ok) {
@@ skipping 90 matching lines @@
 
       // 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;
-    bool has_parameter_expressions = 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());
-    num_parameters = ParseFormalParameterList(
-        scope, initializers, &has_parameter_expressions, &has_rest,
-        &formals_classifier, CHECK_OK);
+    num_parameters = ParseFormalParameterList(scope, &has_rest,
+                                              &formals_classifier, CHECK_OK);
     Expect(Token::RPAREN, CHECK_OK);
     int formals_end_position = scanner()->location().end_pos;
 
     CheckArityRestrictions(num_parameters, arity_restriction, has_rest,
                            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 80 matching lines @@
         is_lazily_parsed = false;
 
         // This is probably an initialization function. Inform the compiler it
         // should also eager-compile this function, and that we expect it to be
         // used once.
         eager_compile_hint = FunctionLiteral::kShouldEagerCompile;
         should_be_used_once_hint = true;
       }
     }
     if (!is_lazily_parsed) {
-      body = DesugarInitializeParameters(scope, has_parameter_expressions,
-                                         initializers);
-      if (has_parameter_expressions) {
-        // 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);
-
-        // Declare Block node
-        Block* block =
-            factory()->NewBlock(nullptr, inner_body->length(), false, pos);
-        block->set_scope(function_body_scope);
-        for (int i = 0; i < inner_body->length(); ++i) {
-          block->AddStatement(inner_body->at(i), zone());
-        }
-
-        scope->set_end_position(function_body_scope->end_position());
-        body->Add(block, zone());
-      } else {
-        body = ParseEagerFunctionBody(function_name, pos, fvar, fvar_init_op,
-                                      kind, CHECK_OK);
-      }
+      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,
                           MessageTemplate::kStrongSuperCallMissing,
                           kReferenceError);
           *ok = false;
@@ skipping 263 matching lines @@
     reusable_preparser_->set_allow_harmony_computed_property_names(
         allow_harmony_computed_property_names());
     reusable_preparser_->set_allow_harmony_rest_params(
         allow_harmony_rest_params());
     reusable_preparser_->set_allow_harmony_spreadcalls(
         allow_harmony_spreadcalls());
     reusable_preparser_->set_allow_harmony_destructuring(
         allow_harmony_destructuring());
     reusable_preparser_->set_allow_harmony_spread_arrays(
         allow_harmony_spread_arrays());
-    reusable_preparser_->set_allow_harmony_default_parameters(
-        allow_harmony_default_parameters());
     reusable_preparser_->set_allow_strong_mode(allow_strong_mode());
   }
   PreParser::PreParseResult result = reusable_preparser_->PreParseLazyFunction(
       language_mode(), function_state_->kind(), logger, bookmark);
   if (pre_parse_timer_ != NULL) {
     pre_parse_timer_->Stop();
   }
   return result;
 }
 
@@ skipping 1502 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