[es6] implement default parameters via desugaring

src/scopes.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/bootstrapper.h"
 #include "src/messages.h"
 #include "src/parser.h"
@@ skipping 59 matching lines @@
 // ----------------------------------------------------------------------------
 // Implementation of Scope
 
 Scope::Scope(Zone* zone, Scope* outer_scope, ScopeType scope_type,
              AstValueFactory* ast_value_factory, FunctionKind function_kind)
     : inner_scopes_(4, zone),
       variables_(zone),
       internals_(4, zone),
       temps_(4, zone),
       params_(4, zone),
+      param_positions_(4, zone),
       unresolved_(16, zone),
       decls_(4, zone),
       module_descriptor_(
           scope_type == MODULE_SCOPE ? ModuleDescriptor::New(zone) : NULL),
       already_resolved_(false),
       ast_value_factory_(ast_value_factory),
       zone_(zone),
       class_declaration_group_start_(-1) {
   SetDefaults(scope_type, outer_scope, Handle<ScopeInfo>::null(),
               function_kind);
   // The outermost scope must be a script scope.
   DCHECK(scope_type == SCRIPT_SCOPE || outer_scope != NULL);
   DCHECK(!HasIllegalRedeclaration());
 }
 
 
 Scope::Scope(Zone* zone, Scope* inner_scope, ScopeType scope_type,
              Handle<ScopeInfo> scope_info, AstValueFactory* value_factory)
     : inner_scopes_(4, zone),
       variables_(zone),
       internals_(4, zone),
       temps_(4, zone),
       params_(4, zone),
+      param_positions_(4, zone),
       unresolved_(16, zone),
       decls_(4, zone),
       module_descriptor_(NULL),
       already_resolved_(true),
       ast_value_factory_(value_factory),
       zone_(zone),
       class_declaration_group_start_(-1) {
   SetDefaults(scope_type, NULL, scope_info);
   if (!scope_info.is_null()) {
     num_heap_slots_ = scope_info_->ContextLength();
   }
   // Ensure at least MIN_CONTEXT_SLOTS to indicate a materialized context.
   num_heap_slots_ = Max(num_heap_slots_,
                         static_cast<int>(Context::MIN_CONTEXT_SLOTS));
   AddInnerScope(inner_scope);
 }
 
 
 Scope::Scope(Zone* zone, Scope* inner_scope,
              const AstRawString* catch_variable_name,
              AstValueFactory* value_factory)
     : inner_scopes_(1, zone),
       variables_(zone),
       internals_(0, zone),
       temps_(0, zone),
       params_(0, zone),
+      param_positions_(0, zone),
       unresolved_(0, zone),
       decls_(0, zone),
       module_descriptor_(NULL),
       already_resolved_(true),
       ast_value_factory_(value_factory),
       zone_(zone),
       class_declaration_group_start_(-1) {
   SetDefaults(CATCH_SCOPE, NULL, Handle<ScopeInfo>::null());
   AddInnerScope(inner_scope);
   ++num_var_or_const_;
@@ skipping 318 matching lines @@
        scope != NULL;
        scope = scope->outer_scope()) {
     Variable* var = scope->LookupLocal(name);
     if (var != NULL) return var;
   }
   return NULL;
 }
 
 
 Variable* Scope::DeclareParameter(const AstRawString* name, VariableMode mode,
-                                  bool is_rest, bool* is_duplicate) {
+                                  bool is_rest, bool* is_duplicate, int pos) {
   DCHECK(!already_resolved());
   DCHECK(is_function_scope());
   Variable* var = variables_.Declare(this, name, mode, Variable::NORMAL,
                                      kCreatedInitialized);
   if (is_rest) {
     DCHECK_NULL(rest_parameter_);
     rest_parameter_ = var;
     rest_index_ = num_parameters();
   }
   // TODO(wingo): Avoid O(n^2) check.
   *is_duplicate = IsDeclaredParameter(name);
   params_.Add(var, zone());
+  param_positions_.Add(pos, zone());
   return var;
 }
 
 
 Variable* Scope::DeclareLocal(const AstRawString* name, VariableMode mode,
                               InitializationFlag init_flag, Variable::Kind kind,
                               MaybeAssignedFlag maybe_assigned_flag,
                               int declaration_group_start) {
   DCHECK(!already_resolved());
   // This function handles VAR, LET, and CONST modes.  DYNAMIC variables are
   // introduces during variable allocation, INTERNAL variables are allocated
   // explicitly, and TEMPORARY variables are allocated via NewTemporary().
   DCHECK(IsDeclaredVariableMode(mode));
   ++num_var_or_const_;
   return variables_.Declare(this, name, mode, kind, init_flag,
                             maybe_assigned_flag, declaration_group_start);
 }
 
 
 Variable* Scope::DeclareDynamicGlobal(const AstRawString* name) {
   DCHECK(is_script_scope());
   return variables_.Declare(this,
                             name,
                             DYNAMIC_GLOBAL,
                             Variable::NORMAL,
                             kCreatedInitialized);
 }
 
 
+void Scope::ShadowParametersForExpressions() {

[rossberg, 2015/05/12 14:04:53]

Instead of spreading this out into a different function, can't we do that during
desugaring, right before invoking re-Declare on the respective variable in
DesugarInitializedPArameters?

[caitp (gmail), 2015/05/12 14:34:17]

well the scope VariableMap is private, so it's hard for the parser to do itself
--- do you mean just get rid of the parser version of the function?

[rossberg, 2015/05/20 07:41:47]

Well, this whole removing variables from scope thing still worries me. Do you
think it would be possible to reuse the same variables in the desugaring instead
of removing and re-Declare-ing them? I figure you'd still need to do some
adjustments (e.g. modifying their VariableMode), but those may be less drastic.

[caitp (gmail), 2015/05/20 11:29:38]

I can try it

[caitp (gmail), 2015/05/20 14:55:33]

I'm not totally sure what needs to change.

Right now, I'm changing the parameter to be a lexical declaration, and making
sure it is allocated with AllocateLocal. However, this seems to break the TDZ
behaviour. It worked a lot better when the var was completely re-declared

+  // Parameters have expressions --- ensure that the declared parameters can
+  // never be resolved
+  DCHECK(is_function_scope());
+  for (int i = 0; i < num_parameters(); ++i) {
+    Variable* p = parameter(i);
+    const AstRawString* name = p->raw_name();
+    variables_.Remove(const_cast<AstRawString*>(name), name->hash());
+  }
+}
+
+
 void Scope::RemoveUnresolved(VariableProxy* var) {
   // Most likely (always?) any variable we want to remove
   // was just added before, so we search backwards.
   for (int i = unresolved_.length(); i-- > 0;) {
     if (unresolved_[i] == var) {
       unresolved_.Remove(i);
       return;
     }
   }
 }
@@ skipping 1024 matching lines @@
       (function_ != NULL && function_->proxy()->var()->IsStackLocal() ? 1 : 0);
 }
 
 
 int Scope::ContextLocalCount() const {
   if (num_heap_slots() == 0) return 0;
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS -
       (function_ != NULL && function_->proxy()->var()->IsContextSlot() ? 1 : 0);
 }
 } }  // namespace v8::internal