[es6] implement default parameters via desugaring

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 11 matching lines @@
         scanner_(scanner),
         stack_overflow_(false),
         allow_lazy_(false),
         allow_natives_(false),
         allow_harmony_arrow_functions_(false),
         allow_harmony_object_literals_(false),
         allow_harmony_sloppy_(false),
         allow_harmony_computed_property_names_(false),
         allow_harmony_rest_params_(false),
         allow_harmony_spreadcalls_(false),
+        allow_harmony_optional_params_(false),
         allow_strong_mode_(false) {}
 
   // Getters that indicate whether certain syntactical constructs are
   // allowed to be parsed by this instance of the parser.
   bool allow_lazy() const { return allow_lazy_; }
   bool allow_natives() const { return allow_natives_; }
   bool allow_harmony_arrow_functions() const {
     return allow_harmony_arrow_functions_;
   }
   bool allow_harmony_modules() const { return scanner()->HarmonyModules(); }
   bool allow_harmony_classes() const { return scanner()->HarmonyClasses(); }
   bool allow_harmony_object_literals() const {
     return allow_harmony_object_literals_;
   }
   bool allow_harmony_sloppy() const { return allow_harmony_sloppy_; }
   bool allow_harmony_unicode() const { return scanner()->HarmonyUnicode(); }
   bool allow_harmony_computed_property_names() const {
     return allow_harmony_computed_property_names_;
   }
   bool allow_harmony_rest_params() const {
     return allow_harmony_rest_params_;
   }
   bool allow_harmony_spreadcalls() const { return allow_harmony_spreadcalls_; }
   bool allow_harmony_destructuring() const {
     return allow_harmony_destructuring_;
   }
+  bool allow_harmony_optional_params() const {
+    return allow_harmony_optional_params_;
+  }
 
   bool allow_strong_mode() const { return allow_strong_mode_; }
 
   // Setters that determine whether certain syntactical constructs are
   // allowed to be parsed by this instance of the parser.
   void set_allow_lazy(bool allow) { allow_lazy_ = allow; }
   void set_allow_natives(bool allow) { allow_natives_ = allow; }
   void set_allow_harmony_arrow_functions(bool allow) {
     allow_harmony_arrow_functions_ = allow;
   }
@@ skipping 18 matching lines @@
   void set_allow_harmony_rest_params(bool allow) {
     allow_harmony_rest_params_ = allow;
   }
   void set_allow_harmony_spreadcalls(bool allow) {
     allow_harmony_spreadcalls_ = allow;
   }
   void set_allow_strong_mode(bool allow) { allow_strong_mode_ = allow; }
   void set_allow_harmony_destructuring(bool allow) {
     allow_harmony_destructuring_ = allow;
   }
+  void set_allow_harmony_optional_params(bool allow) {
+    allow_harmony_optional_params_ = allow;
+  }
 
 
  protected:
   enum AllowRestrictedIdentifiers {
     kAllowRestrictedIdentifiers,
     kDontAllowRestrictedIdentifiers
   };
 
   enum Mode {
     PARSE_LAZILY,
@@ skipping 565 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,
-                            bool* ok);
+                            FormalParameterErrorLocations* locs,
+                            ExpressionT* initializer, bool* has_initializer,
+                            bool is_rest, bool* ok);
   int ParseFormalParameterList(FormalParameterScopeT* scope,
                                FormalParameterErrorLocations* locs,
-                               bool* has_rest, bool* ok);
+                               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,
       Scanner::Location location, const char* message, bool* ok);
@@ skipping 80 matching lines @@
 
   bool allow_lazy_;
   bool allow_natives_;
   bool allow_harmony_arrow_functions_;
   bool allow_harmony_object_literals_;
   bool allow_harmony_sloppy_;
   bool allow_harmony_computed_property_names_;
   bool allow_harmony_rest_params_;
   bool allow_harmony_spreadcalls_;
   bool allow_harmony_destructuring_;
+  bool allow_harmony_optional_params_;
   bool allow_strong_mode_;
 };
 
 
 class PreParserIdentifier {
  public:
   PreParserIdentifier() : type_(kUnknownIdentifier) {}
   static PreParserIdentifier Default() {
     return PreParserIdentifier(kUnknownIdentifier);
   }
@@ skipping 835 matching lines @@
   }
   inline void MaterializeTemplateCallsiteLiterals();
   PreParserExpression NoTemplateTag() {
     return PreParserExpression::NoTemplateTag();
   }
   static bool IsTaggedTemplate(const PreParserExpression tag) {
     return !tag.IsNoTemplateTag();
   }
 
   V8_INLINE bool DeclareFormalParameter(DuplicateFinder* scope,
-                                        PreParserIdentifier param,
-                                        bool is_rest);
+                                        PreParserIdentifier param, bool is_rest,
+                                        int pos);
 
   void CheckConflictingVarDeclarations(Scope* scope, bool* ok) {}
 
   // Temporary glue; these functions will move to ParserBase.
   PreParserExpression ParseV8Intrinsic(bool* ok);
   PreParserExpression ParseFunctionLiteral(
       PreParserIdentifier name, Scanner::Location function_name_location,
       bool name_is_strict_reserved, FunctionKind kind,
       int function_token_position, FunctionLiteral::FunctionType type,
       FunctionLiteral::ArityRestriction arity_restriction, bool* ok);
@@ skipping 175 matching lines @@
 
 PreParserExpression PreParserTraits::SpreadCallNew(PreParserExpression function,
                                                    PreParserExpressionList args,
                                                    int pos) {
   return pre_parser_->factory()->NewCallNew(function, args, pos);
 }
 
 
 bool PreParserTraits::DeclareFormalParameter(
     DuplicateFinder* duplicate_finder, PreParserIdentifier current_identifier,
-    bool is_rest) {
+    bool is_rest, int pos) {
   return pre_parser_->scanner()->FindSymbol(duplicate_finder, 1) != 0;
 }
 
 
 void PreParserTraits::ParseArrowFunctionFormalParameters(
     Scope* scope, PreParserExpression params,
     const Scanner::Location& params_loc,
     FormalParameterErrorLocations* error_locs, bool* is_rest, bool* ok) {
   // TODO(wingo): Detect duplicated identifiers in paramlists.  Detect parameter
   // lists that are too long.
@@ skipping 1526 matching lines @@
     }
   }
   DCHECK(false);
   return this->EmptyExpression();
 }
 
 
 template <class Traits>
 void ParserBase<Traits>::ParseFormalParameter(
     FormalParameterScopeT* scope, FormalParameterErrorLocations* locs,
-    bool is_rest, bool* ok) {
+    ExpressionT* initializer, bool* has_initializer, bool is_rest, bool* ok) {
   // FormalParameter[Yield,GeneratorParameter] :
   //   BindingElement[?Yield, ?GeneratorParameter]
   bool is_strict_reserved;
+  int pos = peek_position();
   IdentifierT name =
       ParseIdentifierOrStrictReservedWord(&is_strict_reserved, ok);
   if (!*ok) return;
 
+  if (initializer && allow_harmony_optional_params() && Check(Token::ASSIGN)) {

[arv (Not doing code reviews), 2015/05/11 14:10:54]

This looks strange. Why are we checking initializer here?

[caitp (gmail), 2015/05/11 14:34:57]

below, *initializer is assigned, and we probably don't want to do that if
`initializer` is null (which, at the moment, it is for arrow function parsing)
--- that's kind of a temporary thing though

[arv (Not doing code reviews), 2015/05/11 14:38:01]

What initializer are you passing in before the initializer has been parsed? I
guess you are using Empty for the preparser.

Can you add a comment/todo?

+    // Optional parameter initializer
+    // let formalName = IS_UNDEFINED(arguments[i]) ? initializer : arguments[i];
+    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);
+  bool was_declared = Traits::DeclareFormalParameter(scope, name, is_rest, pos);
   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) {
+    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;
 
   if (peek() != Token::RPAREN) {
+    DCHECK(scope_->is_function_scope());

[caitp (gmail), 2015/05/09 20:57:22]

Apparently this is a problem for lazy-parsed arrow functions :( There has got to
be a better way

[arv (Not doing code reviews), 2015/05/11 14:10:54]

Andy, could you take a look too?

[wingo, 2015/05/11 15:00:48]

So only lazy-parsed arrow functions will have a chance to have initializer
expressions AFAIU -- is that right?  I mean, otherwise we don't know that it's
an initializer and you haven't modified ParseArrowFunctionFormalParameters to
handle initializers.  That is going to be horrific by the way -- you'll be
lifting expressions parsed in one function to another.  There's still some state
being allocated in the parser (literal counts, handler indices, expected
property counts) that will need to be rewritten for initializers lifted to inner
functions.  In my mind the right way to do that is to move to a post-pass; for
that reason it seems that optional argument initializers are going to be quite a
challenge.  Dunno.

So that said it should be impossible to get to a lazily parsed arrow function
with default initializers with the current code.  The preparser should have
already discounted the possibility of the "formals" of the arrow function being
valid.

[caitp (gmail), 2015/05/11 15:34:24]

The issue with lazy-parsing is that the scope doesn't seem to be a
function/arrow scope during lazy parsing --- so the DCHECK fails, and in release
builds we're potentially declaring things in the wrong scope.

Right now, arrow functions never have valid destructuring of any kind, and that
will take more work to support. But we want this DCHECK not to fail, so we might
need to encode some extra info when lazily parsing these.

     do {
+      Scope* param_scope = NewScope(scope_, BLOCK_SCOPE);
+      param_scope->set_start_position(scanner()->peek_location().beg_pos);
+      BlockState param_state(&scope_, param_scope);
+
       if (++parameter_count > Code::kMaxArguments) {
         ReportMessage("too_many_parameters");
         *ok = false;
         return -1;
       }
       *is_rest = allow_harmony_rest_params() && Check(Token::ELLIPSIS);
-      ParseFormalParameter(scope, locs, *is_rest, ok);
+
+      bool has_initializer = false;
+      ExpressionT initializer = this->EmptyExpression();
+      ParseFormalParameter(scope, locs, &initializer, &has_initializer,
+                           *is_rest, ok);
       if (!*ok) return -1;
+      param_scope->set_end_position(scanner()->location().end_pos);
+      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 304 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H