[es6] implement optional parameters via desugaring (with scoping)

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 132 matching lines @@
                                           Variable::NORMAL,
                                           kCreatedInitialized);
   AllocateHeapSlot(variable);
 }
 
 
 void Scope::SetDefaults(ScopeType scope_type, Scope* outer_scope,
                         Handle<ScopeInfo> scope_info,
                         FunctionKind function_kind) {
   outer_scope_ = outer_scope;
+  function_body_ = nullptr;
   scope_type_ = scope_type;
   function_kind_ = function_kind;
   block_scope_is_class_scope_ = false;
   scope_name_ = ast_value_factory_->empty_string();
   dynamics_ = NULL;
   receiver_ = NULL;
   new_target_ = nullptr;
   function_ = NULL;
   arguments_ = NULL;
   illegal_redecl_ = NULL;
@@ skipping 24 matching lines @@
   rest_index_ = -1;
   scope_info_ = scope_info;
   start_position_ = RelocInfo::kNoPosition;
   end_position_ = RelocInfo::kNoPosition;
   if (!scope_info.is_null()) {
     scope_calls_eval_ = scope_info->CallsEval();
     language_mode_ = scope_info->language_mode();
     block_scope_is_class_scope_ = scope_info->block_scope_is_class_scope();
     function_kind_ = scope_info->function_kind();
   }
+  if (scope_type == FUNCTION_BODY_SCOPE) {
+    DCHECK_NOT_NULL(outer_scope);
+    DCHECK(outer_scope->is_function_scope());
+    DCHECK_NULL(outer_scope->function_body_);
+    outer_scope->function_body_ = this;
+  }
 }
 
 
 Scope* Scope::DeserializeScopeChain(Isolate* isolate, Zone* zone,
                                     Context* context, Scope* script_scope) {
   // Reconstruct the outer scope chain from a closure's context chain.
   Scope* current_scope = NULL;
   Scope* innermost_scope = NULL;
   bool contains_with = false;
   while (!context->IsNativeContext()) {
@@ skipping 329 matching lines @@
                                        name,
                                        TEMPORARY,
                                        Variable::NORMAL,
                                        kCreatedInitialized);
   temps_.Add(var, zone());
   return var;
 }
 
 
 void Scope::AddDeclaration(Declaration* declaration) {
-  decls_.Add(declaration, zone());
+  Scope* target = this;
+  if (is_function_body_scope() && declaration->mode() == VAR) {
+    // Add `var` declarations to outer scope, to make allocation simpler
+    target = outer_scope();
+  }
+  target->decls_.Add(declaration, zone());
 }
 
 
 void Scope::SetIllegalRedeclaration(Expression* expression) {
   // Record only the first illegal redeclaration.
   if (!HasIllegalRedeclaration()) {
     illegal_redecl_ = expression;
   }
   DCHECK(HasIllegalRedeclaration());
 }
@@ skipping 255 matching lines @@
 static const char* Header(ScopeType scope_type) {
   switch (scope_type) {
     case EVAL_SCOPE: return "eval";
     case FUNCTION_SCOPE: return "function";
     case MODULE_SCOPE: return "module";
     case SCRIPT_SCOPE: return "global";
     case CATCH_SCOPE: return "catch";
     case BLOCK_SCOPE: return "block";
     case WITH_SCOPE: return "with";
     case ARROW_SCOPE: return "arrow";
+    case FUNCTION_BODY_SCOPE:
+      return "function body";
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 static void Indent(int n, const char* str) {
   PrintF("%*s%s", n, "", str);
 }
 
@@ skipping 517 matching lines @@
     if (params_[i]->name().is_identical_to(
             isolate->factory()->arguments_string())) {
       return true;
     }
   }
   return false;
 }
 
 
 void Scope::AllocateStackSlot(Variable* var) {
-  if (is_block_scope()) {
+  if (is_function_body_scope()) {
+    // Function body variables need to be allocated in the "real" function
+    // scope, but can't be resolved from it
+    outer_scope()->AllocateStackSlot(var);
+  } else if (is_block_scope()) {
     DeclarationScope()->AllocateStackSlot(var);
   } else {
     var->AllocateTo(Variable::LOCAL, num_stack_slots_++);
   }
 }
 
 
 void Scope::AllocateHeapSlot(Variable* var) {
   var->AllocateTo(Variable::CONTEXT, num_heap_slots_++);
 }
@@ skipping 173 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