[es6] implement default/optional parameters (WIP / comments)

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 355 matching lines @@
           Runtime::FunctionForId(Runtime::kInlineDefaultConstructorCallSuper),
           args, pos);
       body->Add(factory()->NewReturnStatement(call, pos), zone());
     }
 
     materialized_literal_count = function_state.materialized_literal_count();
     expected_property_count = function_state.expected_property_count();
     handler_count = function_state.handler_count();
   }
 
+  ZoneList<Expression*>* default_values =
+      new (zone()) ZoneList<Expression*>(0, zone());
   FunctionLiteral* function_literal = factory()->NewFunctionLiteral(
       name, ast_value_factory(), function_scope, body,
       materialized_literal_count, expected_property_count, handler_count,
-      parameter_count, FunctionLiteral::kNoDuplicateParameters,
+      parameter_count, default_values, FunctionLiteral::kNoDuplicateParameters,
       FunctionLiteral::ANONYMOUS_EXPRESSION, FunctionLiteral::kIsFunction,
       FunctionLiteral::kNotParenthesized, kind, pos);
 
   return function_literal;
 }
 
 
 // ----------------------------------------------------------------------------
 // Target is a support class to facilitate manipulation of the
 // Parser's target_stack_ (the stack of potential 'break' and
@@ skipping 639 matching lines @@
       if (body->length() != 1 ||
           !body->at(0)->IsExpressionStatement() ||
           !body->at(0)->AsExpressionStatement()->
               expression()->IsFunctionLiteral()) {
         ReportMessage("single_function_literal");
         ok = false;
       }
     }
 
     if (ok) {
+      ZoneList<Expression*>* default_values =
+          new (zone()) ZoneList<Expression*>(0, zone());
       result = factory()->NewFunctionLiteral(
           ast_value_factory()->empty_string(), ast_value_factory(), scope_,
           body, function_state.materialized_literal_count(),
           function_state.expected_property_count(),
-          function_state.handler_count(), 0,
+          function_state.handler_count(), 0, default_values,
           FunctionLiteral::kNoDuplicateParameters,
           FunctionLiteral::ANONYMOUS_EXPRESSION, FunctionLiteral::kGlobalOrEval,
           FunctionLiteral::kNotParenthesized, FunctionKind::kNormalFunction, 0);
     }
   }
 
   // Make sure the target stack is empty.
   DCHECK(target_stack_ == NULL);
 
   return result;
@@ skipping 2779 matching lines @@
                      : NewScope(scope_, FUNCTION_SCOPE, kind);
   ZoneList<Statement*>* body = NULL;
   int materialized_literal_count = -1;
   int expected_property_count = -1;
   int handler_count = 0;
   FunctionLiteral::ParameterFlag duplicate_parameters =
       FunctionLiteral::kNoDuplicateParameters;
   FunctionLiteral::IsParenthesizedFlag parenthesized = parenthesized_function_
       ? FunctionLiteral::kIsParenthesized
       : FunctionLiteral::kNotParenthesized;
+
+  ZoneList<Expression*>* default_params = new (zone()) ZoneList<Expression*>(0, zone());
+
   // Parse function body.
   {
     AstNodeFactory function_factory(ast_value_factory());
     FunctionState function_state(&function_state_, &scope_, scope, kind,
                                  &function_factory);
     scope_->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
@@ skipping 19 matching lines @@
     Scanner::Location eval_args_error_loc = Scanner::Location::invalid();
     Scanner::Location dupe_error_loc = Scanner::Location::invalid();
     Scanner::Location reserved_error_loc = Scanner::Location::invalid();
 
     bool is_rest = false;
     bool done = arity_restriction == FunctionLiteral::GETTER_ARITY ||
         (peek() == Token::RPAREN &&
          arity_restriction != FunctionLiteral::SETTER_ARITY);
     while (!done) {
       bool is_strict_reserved = false;
-      is_rest = peek() == Token::ELLIPSIS && allow_harmony_rest_params();
-      if (is_rest) {
+      int rest_pos;
+
+      ParameterKind kind = ParameterKind::Normal;
+
+      if (peek() == Token::ELLIPSIS && allow_harmony_rest_params()) {
         Consume(Token::ELLIPSIS);
+        rest_pos = position();
+        kind = ParameterKind::Rest;
       }
 
       const AstRawString* param_name =
           ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
 
       // Store locations for possible future error reports.
       if (!eval_args_error_loc.IsValid() && IsEvalOrArguments(param_name)) {
         eval_args_error_loc = scanner()->location();
       }
       if (!reserved_error_loc.IsValid() && is_strict_reserved) {
         reserved_error_loc = scanner()->location();
       }
       if (!dupe_error_loc.IsValid() &&
           scope_->IsDeclaredParameter(param_name)) {
         duplicate_parameters = FunctionLiteral::kHasDuplicateParameters;
         dupe_error_loc = scanner()->location();
       }
 
-      Variable* var = scope_->DeclareParameter(param_name, VAR, is_rest);
+
+
+      if (peek() == Token::ASSIGN) {
+        // Default parameters:
+        Consume(Token::ASSIGN);
+        static const bool accept_IN = true;
+        Expression* defaultValue =
+            ParseAssignmentExpression(accept_IN, CHECK_OK);
+        if (kind.isRestParameter()) {
+          ReportMessageAt(
+              Scanner::Location(rest_pos, scanner()->location().end_pos),
+              "rest_param_default");
+          *ok = false;
+          return nullptr;
+        }
+        kind = ParameterKind::Optional;
+        default_params->Add(defaultValue, zone());
+      }
+
+      Variable* var = scope_->DeclareParameter(param_name, VAR, kind);
+
       if (is_sloppy(scope->language_mode())) {
         // TODO(sigurds) Mark every parameter as maybe assigned. This is a
         // conservative approximation necessary to account for parameters
         // that are assigned via the arguments array.
         var->set_maybe_assigned();
       }
 
       num_parameters++;
       if (num_parameters > Code::kMaxArguments) {
         ReportMessage("too_many_parameters");
@@ skipping 111 matching lines @@
                         kReferenceError);
         *ok = false;
         return nullptr;
       }
     }
   }
 
   FunctionLiteral* function_literal = factory()->NewFunctionLiteral(
       function_name, ast_value_factory(), scope, body,
       materialized_literal_count, expected_property_count, handler_count,
-      num_parameters, duplicate_parameters, function_type,
+      num_parameters, default_params, duplicate_parameters, function_type,
       FunctionLiteral::kIsFunction, parenthesized, kind, pos);
   function_literal->set_function_token_position(function_token_pos);
 
   if (scope->has_rest_parameter()) {
     // TODO(caitp): enable optimization of functions with rest params
     function_literal->set_dont_optimize_reason(kRestParameter);
   }
 
   if (fni_ != NULL && should_infer_name) fni_->AddFunction(function_literal);
   return function_literal;
@@ skipping 1689 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