[es6] implement default parameters via desugaring

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 108 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, bool* is_duplicate);
+                             bool is_rest, bool* is_duplicate, int pos);
 
   // 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,
                          int declaration_group_start = -1);
 
   // Declare an implicit global variable in this scope which must be a
   // script scope.  The variable was introduced (possibly from an inner
@@ skipping 35 matching lines @@
   // for printing and cannot be used to find the variable.  In particular,
   // the only way to get hold of the temporary is by keeping the Variable*
   // around.  The name should not clash with a legitimate variable names.
   Variable* NewTemporary(const AstRawString* name);
 
   // Adds the specific declaration node to the list of declarations in
   // this scope. The declarations are processed as part of entering
   // the scope; see codegen.cc:ProcessDeclarations.
   void AddDeclaration(Declaration* declaration);
 
+  // Formal parameters may be re-declared as lexical declarations in order to
+  // support TDZ semantics specified in ECMAScript 6.
+  void UndeclareParametersForExpressions();
+
   // ---------------------------------------------------------------------------
   // Illegal redeclaration support.
 
   // Set an expression node that will be executed when the scope is
   // entered. We only keep track of one illegal redeclaration node per
   // scope - the first one - so if you try to set it multiple times
   // the additional requests will be silently ignored.
   void SetIllegalRedeclaration(Expression* expression);
 
   // Visit the illegal redeclaration expression. Do not call if the
@@ skipping 171 matching lines @@
     return function_;
   }
 
   // Parameters. The left-most parameter has index 0.
   // Only valid for function scopes.
   Variable* parameter(int index) const {
     DCHECK(is_function_scope());
     return params_[index];
   }
 
+  // TODO(caitp): This probably won't work when BindingPatterns are supported
+  // in function parameters. Need a better way.
+  int parameter_position(int index) const {
+    DCHECK(is_function_scope());
+    return param_positions_[index];
+  }
+
   // Returns the default function arity --- does not include rest parameters.
   int default_function_length() const {
     int count = params_.length();
     if (rest_index_ >= 0) {
       DCHECK(count > 0);
       DCHECK(is_function_scope());
       --count;
     }
     return count;
   }
@@ skipping 170 matching lines @@
   // All user-declared variables (incl. parameters).  For script scopes
   // variables may be implicitly 'declared' by being used (possibly in
   // an inner scope) with no intervening with statements or eval calls.
   VariableMap variables_;
   // Compiler-allocated (user-invisible) internals.
   ZoneList<Variable*> internals_;
   // Compiler-allocated (user-invisible) temporaries.
   ZoneList<Variable*> temps_;
   // Parameter list in source order.
   ZoneList<Variable*> params_;
+  ZoneList<int> param_positions_;
   // Variables that must be looked up dynamically.
   DynamicScopePart* dynamics_;
   // Unresolved variables referred to from this scope.
   ZoneList<VariableProxy*> unresolved_;
   // Declarations.
   ZoneList<Declaration*> decls_;
   // Convenience variable.
   Variable* receiver_;
   // Function variable, if any; function scopes only.
   VariableDeclaration* function_;
@@ skipping 54 matching lines @@
   // The number of modules (including nested ones).
   int num_modules_;
 
   // For module scopes, the host scope's internal variable binding this module.
   Variable* module_var_;
 
   // Rest parameter
   Variable* rest_parameter_;
   int rest_index_;
 
+  bool has_parameter_expressions_;
+
   // Serialized scope info support.
   Handle<ScopeInfo> scope_info_;
   bool already_resolved() { return already_resolved_; }
 
   // Create a non-local variable with a given name.
   // These variables are looked up dynamically at runtime.
   Variable* NonLocal(const AstRawString* name, VariableMode mode);
 
   // Variable resolution.
   // Possible results of a recursive variable lookup telling if and how a
@@ skipping 115 matching lines @@
   PendingCompilationErrorHandler pending_error_handler_;
 
   // For tracking which classes are declared consecutively. Needed for strong
   // mode.
   int class_declaration_group_start_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCOPES_H_