Scopes: simplfy scope creation for with scopes.

src/ast/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/ast/scopes.h"
 
 #include <set>
 
 #include "src/accessors.h"
 #include "src/bootstrapper.h"
@@ skipping 59 matching lines @@
       ZoneHashMap::LookupOrInsert(const_cast<AstRawString*>(name), name->hash(),
                                   ZoneAllocationPolicy(zone));
   stmt->set_next(static_cast<SloppyBlockFunctionStatement*>(p->value));
   p->value = stmt;
 }
 
 
 // ----------------------------------------------------------------------------
 // Implementation of Scope
 
-Scope::Scope(Zone* zone)
+Scope::Scope(Zone* zone, ScopeType scope_type)
     : zone_(zone),
       outer_scope_(nullptr),
       variables_(zone),
       ordered_variables_(4, zone),
       decls_(4, zone),
-      scope_type_(SCRIPT_SCOPE) {
+      scope_type_(scope_type) {
+  DCHECK(scope_type == SCRIPT_SCOPE || scope_type == WITH_SCOPE);
   SetDefaults();
+#ifdef DEBUG
+  if (scope_type == WITH_SCOPE) {
+    already_resolved_ = true;
+  }
+#endif
 }
 
 Scope::Scope(Zone* zone, Scope* outer_scope, ScopeType scope_type)
     : zone_(zone),
       outer_scope_(outer_scope),
       variables_(zone),
       ordered_variables_(4, zone),
       decls_(4, zone),
       scope_type_(scope_type) {
   DCHECK_NE(SCRIPT_SCOPE, scope_type);
@@ skipping 41 matching lines @@
 
 Scope::Scope(Zone* zone, Scope* inner_scope, ScopeType scope_type,
              Handle<ScopeInfo> scope_info)
     : zone_(zone),
       outer_scope_(nullptr),
       variables_(zone),
       ordered_variables_(0, zone),
       decls_(0, zone),
       scope_info_(scope_info),
       scope_type_(scope_type) {
+  DCHECK(!scope_info.is_null());
   SetDefaults();
 #ifdef DEBUG
   already_resolved_ = true;
 #endif
-  if (scope_type == WITH_SCOPE) {
-    DCHECK(scope_info.is_null());
-  } else {
-    if (scope_info->CallsEval()) RecordEvalCall();
-    set_language_mode(scope_info->language_mode());
-    num_heap_slots_ = scope_info->ContextLength();
-  }
+  if (scope_info->CallsEval()) RecordEvalCall();
+  set_language_mode(scope_info->language_mode());
+  num_heap_slots_ = scope_info->ContextLength();
   DCHECK_LE(Context::MIN_CONTEXT_SLOTS, num_heap_slots_);
 
   if (inner_scope != nullptr) AddInnerScope(inner_scope);
 }
 
 DeclarationScope::DeclarationScope(Zone* zone, Scope* inner_scope,
                                    ScopeType scope_type,
                                    Handle<ScopeInfo> scope_info)
     : Scope(zone, inner_scope, scope_type, scope_info),
       function_kind_(scope_info->function_kind()),
@@ skipping 87 matching lines @@
                                     Context* context,
                                     DeclarationScope* script_scope,
                                     AstValueFactory* ast_value_factory,
                                     DeserializationMode deserialization_mode) {
   // Reconstruct the outer scope chain from a closure's context chain.
   Scope* current_scope = nullptr;
   Scope* innermost_scope = nullptr;
   while (!context->IsNativeContext()) {
     if (context->IsWithContext() || context->IsDebugEvaluateContext()) {
       // For scope analysis, debug-evaluate is equivalent to a with scope.
-      Scope* with_scope = new (zone)
-          Scope(zone, current_scope, WITH_SCOPE, Handle<ScopeInfo>());
+      Scope* with_scope = new (zone) Scope(zone, WITH_SCOPE);
+      if (current_scope != nullptr) {
+        with_scope->AddInnerScope(current_scope);

[Toon Verwaest, 2016/08/23 12:33:27]

Perhaps we should just pull this out of the other constructor and put it at the
end of the while body? I never liked that the Scope* argument to Scope can
either be inner or outer scope, depending on ScopeInfo being passed in ...

+      }
+
       // TODO(yangguo): Remove once debug-evaluate properly keeps track of the
       // function scope in which we are evaluating.
       if (context->IsDebugEvaluateContext()) {
         with_scope->set_is_debug_evaluate_scope();
       }
       current_scope = with_scope;
     } else if (context->IsScriptContext()) {
       Handle<ScopeInfo> scope_info(context->scope_info(), isolate);
       DCHECK_EQ(scope_info->scope_type(), SCRIPT_SCOPE);
       current_scope = new (zone)
@@ skipping 1455 matching lines @@
       function != nullptr && function->IsContextSlot();
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS - num_global_slots() -
          (is_function_var_in_context ? 1 : 0);
 }
 
 
 int Scope::ContextGlobalCount() const { return num_global_slots(); }
 
 }  // namespace internal
 }  // namespace v8