[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 166 matching lines @@
 
   // The variable holding the function literal for named function
   // literals, or NULL.  Only valid for function scopes.
   VariableDeclaration* function() const {
     DCHECK(is_function_scope());
     return function_;
   }
 
   // Parameters. The left-most parameter has index 0.
   // Only valid for function scopes.
   Variable* parameter(int index) const {

[adamk, 2015/05/26 20:34:02]

Is this called anywhere (besides your new caller in scopes.cc)? It scares me a
bit that callers might pull a Variable out of this now that these are bogus.

[caitp (gmail), 2015/05/26 20:59:11]

Yes, it's called in function prologues to move parameters pushed on the stack
into context. It should never actually have to "do" that since the "original"
param variables are never allocated right now, so I think it's safe-ish.

[adamk, 2015/05/26 21:38:07]

Thanks for the pointer, I see how my git grep missed that now.

I agree that it's "safe-ish" :)

     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 160 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 52 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_