[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 642 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 2773 matching lines @@
   // - (1) is the case iff the innermost scope of the deserialized scope chain
   //   under which we compile is _not_ a declaration scope. This holds because
   //   in all normal cases, function declarations are fully hoisted to a
   //   declaration scope and compiled relative to that.
   // - (2) is the case iff the current declaration scope is still the original
   //   one relative to the deserialized scope chain. Otherwise we must be
   //   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 &&
+  Scope* env_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);
+                     ? declaration_scope
+                     : scope_;
+  // A separate Environment Record is needed to ensure that closures created by
+  // expressions in the formal parameter list do not have visibility of
+  // declarations in the function body.
+  Scope* param_expressions_scope = NewScope(env_scope, BLOCK_SCOPE);
+
+  Scope* scope = NewScope(env_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*>* param_initializers =
+      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);
+    param_expressions_scope->SetParameterExpressionsScopeFor(scope_);
 
     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.
@@ skipping 16 matching lines @@
 
     // Similarly for strong mode.
     Scanner::Location undefined_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 = NormalParameter;
+
+      if (peek() == Token::ELLIPSIS && allow_harmony_rest_params()) {
         Consume(Token::ELLIPSIS);
+        rest_pos = position();
+        kind = RestParameter;
       }
 
       const AstRawString* param_name =
           ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
 
       // Store locations for possible future error reports.
       if (!eval_args_loc.IsValid() && IsEvalOrArguments(param_name)) {
         eval_args_loc = scanner()->location();
       }
       if (!undefined_loc.IsValid() && IsUndefined(param_name)) {
         undefined_loc = scanner()->location();
       }
       if (!reserved_loc.IsValid() && is_strict_reserved) {
         reserved_loc = scanner()->location();
       }
       if (!dupe_loc.IsValid() &&
           scope_->IsDeclaredParameter(param_name)) {
         duplicate_parameters = FunctionLiteral::kHasDuplicateParameters;
         dupe_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 = nullptr;
+        {
+          // Evaluate parameter initializations within context of separate scope
+          BlockState state(&scope_, param_expressions_scope);
+          defaultValue = ParseAssignmentExpression(accept_IN, CHECK_OK);
+        }
+        if (kind == RestParameter) {
+          ReportMessageAt(
+              Scanner::Location(rest_pos, scanner()->location().end_pos),
+              "rest_param_default");
+          *ok = false;
+          return nullptr;
+        }
+        kind = OptionalParameter;
+        param_initializers->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, param_initializers, 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 1695 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