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

src/scopes.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_SCOPES_H_
 #define V8_SCOPES_H_
 
 #include "src/ast.h"
 #include "src/pending-compilation-error-handler.h"
 #include "src/zone.h"
@@ skipping 69 matching lines @@
   static bool Analyze(ParseInfo* info);
 
   static Scope* DeserializeScopeChain(Isolate* isolate, Zone* zone,
                                       Context* context, Scope* script_scope);
 
   // The scope name is only used for printing/debugging.
   void SetScopeName(const AstRawString* scope_name) {
     scope_name_ = scope_name;
   }
 
+  // Mark the current scope as a scope for evaluating function parameter
+  // expressions (such as initializers for optional parameters)
+  void SetParameterExpressionsScopeFor(Scope* function_scope);
+
   void Initialize();
 
   // Checks if the block scope is redundant, i.e. it does not contain any
   // block scoped declarations. In that case it is removed from the scope
   // tree and its children are reparented.
   Scope* FinalizeBlockScope();
 
   Zone* zone() const { return zone_; }
 
   // ---------------------------------------------------------------------------
@@ skipping 18 matching lines @@
   // outer scope. Only possible for function scopes; at most one variable.
   void DeclareFunctionVar(VariableDeclaration* declaration) {
     DCHECK(is_function_scope());
     function_ = declaration;
   }
 
   // Declare a parameter in this scope.  When there are duplicated
   // parameters the rightmost one 'wins'.  However, the implementation
   // expects all parameters to be declared and from left to right.
   Variable* DeclareParameter(const AstRawString* name, VariableMode mode,
-                             bool is_rest = false);
+                             ParameterKind kind = NormalParameter);
 
   // Declare a local variable in this scope. If the variable has been
   // declared before, the previously declared variable is returned.
   Variable* DeclareLocal(const AstRawString* name, VariableMode mode,
                          InitializationFlag init_flag, Variable::Kind kind,
                          MaybeAssignedFlag maybe_assigned_flag = kNotAssigned);
 
   // Declare an implicit global variable in this scope which must be a
   // script scope.  The variable was introduced (possibly from an inner
   // scope) by a reference to an unresolved variable with no intervening
@@ skipping 363 matching lines @@
   void Print(int n = 0);  // n = indentation; n < 0 => don't print recursively
 #endif
 
   // ---------------------------------------------------------------------------
   // Implementation.
  protected:
   friend class ParserFactory;
 
   // Scope tree.
   Scope* outer_scope_;  // the immediately enclosing outer scope, or NULL
+
+  // function scope to search for parameters. This auxiliary scope enables TDZ
+  // semantics for parameters while evaluating parameter expressions.
+  Scope* parameter_scope_;
+
   ZoneList<Scope*> inner_scopes_;  // the immediately enclosed inner scopes
 
   // The scope type.
   ScopeType scope_type_;
   // Some block scopes are tagged as class scopes.
   bool block_scope_is_class_scope_;
   // If the scope is a function scope, this is the function kind.
   FunctionKind function_kind_;
 
   // Debugging support.
@@ skipping 208 matching lines @@
 
   AstValueFactory* ast_value_factory_;
   Zone* zone_;
 
   PendingCompilationErrorHandler pending_error_handler_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCOPES_H_