[es6] Implement default parameters

src/parser.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_PARSER_H_
 #define V8_PARSER_H_
 
 #include "src/allocation.h"
 #include "src/ast.h"
 #include "src/compiler.h"  // TODO(titzer): remove this include dependency
@@ skipping 523 matching lines @@
 
 // ----------------------------------------------------------------------------
 // JAVASCRIPT PARSING
 
 class Parser;
 class SingletonLogger;
 
 
 struct ParserFormalParameters : FormalParametersBase {
   struct Parameter {
-    Parameter(const AstRawString* name, Expression* pattern, bool is_rest)
-        : name(name), pattern(pattern), is_rest(is_rest) {}
+    Parameter(const AstRawString* name, Expression* pattern,
+              Expression* initializer, bool is_rest)
+        : name(name), pattern(pattern), initializer(initializer),
+          is_rest(is_rest) {}
     const AstRawString* name;
     Expression* pattern;
+    Expression* initializer;
     bool is_rest;
   };
 
   explicit ParserFormalParameters(Scope* scope)
       : FormalParametersBase(scope), params(4, scope->zone()) {}
   ZoneList<Parameter> params;
 
   int Arity() const { return params.length(); }
   const Parameter& at(int i) const { return params[i]; }
 };
@@ skipping 214 matching lines @@
   }
 
   V8_INLINE void AddParameterInitializationBlock(
       const ParserFormalParameters& parameters,
       ZoneList<v8::internal::Statement*>* body, bool* ok);
 
   V8_INLINE Scope* NewScope(Scope* parent_scope, ScopeType scope_type,
                             FunctionKind kind = kNormalFunction);
 
   V8_INLINE void AddFormalParameter(
-      ParserFormalParameters* parameters, Expression* pattern, bool is_rest);
+      ParserFormalParameters* parameters, Expression* pattern,
+      Expression* initializer, bool is_rest);
   V8_INLINE void DeclareFormalParameter(
       Scope* scope, const ParserFormalParameters::Parameter& parameter,
       bool is_simple, ExpressionClassifier* classifier);
   void ParseArrowFunctionFormalParameters(
       ParserFormalParameters* parameters, Expression* params,
       const Scanner::Location& params_loc,
       Scanner::Location* duplicate_loc, bool* ok);
   void ParseArrowFunctionFormalParameterList(
       ParserFormalParameters* parameters, Expression* params,
       const Scanner::Location& params_loc,
@@ skipping 513 matching lines @@
 }
 
 
 Expression* ParserTraits::SpreadCallNew(
     Expression* function, ZoneList<v8::internal::Expression*>* args, int pos) {
   return parser_->SpreadCallNew(function, args, pos);
 }
 
 
 void ParserTraits::AddFormalParameter(
-    ParserFormalParameters* parameters, Expression* pattern, bool is_rest) {
-  bool is_simple = pattern->IsVariableProxy();
+    ParserFormalParameters* parameters,
+    Expression* pattern, Expression* initializer, bool is_rest) {
+  bool is_simple = pattern->IsVariableProxy() && initializer == nullptr;
   DCHECK(parser_->allow_harmony_destructuring() ||
-         parser_->allow_harmony_rest_parameters() || is_simple);
+         parser_->allow_harmony_rest_parameters() ||
+         parser_->allow_harmony_default_parameters() || is_simple);
   const AstRawString* name = is_simple
                                  ? pattern->AsVariableProxy()->raw_name()
                                  : parser_->ast_value_factory()->empty_string();
   parameters->params.Add(
-      ParserFormalParameters::Parameter(name, pattern, is_rest),
+      ParserFormalParameters::Parameter(name, pattern, initializer, is_rest),
       parameters->scope->zone());
 }
 
 
 void ParserTraits::DeclareFormalParameter(
     Scope* scope, const ParserFormalParameters::Parameter& parameter,
     bool is_simple, ExpressionClassifier* classifier) {
   bool is_duplicate = false;
   // TODO(caitp): Remove special handling for rest once desugaring is in.
   auto name = is_simple || parameter.is_rest
@@ skipping 22 matching lines @@
         parser_->BuildParameterInitializationBlock(parameters, ok);
     if (!*ok) return;
     if (init_block != nullptr) {
       body->Add(init_block, parser_->zone());
     }
   }
 }
 } }  // namespace v8::internal
 
 #endif  // V8_PARSER_H_