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

src/preparser.h

 // 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.
 
 #ifndef V8_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/v8.h"
 
 #include "src/bailout-reason.h"
@@ skipping 66 matching lines @@
 //     typedef Factory;
 //   };
 //   // ...
 // };
 
 template <typename Traits>
 class ParserBase : public Traits {
  public:
   // Shorten type names defined by Traits.
   typedef typename Traits::Type::Expression ExpressionT;
+  typedef typename Traits::Type::ExpressionList ExpressionListT;
   typedef typename Traits::Type::Identifier IdentifierT;
   typedef typename Traits::Type::FormalParameter FormalParameterT;
   typedef typename Traits::Type::FormalParameterScope FormalParameterScopeT;
   typedef typename Traits::Type::FunctionLiteral FunctionLiteralT;
   typedef typename Traits::Type::Literal LiteralT;
   typedef typename Traits::Type::ObjectLiteralProperty ObjectLiteralPropertyT;
 
   ParserBase(Zone* zone, Scanner* scanner, uintptr_t stack_limit,
              v8::Extension* extension, AstValueFactory* ast_value_factory,
              ParserRecorder* log, typename Traits::Type::Parser this_object)
@@ skipping 590 matching lines @@
                                    ExpressionClassifier* classifier, bool* ok);
   void AddTemplateExpression(ExpressionT);
   ExpressionT ParseSuperExpression(bool is_new,
                                    ExpressionClassifier* classifier, bool* ok);
   ExpressionT ParseStrongInitializationExpression(
       ExpressionClassifier* classifier, bool* ok);
   ExpressionT ParseStrongSuperCallExpression(ExpressionClassifier* classifier,
                                              bool* ok);
 
   void ParseFormalParameter(FormalParameterScopeT* scope,
-                            FormalParameterErrorLocations* locs, bool is_rest,
+                            Scope* initializer_scope,
+                            FormalParameterErrorLocations* locs,
+                            ExpressionT* initializer,
+                            bool* has_initializer, bool is_rest,
                             bool* ok);
   int ParseFormalParameterList(FormalParameterScopeT* scope,
+                               Scope* initializer_scope,
                                FormalParameterErrorLocations* locs,
+                               ExpressionListT initializers,
+                               bool* has_initializers,
                                bool* has_rest, bool* ok);
   void CheckArityRestrictions(
       int param_count, FunctionLiteral::ArityRestriction arity_restriction,
       int formals_start_pos, int formals_end_pos, bool* ok);
 
   // Checks if the expression is a valid reference expression (e.g., on the
   // left-hand side of assignments). Although ruled out by ECMA as early errors,
   // we allow calls for web compatibility and rewrite them to a runtime throw.
   ExpressionT CheckAndRewriteReferenceExpression(
       ExpressionT expression,
@@ skipping 2625 matching lines @@
         return expression;
     }
   }
   DCHECK(false);
   return this->EmptyExpression();
 }
 
 
 template <class Traits>
 void ParserBase<Traits>::ParseFormalParameter(
-    FormalParameterScopeT* scope, FormalParameterErrorLocations* locs,
-    bool is_rest, bool* ok) {
+    FormalParameterScopeT* scope, Scope* parameter_scope,
+    FormalParameterErrorLocations* locs,
+    ExpressionT* initializer, bool* has_initializer, bool is_rest, bool* ok) {
   // FormalParameter[Yield,GeneratorParameter] :
   //   BindingElement[?Yield, ?GeneratorParameter]
   bool is_strict_reserved;
   IdentifierT name =
       ParseIdentifierOrStrictReservedWord(&is_strict_reserved, ok);
   if (!*ok) return;
 
+  if (parameter_scope && Check(Token::ASSIGN)) {
+    // Optional argument initializer
+    // let formalName = IS_UNDEFINED(arguments[i]) ? initializer : arguments[i];
+    BlockState state(&scope_, NewScope(parameter_scope, BLOCK_SCOPE));
+    static const bool accept_IN = true;
+    ExpressionClassifier classifier;
+    *initializer = ParseAssignmentExpression(accept_IN, &classifier, ok);
+    if (!*ok) return;
+    *has_initializer = true;
+  }
+
   // Store locations for possible future error reports.
   if (!locs->eval_or_arguments.IsValid() && this->IsEvalOrArguments(name)) {
     locs->eval_or_arguments = scanner()->location();
   }
   if (!locs->undefined.IsValid() && this->IsUndefined(name)) {
     locs->undefined = scanner()->location();
   }
   if (!locs->reserved.IsValid() && is_strict_reserved) {
     locs->reserved = scanner()->location();
   }
   bool was_declared = Traits::DeclareFormalParameter(scope, name, is_rest);
   if (!locs->duplicate.IsValid() && was_declared) {
     locs->duplicate = scanner()->location();
   }
 }
 
 
 template <class Traits>
 int ParserBase<Traits>::ParseFormalParameterList(
-    FormalParameterScopeT* scope, FormalParameterErrorLocations* locs,
-    bool* is_rest, bool* ok) {
+    FormalParameterScopeT* scope, Scope* parameter_scope,
+    FormalParameterErrorLocations* locs,
+    ExpressionListT initializers, bool* has_initializers, bool* is_rest,
+    bool* ok) {
   // FormalParameters[Yield,GeneratorParameter] :
   //   [empty]
   //   FormalParameterList[?Yield, ?GeneratorParameter]
   //
   // FormalParameterList[Yield,GeneratorParameter] :
   //   FunctionRestParameter[?Yield]
   //   FormalsList[?Yield, ?GeneratorParameter]
   //   FormalsList[?Yield, ?GeneratorParameter] , FunctionRestParameter[?Yield]
   //
   // FormalsList[Yield,GeneratorParameter] :
   //   FormalParameter[?Yield, ?GeneratorParameter]
   //   FormalsList[?Yield, ?GeneratorParameter] ,
   //     FormalParameter[?Yield,?GeneratorParameter]
 
   int parameter_count = 0;
 
+  BlockState parameter_block(&scope_, parameter_scope);
+
   if (peek() != Token::RPAREN) {
     do {
       if (++parameter_count > Code::kMaxArguments) {
         ReportMessage("too_many_parameters");
         *ok = false;
         return -1;
       }
+      bool has_initializer = false;
+      ExpressionT initializer = this->EmptyExpression();
       *is_rest = allow_harmony_rest_params() && Check(Token::ELLIPSIS);
-      ParseFormalParameter(scope, locs, *is_rest, ok);
+      ParseFormalParameter(scope, parameter_scope, locs, &initializer,
+                           &has_initializer, *is_rest, ok);
       if (!*ok) return -1;
+      initializers->Add(initializer, zone());
+      if (has_initializer) *has_initializers = true;
     } while (!*is_rest && Check(Token::COMMA));
 
     if (*is_rest && peek() == Token::COMMA) {
       ReportMessageAt(scanner()->peek_location(), "param_after_rest");
       *ok = false;
       return -1;
     }
   }
 
   return parameter_count;
@@ skipping 301 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H