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

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 @@
   // doesn't re-allocate variables repeatedly.
   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;
   }
-
+  const AstRawString* scope_name() const { return scope_name_; }
   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 168 matching lines @@
   }
 
   // ---------------------------------------------------------------------------
   // Predicates.
 
   // Specific scope types.
   bool is_eval_scope() const { return scope_type_ == EVAL_SCOPE; }
   bool is_function_scope() const {
     return scope_type_ == FUNCTION_SCOPE || scope_type_ == ARROW_SCOPE;
   }
+  bool is_function_body_scope() const {
+    return scope_type_ == FUNCTION_BODY_SCOPE;
+  }
   bool is_module_scope() const { return scope_type_ == MODULE_SCOPE; }
   bool is_script_scope() const { return scope_type_ == SCRIPT_SCOPE; }
   bool is_catch_scope() const { return scope_type_ == CATCH_SCOPE; }
-  bool is_block_scope() const { return scope_type_ == BLOCK_SCOPE; }
+  bool is_block_scope() const {
+    return scope_type_ == BLOCK_SCOPE || scope_type_ == FUNCTION_BODY_SCOPE;
+  }
   bool is_with_scope() const { return scope_type_ == WITH_SCOPE; }
   bool is_arrow_scope() const { return scope_type_ == ARROW_SCOPE; }
   void tag_as_class_scope() {
     DCHECK(is_block_scope());
     block_scope_is_class_scope_ = true;
   }
   bool is_class_scope() const {
     return is_block_scope() && block_scope_is_class_scope_;
   }
   bool is_declaration_scope() const {
-    return is_eval_scope() || is_function_scope() ||
-        is_module_scope() || is_script_scope();
+    return is_eval_scope() || is_function_scope() || is_module_scope() ||
+           is_script_scope() || is_function_body_scope();
   }
   bool is_strict_eval_scope() const {
     return is_eval_scope() && is_strict(language_mode_);
   }
 
   // Information about which scopes calls eval.
   bool calls_eval() const { return scope_calls_eval_; }
   bool calls_sloppy_eval() {
     return scope_calls_eval_ && is_sloppy(language_mode_);
   }
@@ skipping 98 matching lines @@
 
   // Declarations list.
   ZoneList<Declaration*>* declarations() { return &decls_; }
 
   // Inner scope list.
   ZoneList<Scope*>* inner_scopes() { return &inner_scopes_; }
 
   // The scope immediately surrounding this scope, or NULL.
   Scope* outer_scope() const { return outer_scope_; }
 
+  // The inner scope which contains the main "body" of a function (may be null)
+  Scope* function_body() const { return function_body_; }
+
   // The ModuleDescriptor for this scope; only for module scopes.
   ModuleDescriptor* module() const { return module_descriptor_; }
 
 
   void set_class_declaration_group_start(int position) {
     class_declaration_group_start_ = position;
   }
 
   int class_declaration_group_start() const {
     return class_declaration_group_start_;
@@ skipping 91 matching lines @@
 #endif
 
   // ---------------------------------------------------------------------------
   // Implementation.
  protected:
   friend class ParserFactory;
 
   // Scope tree.
   Scope* outer_scope_;  // the immediately enclosing outer scope, or NULL
   ZoneList<Scope*> inner_scopes_;  // the immediately enclosed inner scopes
+  Scope* function_body_;           // The scope for a function body
 
   // 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.
   const AstRawString* scope_name_;
@@ skipping 211 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_