../deps/v8/src/ast/scopes.cc

Bug Summary

File:	out/../deps/v8/src/ast/scopes.cc
Warning:	line 2217, column 5 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name scopes.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D V8_GYP_BUILD -D V8_TYPED_ARRAY_MAX_SIZE_IN_HEAP=64 -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D V8_TARGET_ARCH_X64 -D V8_HAVE_TARGET_OS -D V8_TARGET_OS_LINUX -D V8_EMBEDDER_STRING="-node.8" -D ENABLE_DISASSEMBLER -D V8_PROMISE_INTERNAL_FIELD_COUNT=1 -D V8_SHORT_BUILTIN_CALLS -D OBJECT_PRINT -D V8_INTL_SUPPORT -D V8_ATOMIC_OBJECT_FIELD_WRITES -D V8_ENABLE_LAZY_SOURCE_POSITIONS -D V8_USE_SIPHASH -D V8_SHARED_RO_HEAP -D V8_WIN64_UNWINDING_INFO -D V8_ENABLE_REGEXP_INTERPRETER_THREADED_DISPATCH -D V8_SNAPSHOT_COMPRESSION -D V8_ENABLE_WEBASSEMBLY -D V8_ENABLE_JAVASCRIPT_PROMISE_HOOKS -D V8_ALLOCATION_FOLDING -D V8_ALLOCATION_SITE_TRACKING -D V8_SCRIPTORMODULE_LEGACY_LIFETIME -D V8_ADVANCED_BIGINT_ALGORITHMS -D ICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_STATIC -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_STATIC_IMPLEMENTATION=1 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/v8 -I ../deps/v8/include -I /home/maurizio/node-v18.6.0/out/Release/obj/gen/inspector-generated-output-root -I ../deps/v8/third_party/inspector_protocol -I /home/maurizio/node-v18.6.0/out/Release/obj/gen -I /home/maurizio/node-v18.6.0/out/Release/obj/gen/generate-bytecode-output-root -I ../deps/icu-small/source/i18n -I ../deps/icu-small/source/common -I ../deps/v8/third_party/zlib -I ../deps/v8/third_party/zlib/google -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-return-type -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/v8/src/ast/scopes.cc
1// Copyright 2012 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.

5#include "src/ast/scopes.h"

7#include <set>

9#include "src/ast/ast.h"
10#include "src/base/logging.h"
11#include "src/base/optional.h"
12#include "src/builtins/accessors.h"
13#include "src/common/message-template.h"
14#include "src/heap/local-factory-inl.h"
15#include "src/init/bootstrapper.h"
16#include "src/logging/runtime-call-stats-scope.h"
17#include "src/objects/module-inl.h"
18#include "src/objects/objects-inl.h"
19#include "src/objects/scope-info.h"
20#include "src/objects/string-set-inl.h"
21#include "src/parsing/parse-info.h"
22#include "src/parsing/parser.h"
23#include "src/parsing/preparse-data.h"
24#include "src/zone/zone-list-inl.h"
25#include "src/zone/zone.h"

27namespace v8 {
28namespace internal {

30// ----------------------------------------------------------------------------
31// Implementation of LocalsMap
32//
33// Note: We are storing the handle locations as key values in the hash map.
34//       When inserting a new variable via Declare(), we rely on the fact that
35//       the handle location remains alive for the duration of that variable
36//       use. Because a Variable holding a handle with the same location exists
37//       this is ensured.

39static_assert(sizeof(VariableMap) == (sizeof(void*) + 2 * sizeof(uint32_t) +
                                    sizeof(ZoneAllocationPolicy)),
            "Empty base optimization didn't kick in for VariableMap");

43VariableMap::VariableMap(Zone* zone)
  : ZoneHashMap(8, ZoneAllocationPolicy(zone)) {}

46VariableMap::VariableMap(const VariableMap& other, Zone* zone)
  : ZoneHashMap(other, ZoneAllocationPolicy(zone)) {}

49Variable* VariableMap::Declare(Zone* zone, Scope* scope,
                             const AstRawString* name, VariableMode mode,
                             VariableKind kind,
                             InitializationFlag initialization_flag,
                             MaybeAssignedFlag maybe_assigned_flag,
                             IsStaticFlag is_static_flag, bool* was_added) {
DCHECK_EQ(zone, allocator().zone())((void) 0);
// AstRawStrings are unambiguous, i.e., the same string is always represented
// by the same AstRawString*.
// FIXME(marja): fix the type of Lookup.
Entry* p = ZoneHashMap::LookupOrInsert(const_cast<AstRawString*>(name),
                                       name->Hash());
*was_added = p->value == nullptr;
if (*was_added) {
  // The variable has not been declared yet -> insert it.
  DCHECK_EQ(name, p->key)((void) 0);
  Variable* variable =
      zone->New<Variable>(scope, name, mode, kind, initialization_flag,
                          maybe_assigned_flag, is_static_flag);
  p->value = variable;
}
return reinterpret_cast<Variable*>(p->value);
71}

73void VariableMap::Remove(Variable* var) {
const AstRawString* name = var->raw_name();
ZoneHashMap::Remove(const_cast<AstRawString*>(name), name->Hash());
76}

78void VariableMap::Add(Variable* var) {
const AstRawString* name = var->raw_name();
Entry* p = ZoneHashMap::LookupOrInsert(const_cast<AstRawString*>(name),
                                       name->Hash());
DCHECK_NULL(p->value)((void) 0);
DCHECK_EQ(name, p->key)((void) 0);
p->value = var;
85}

87Variable* VariableMap::Lookup(const AstRawString* name) {
Entry* p = ZoneHashMap::Lookup(const_cast<AstRawString*>(name), name->Hash());
if (p != nullptr) {
  DCHECK(reinterpret_cast<const AstRawString*>(p->key) == name)((void) 0);
  DCHECK_NOT_NULL(p->value)((void) 0);
  return reinterpret_cast<Variable*>(p->value);
}
return nullptr;
95}

97// ----------------------------------------------------------------------------
98// Implementation of Scope

100Scope::Scope(Zone* zone)
  : outer_scope_(nullptr), variables_(zone), scope_type_(SCRIPT_SCOPE) {
SetDefaults();
103}

105Scope::Scope(Zone* zone, Scope* outer_scope, ScopeType scope_type)
  : outer_scope_(outer_scope), variables_(zone), scope_type_(scope_type) {
DCHECK_NE(SCRIPT_SCOPE, scope_type)((void) 0);
SetDefaults();
set_language_mode(outer_scope->language_mode());
private_name_lookup_skips_outer_class_ =
    outer_scope->is_class_scope() &&
    outer_scope->AsClassScope()->IsParsingHeritage();
outer_scope_->AddInnerScope(this);
114}

116Variable* Scope::DeclareHomeObjectVariable(AstValueFactory* ast_value_factory) {
bool was_added;
Variable* home_object_variable = Declare(
    zone(), ast_value_factory->dot_home_object_string(), VariableMode::kConst,
    NORMAL_VARIABLE, InitializationFlag::kCreatedInitialized,
    MaybeAssignedFlag::kNotAssigned, &was_added);
DCHECK(was_added)((void) 0);
home_object_variable->set_is_used();
home_object_variable->ForceContextAllocation();
return home_object_variable;
126}

128Variable* Scope::DeclareStaticHomeObjectVariable(
  AstValueFactory* ast_value_factory) {
bool was_added;
Variable* static_home_object_variable =
    Declare(zone(), ast_value_factory->dot_static_home_object_string(),
            VariableMode::kConst, NORMAL_VARIABLE,
            InitializationFlag::kCreatedInitialized,
            MaybeAssignedFlag::kNotAssigned, &was_added);
DCHECK(was_added)((void) 0);
static_home_object_variable->set_is_used();
static_home_object_variable->ForceContextAllocation();
return static_home_object_variable;
140}

142DeclarationScope::DeclarationScope(Zone* zone,
                                 AstValueFactory* ast_value_factory,
                                 REPLMode repl_mode)
  : Scope(zone),
    function_kind_(repl_mode == REPLMode::kYes
                       ? FunctionKind::kAsyncFunction
                       : FunctionKind::kNormalFunction),
    params_(4, zone) {
DCHECK_EQ(scope_type_, SCRIPT_SCOPE)((void) 0);
SetDefaults();
is_repl_mode_scope_ = repl_mode == REPLMode::kYes;
receiver_ = DeclareDynamicGlobal(ast_value_factory->this_string(),
                                 THIS_VARIABLE, this);
155}

157DeclarationScope::DeclarationScope(Zone* zone, Scope* outer_scope,
                                 ScopeType scope_type,
                                 FunctionKind function_kind)
  : Scope(zone, outer_scope, scope_type),
    function_kind_(function_kind),
    params_(4, zone) {
DCHECK_NE(scope_type, SCRIPT_SCOPE)((void) 0);
SetDefaults();
165}

167ModuleScope::ModuleScope(DeclarationScope* script_scope,
                       AstValueFactory* avfactory)
  : DeclarationScope(avfactory->single_parse_zone(), script_scope,
                     MODULE_SCOPE, FunctionKind::kModule),
    module_descriptor_(
        avfactory->single_parse_zone()->New<SourceTextModuleDescriptor>(
            avfactory->single_parse_zone())) {
set_language_mode(LanguageMode::kStrict);
DeclareThis(avfactory);
176}

178ModuleScope::ModuleScope(Handle<ScopeInfo> scope_info,
                       AstValueFactory* avfactory)
  : DeclarationScope(avfactory->single_parse_zone(), MODULE_SCOPE, avfactory,
                     scope_info),
    module_descriptor_(nullptr) {
set_language_mode(LanguageMode::kStrict);
184}

186ClassScope::ClassScope(Zone* zone, Scope* outer_scope, bool is_anonymous)
  : Scope(zone, outer_scope, CLASS_SCOPE),
    rare_data_and_is_parsing_heritage_(nullptr),
    is_anonymous_class_(is_anonymous) {
set_language_mode(LanguageMode::kStrict);
191}

193template <typename IsolateT>
194ClassScope::ClassScope(IsolateT* isolate, Zone* zone,
                     AstValueFactory* ast_value_factory,
                     Handle<ScopeInfo> scope_info)
  : Scope(zone, CLASS_SCOPE, ast_value_factory, scope_info),
    rare_data_and_is_parsing_heritage_(nullptr) {
set_language_mode(LanguageMode::kStrict);
if (scope_info->ClassScopeHasPrivateBrand()) {
  Variable* brand =
      LookupInScopeInfo(ast_value_factory->dot_brand_string(), this);
  DCHECK_NOT_NULL(brand)((void) 0);
  EnsureRareData()->brand = brand;
}

// If the class variable is context-allocated and its index is
// saved for deserialization, deserialize it.
if (scope_info->HasSavedClassVariable()) {
  String name;
  int index;
  std::tie(name, index) = scope_info->SavedClassVariable();
  DCHECK_EQ(scope_info->ContextLocalMode(index), VariableMode::kConst)((void) 0);
  DCHECK_EQ(scope_info->ContextLocalInitFlag(index),((void) 0)
            InitializationFlag::kNeedsInitialization)((void) 0);
  DCHECK_EQ(scope_info->ContextLocalMaybeAssignedFlag(index),((void) 0)
            MaybeAssignedFlag::kMaybeAssigned)((void) 0);
  Variable* var = DeclareClassVariable(
      ast_value_factory,
      ast_value_factory->GetString(name,
                                   SharedStringAccessGuardIfNeeded(isolate)),
      kNoSourcePosition);
  var->AllocateTo(VariableLocation::CONTEXT,
                  Context::MIN_CONTEXT_SLOTS + index);
}

DCHECK(scope_info->HasPositionInfo())((void) 0);
set_start_position(scope_info->StartPosition());
set_end_position(scope_info->EndPosition());
230}
231template ClassScope::ClassScope(Isolate* isolate, Zone* zone,
                              AstValueFactory* ast_value_factory,
                              Handle<ScopeInfo> scope_info);
234template ClassScope::ClassScope(LocalIsolate* isolate, Zone* zone,
                              AstValueFactory* ast_value_factory,
                              Handle<ScopeInfo> scope_info);

238Scope::Scope(Zone* zone, ScopeType scope_type,
           AstValueFactory* ast_value_factory, Handle<ScopeInfo> scope_info)
  : outer_scope_(nullptr),
    variables_(zone),
    scope_info_(scope_info),
    scope_type_(scope_type) {
DCHECK(!scope_info.is_null())((void) 0);
SetDefaults();
246#ifdef DEBUG
already_resolved_ = true;
248#endif
set_language_mode(scope_info->language_mode());
DCHECK_EQ(ContextHeaderLength(), num_heap_slots_)((void) 0);
private_name_lookup_skips_outer_class_ =
    scope_info->PrivateNameLookupSkipsOuterClass();
// We don't really need to use the preparsed scope data; this is just to
// shorten the recursion in SetMustUsePreparseData.
must_use_preparsed_scope_data_ = true;

if (scope_type == BLOCK_SCOPE) {
  // Set is_block_scope_for_object_literal_ based on the existince of the home
  // object variable (we don't store it explicitly).
  DCHECK_NOT_NULL(ast_value_factory)((void) 0);
  int home_object_index = scope_info->ContextSlotIndex(
      ast_value_factory->dot_home_object_string()->string());
  DCHECK_IMPLIES(home_object_index >= 0,((void) 0)
                 scope_type == CLASS_SCOPE || scope_type == BLOCK_SCOPE)((void) 0);
  if (home_object_index >= 0) {
    is_block_scope_for_object_literal_ = true;
  }
}
269}

271DeclarationScope::DeclarationScope(Zone* zone, ScopeType scope_type,
                                 AstValueFactory* ast_value_factory,
                                 Handle<ScopeInfo> scope_info)
  : Scope(zone, scope_type, ast_value_factory, scope_info),
    function_kind_(scope_info->function_kind()),
    params_(0, zone) {
DCHECK_NE(scope_type, SCRIPT_SCOPE)((void) 0);
SetDefaults();
if (scope_info->SloppyEvalCanExtendVars()) {
  DCHECK(!is_eval_scope())((void) 0);
  sloppy_eval_can_extend_vars_ = true;
}
if (scope_info->ClassScopeHasPrivateBrand()) {
  DCHECK(IsClassConstructor(function_kind()))((void) 0);
  class_scope_has_private_brand_ = true;
}
287}

289Scope::Scope(Zone* zone, const AstRawString* catch_variable_name,
           MaybeAssignedFlag maybe_assigned, Handle<ScopeInfo> scope_info)
  : outer_scope_(nullptr),
    variables_(zone),
    scope_info_(scope_info),
    scope_type_(CATCH_SCOPE) {
SetDefaults();
296#ifdef DEBUG
already_resolved_ = true;
298#endif
// Cache the catch variable, even though it's also available via the
// scope_info, as the parser expects that a catch scope always has the catch
// variable as first and only variable.
bool was_added;
Variable* variable =
    Declare(zone, catch_variable_name, VariableMode::kVar, NORMAL_VARIABLE,
            kCreatedInitialized, maybe_assigned, &was_added);
DCHECK(was_added)((void) 0);
AllocateHeapSlot(variable);
308}

310void DeclarationScope::SetDefaults() {
is_declaration_scope_ = true;
has_simple_parameters_ = true;
313#if V8_ENABLE_WEBASSEMBLY1
is_asm_module_ = false;
315#endif  // V8_ENABLE_WEBASSEMBLY
force_eager_compilation_ = false;
has_arguments_parameter_ = false;
uses_super_property_ = false;
has_checked_syntax_ = false;
has_this_reference_ = false;
has_this_declaration_ =
    (is_function_scope() && !is_arrow_scope()) || is_module_scope();
needs_private_name_context_chain_recalc_ = false;
has_rest_ = false;
receiver_ = nullptr;
new_target_ = nullptr;
function_ = nullptr;
arguments_ = nullptr;
rare_data_ = nullptr;
should_eager_compile_ = false;
was_lazily_parsed_ = false;
is_skipped_function_ = false;
preparse_data_builder_ = nullptr;
class_scope_has_private_brand_ = false;
335#ifdef DEBUG
DeclarationScope* outer_declaration_scope =
    outer_scope_ ? outer_scope_->GetDeclarationScope() : nullptr;
is_being_lazily_parsed_ =
    outer_declaration_scope ? outer_declaration_scope->is_being_lazily_parsed_
                            : false;
341#endif
342}

344void Scope::SetDefaults() {
345#ifdef DEBUG
scope_name_ = nullptr;
already_resolved_ = false;
needs_migration_ = false;
349#endif
inner_scope_ = nullptr;
sibling_ = nullptr;
unresolved_list_.Clear();

start_position_ = kNoSourcePosition;
end_position_ = kNoSourcePosition;

calls_eval_ = false;
sloppy_eval_can_extend_vars_ = false;
scope_nonlinear_ = false;
is_hidden_ = false;
is_debug_evaluate_scope_ = false;

inner_scope_calls_eval_ = false;
force_context_allocation_for_parameters_ = false;

is_declaration_scope_ = false;

private_name_lookup_skips_outer_class_ = false;

must_use_preparsed_scope_data_ = false;
is_repl_mode_scope_ = false;

deserialized_scope_uses_external_cache_ = false;

needs_home_object_ = false;
is_block_scope_for_object_literal_ = false;

num_stack_slots_ = 0;
num_heap_slots_ = ContextHeaderLength();

set_language_mode(LanguageMode::kSloppy);
382}

384bool Scope::HasSimpleParameters() {
DeclarationScope* scope = GetClosureScope();
return !scope->is_function_scope() || scope->has_simple_parameters();
387}

389void DeclarationScope::set_should_eager_compile() {
should_eager_compile_ = !was_lazily_parsed_;
391}

393#if V8_ENABLE_WEBASSEMBLY1
394void DeclarationScope::set_is_asm_module() { is_asm_module_ = true; }

396bool Scope::IsAsmModule() const {
return is_function_scope() && AsDeclarationScope()->is_asm_module();
398}

400bool Scope::ContainsAsmModule() const {
if (IsAsmModule()) return true;

// Check inner scopes recursively
for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
  // Don't check inner functions which won't be eagerly compiled.
  if (!scope->is_function_scope() ||
      scope->AsDeclarationScope()->ShouldEagerCompile()) {
    if (scope->ContainsAsmModule()) return true;
  }
}

return false;
413}
414#endif  // V8_ENABLE_WEBASSEMBLY

416template <typename IsolateT>
417Scope* Scope::DeserializeScopeChain(IsolateT* isolate, Zone* zone,
                                  ScopeInfo scope_info,
                                  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;
Scope* outer_scope = nullptr;
bool cache_scope_found = false;
while (!scope_info.is_null()) {
  if (scope_info.scope_type() == WITH_SCOPE) {
    if (scope_info.IsDebugEvaluateScope()) {
      outer_scope =
          zone->New<DeclarationScope>(zone, FUNCTION_SCOPE, ast_value_factory,
                                      handle(scope_info, isolate));
      outer_scope->set_is_debug_evaluate_scope();
    } else {
      // For scope analysis, debug-evaluate is equivalent to a with scope.
      outer_scope = zone->New<Scope>(zone, WITH_SCOPE, ast_value_factory,
                                     handle(scope_info, isolate));
    }

  } else if (scope_info.scope_type() == SCRIPT_SCOPE) {
    // If we reach a script scope, it's the outermost scope. Install the
    // scope info of this script context onto the existing script scope to
    // avoid nesting script scopes.
    if (deserialization_mode == DeserializationMode::kIncludingVariables) {
      script_scope->SetScriptScopeInfo(handle(scope_info, isolate));
    }
    if (scope_info.IsReplModeScope()) script_scope->set_is_repl_mode_scope();
    DCHECK(!scope_info.HasOuterScopeInfo())((void) 0);
    break;
  } else if (scope_info.scope_type() == FUNCTION_SCOPE) {
    outer_scope = zone->New<DeclarationScope>(
        zone, FUNCTION_SCOPE, ast_value_factory, handle(scope_info, isolate));
453#if V8_ENABLE_WEBASSEMBLY1
    if (scope_info.IsAsmModule()) {
      outer_scope->AsDeclarationScope()->set_is_asm_module();
    }
457#endif  // V8_ENABLE_WEBASSEMBLY
  } else if (scope_info.scope_type() == EVAL_SCOPE) {
    outer_scope = zone->New<DeclarationScope>(
        zone, EVAL_SCOPE, ast_value_factory, handle(scope_info, isolate));
  } else if (scope_info.scope_type() == CLASS_SCOPE) {
    outer_scope = zone->New<ClassScope>(isolate, zone, ast_value_factory,
                                        handle(scope_info, isolate));
  } else if (scope_info.scope_type() == BLOCK_SCOPE) {
    if (scope_info.is_declaration_scope()) {
      outer_scope = zone->New<DeclarationScope>(
          zone, BLOCK_SCOPE, ast_value_factory, handle(scope_info, isolate));
    } else {
      outer_scope = zone->New<Scope>(zone, BLOCK_SCOPE, ast_value_factory,
                                     handle(scope_info, isolate));
    }
  } else if (scope_info.scope_type() == MODULE_SCOPE) {
    outer_scope = zone->New<ModuleScope>(handle(scope_info, isolate),
                                         ast_value_factory);
  } else {
    DCHECK_EQ(scope_info.scope_type(), CATCH_SCOPE)((void) 0);
    DCHECK_EQ(scope_info.ContextLocalCount(), 1)((void) 0);
    DCHECK_EQ(scope_info.ContextLocalMode(0), VariableMode::kVar)((void) 0);
    DCHECK_EQ(scope_info.ContextLocalInitFlag(0), kCreatedInitialized)((void) 0);
    DCHECK(scope_info.HasInlinedLocalNames())((void) 0);
    String name = scope_info.ContextInlinedLocalName(0);
    MaybeAssignedFlag maybe_assigned =
        scope_info.ContextLocalMaybeAssignedFlag(0);
    outer_scope =
        zone->New<Scope>(zone,
                         ast_value_factory->GetString(
                             name, SharedStringAccessGuardIfNeeded(isolate)),
                         maybe_assigned, handle(scope_info, isolate));
  }
  if (deserialization_mode == DeserializationMode::kScopesOnly) {
    outer_scope->scope_info_ = Handle<ScopeInfo>::null();
  }

  if (cache_scope_found) {
    outer_scope->set_deserialized_scope_uses_external_cache();
  } else {
    DCHECK(!cache_scope_found)((void) 0);
    cache_scope_found =
        outer_scope->is_declaration_scope() && !outer_scope->is_eval_scope();
  }

  if (current_scope != nullptr) {
    outer_scope->AddInnerScope(current_scope);
  }
  current_scope = outer_scope;
  if (innermost_scope == nullptr) innermost_scope = current_scope;
  scope_info = scope_info.HasOuterScopeInfo() ? scope_info.OuterScopeInfo()
                                              : ScopeInfo();
}

if (deserialization_mode == DeserializationMode::kIncludingVariables) {
  SetScriptScopeInfo(isolate, script_scope);
}

if (innermost_scope == nullptr) return script_scope;
script_scope->AddInnerScope(current_scope);
return innermost_scope;
518}

520template <typename IsolateT>
521void Scope::SetScriptScopeInfo(IsolateT* isolate,
                             DeclarationScope* script_scope) {
if (script_scope->scope_info_.is_null()) {
  script_scope->SetScriptScopeInfo(
      ReadOnlyRoots(isolate).global_this_binding_scope_info_handle());
}
527}

529template EXPORT_TEMPLATE_DEFINE(
  V8_EXPORT_PRIVATE) void Scope::SetScriptScopeInfo(Isolate* isolate,
                                                    DeclarationScope*
                                                        script_scope);
533template EXPORT_TEMPLATE_DEFINE(
  V8_EXPORT_PRIVATE) void Scope::SetScriptScopeInfo(LocalIsolate* isolate,
                                                    DeclarationScope*
                                                        script_scope);

538template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)
  Scope* Scope::DeserializeScopeChain(
      Isolate* isolate, Zone* zone, ScopeInfo scope_info,
      DeclarationScope* script_scope, AstValueFactory* ast_value_factory,
      DeserializationMode deserialization_mode);
543template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)
  Scope* Scope::DeserializeScopeChain(
      LocalIsolate* isolate, Zone* zone, ScopeInfo scope_info,
      DeclarationScope* script_scope, AstValueFactory* ast_value_factory,
      DeserializationMode deserialization_mode);

549#ifdef DEBUG
550bool Scope::IsReparsedMemberInitializerScope() const {
return is_declaration_scope() &&
       IsClassMembersInitializerFunction(
           AsDeclarationScope()->function_kind()) &&
       outer_scope()->AsClassScope()->is_reparsed_class_scope();
555}
556#endif

558DeclarationScope* Scope::AsDeclarationScope() {
DCHECK(is_declaration_scope())((void) 0);
return static_cast<DeclarationScope*>(this);
561}

563const DeclarationScope* Scope::AsDeclarationScope() const {
DCHECK(is_declaration_scope())((void) 0);
return static_cast<const DeclarationScope*>(this);
566}

568ModuleScope* Scope::AsModuleScope() {
DCHECK(is_module_scope())((void) 0);
return static_cast<ModuleScope*>(this);
571}

573const ModuleScope* Scope::AsModuleScope() const {
DCHECK(is_module_scope())((void) 0);
return static_cast<const ModuleScope*>(this);
576}

578ClassScope* Scope::AsClassScope() {
DCHECK(is_class_scope())((void) 0);
return static_cast<ClassScope*>(this);
581}

583const ClassScope* Scope::AsClassScope() const {
DCHECK(is_class_scope())((void) 0);
return static_cast<const ClassScope*>(this);
586}

588void DeclarationScope::DeclareSloppyBlockFunction(
  SloppyBlockFunctionStatement* sloppy_block_function) {
sloppy_block_functions_.Add(sloppy_block_function);
591}

593void DeclarationScope::HoistSloppyBlockFunctions(AstNodeFactory* factory) {
DCHECK(is_sloppy(language_mode()))((void) 0);
DCHECK(is_function_scope() || is_eval_scope() || is_script_scope() ||((void) 0)
       (is_block_scope() && outer_scope()->is_function_scope()))((void) 0);
DCHECK(HasSimpleParameters() || is_block_scope() || is_being_lazily_parsed_)((void) 0);
DCHECK_EQ(factory == nullptr, is_being_lazily_parsed_)((void) 0);

if (sloppy_block_functions_.is_empty()) return;

// In case of complex parameters the current scope is the body scope and the
// parameters are stored in the outer scope.
Scope* parameter_scope = HasSimpleParameters() ? this : outer_scope_;
DCHECK(parameter_scope->is_function_scope() || is_eval_scope() ||((void) 0)
       is_script_scope())((void) 0);

DeclarationScope* decl_scope = GetNonEvalDeclarationScope();
Scope* outer_scope = decl_scope->outer_scope();

// For each variable which is used as a function declaration in a sloppy
// block,
for (SloppyBlockFunctionStatement* sloppy_block_function :
     sloppy_block_functions_) {
  const AstRawString* name = sloppy_block_function->name();

  // If the variable wouldn't conflict with a lexical declaration
  // or parameter,

  // Check if there's a conflict with a parameter.
  Variable* maybe_parameter = parameter_scope->LookupLocal(name);
  if (maybe_parameter != nullptr && maybe_parameter->is_parameter()) {
    continue;
  }

  // Check if there's a conflict with a lexical declaration
  Scope* query_scope = sloppy_block_function->scope()->outer_scope();
  bool should_hoist = true;

  // It is not sufficient to just do a Lookup on query_scope: for
  // example, that does not prevent hoisting of the function in
  // `{ let e; try {} catch (e) { function e(){} } }`
  //
  // Don't use a generic cache scope, as the cache scope would be the outer
  // scope and we terminate the iteration there anyway.
  do {
    Variable* var = query_scope->LookupInScopeOrScopeInfo(name, query_scope);
    if (var != nullptr && IsLexicalVariableMode(var->mode())) {
      should_hoist = false;
      break;
    }
    query_scope = query_scope->outer_scope();
  } while (query_scope != outer_scope);

  if (!should_hoist) continue;

  if (factory) {
    DCHECK(!is_being_lazily_parsed_)((void) 0);
    int pos = sloppy_block_function->position();
    bool ok = true;
    bool was_added;
    auto declaration = factory->NewVariableDeclaration(pos);
    // Based on the preceding checks, it doesn't matter what we pass as
    // sloppy_mode_block_scope_function_redefinition.
    Variable* var = DeclareVariable(
        declaration, name, pos, VariableMode::kVar, NORMAL_VARIABLE,
        Variable::DefaultInitializationFlag(VariableMode::kVar), &was_added,
        nullptr, &ok);
    DCHECK(ok)((void) 0);
    VariableProxy* source =
        factory->NewVariableProxy(sloppy_block_function->var());
    VariableProxy* target = factory->NewVariableProxy(var);
    Assignment* assignment = factory->NewAssignment(
        sloppy_block_function->init(), target, source, pos);
    assignment->set_lookup_hoisting_mode(LookupHoistingMode::kLegacySloppy);
    Statement* statement = factory->NewExpressionStatement(assignment, pos);
    sloppy_block_function->set_statement(statement);
  } else {
    DCHECK(is_being_lazily_parsed_)((void) 0);
    bool was_added;
    Variable* var = DeclareVariableName(name, VariableMode::kVar, &was_added);
    if (sloppy_block_function->init() == Token::ASSIGN) {
      var->SetMaybeAssigned();
    }
  }
}
677}

679bool DeclarationScope::Analyze(ParseInfo* info) {
RCS_SCOPE(info->runtime_call_stats(),
          RuntimeCallCounterId::kCompileScopeAnalysis,
          RuntimeCallStats::kThreadSpecific);
DCHECK_NOT_NULL(info->literal())((void) 0);
DeclarationScope* scope = info->literal()->scope();

base::Optional<AllowHandleDereference> allow_deref;
687#ifdef DEBUG
if (scope->outer_scope() && !scope->outer_scope()->scope_info_.is_null()) {
  allow_deref.emplace();
}
691#endif

if (scope->is_eval_scope() && is_sloppy(scope->language_mode())) {
  AstNodeFactory factory(info->ast_value_factory(), info->zone());
  scope->HoistSloppyBlockFunctions(&factory);
}

// We are compiling one of four cases:
// 1) top-level code,
// 2) a function/eval/module on the top-level
// 4) a class member initializer function scope
// 3) 4 function/eval in a scope that was already resolved.
DCHECK(scope->is_script_scope() || scope->outer_scope()->is_script_scope() ||((void) 0)
       scope->IsReparsedMemberInitializerScope() ||((void) 0)
       scope->outer_scope()->already_resolved_)((void) 0);

// The outer scope is never lazy.
scope->set_should_eager_compile();

if (scope->must_use_preparsed_scope_data_) {
  DCHECK_EQ(scope->scope_type_, ScopeType::FUNCTION_SCOPE)((void) 0);
  allow_deref.emplace();
  info->consumed_preparse_data()->RestoreScopeAllocationData(
      scope, info->ast_value_factory(), info->zone());
}

if (!scope->AllocateVariables(info)) return false;
scope->GetScriptScope()->RewriteReplGlobalVariables();

720#ifdef DEBUG
if (FLAG_print_scopes) {
  PrintF("Global scope:\n");
  scope->Print();
}
scope->CheckScopePositions();
scope->CheckZones();
727#endif

return true;
730}

732void DeclarationScope::DeclareThis(AstValueFactory* ast_value_factory) {
DCHECK(has_this_declaration())((void) 0);

bool derived_constructor = IsDerivedConstructor(function_kind_);

receiver_ = zone()->New<Variable>(
    this, ast_value_factory->this_string(),
    derived_constructor ? VariableMode::kConst : VariableMode::kVar,
    THIS_VARIABLE,
    derived_constructor ? kNeedsInitialization : kCreatedInitialized,
    kNotAssigned);
locals_.Add(receiver_);
744}

746void DeclarationScope::DeclareArguments(AstValueFactory* ast_value_factory) {
DCHECK(is_function_scope())((void) 0);
DCHECK(!is_arrow_scope())((void) 0);

// Because when arguments_ is not nullptr, we already declared
// "arguments exotic object" to add it into parameters before
// impl()->InsertShadowingVarBindingInitializers, so here
// only declare "arguments exotic object" when arguments_
// is nullptr
if (arguments_ != nullptr) {
  return;
}

// Declare 'arguments' variable which exists in all non arrow functions.  Note
// that it might never be accessed, in which case it won't be allocated during
// variable allocation.
bool was_added = false;

arguments_ =
    Declare(zone(), ast_value_factory->arguments_string(), VariableMode::kVar,
            NORMAL_VARIABLE, kCreatedInitialized, kNotAssigned, &was_added);
// According to ES#sec-functiondeclarationinstantiation step 18
// we should set argumentsObjectNeeded to false if has lexical
// declared arguments only when hasParameterExpressions is false
if (!was_added && IsLexicalVariableMode(arguments_->mode()) &&
    has_simple_parameters_) {
  // Check if there's lexically declared variable named arguments to avoid
  // redeclaration. See ES#sec-functiondeclarationinstantiation, step 20.
  arguments_ = nullptr;
}
776}

778void DeclarationScope::DeclareDefaultFunctionVariables(
  AstValueFactory* ast_value_factory) {
DCHECK(is_function_scope())((void) 0);
DCHECK(!is_arrow_scope())((void) 0);

DeclareThis(ast_value_factory);
bool was_added;
new_target_ = Declare(zone(), ast_value_factory->new_target_string(),
                      VariableMode::kConst, NORMAL_VARIABLE,
                      kCreatedInitialized, kNotAssigned, &was_added);
DCHECK(was_added)((void) 0);

if (IsConciseMethod(function_kind_) || IsClassConstructor(function_kind_) ||
    IsAccessorFunction(function_kind_)) {
  EnsureRareData()->this_function = Declare(
      zone(), ast_value_factory->this_function_string(), VariableMode::kConst,
      NORMAL_VARIABLE, kCreatedInitialized, kNotAssigned, &was_added);
  DCHECK(was_added)((void) 0);
}
797}

799Variable* DeclarationScope::DeclareFunctionVar(const AstRawString* name,
                                             Scope* cache) {
DCHECK(is_function_scope())((void) 0);
DCHECK_NULL(function_)((void) 0);
if (cache == nullptr) cache = this;
DCHECK(this->IsOuterScopeOf(cache))((void) 0);
DCHECK_NULL(cache->variables_.Lookup(name))((void) 0);
VariableKind kind = is_sloppy(language_mode()) ? SLOPPY_FUNCTION_NAME_VARIABLE
                                               : NORMAL_VARIABLE;
function_ = zone()->New<Variable>(this, name, VariableMode::kConst, kind,
                                  kCreatedInitialized);
if (sloppy_eval_can_extend_vars()) {
  cache->NonLocal(name, VariableMode::kDynamic);
} else {
  cache->variables_.Add(function_);
}
return function_;
816}

818Variable* DeclarationScope::DeclareGeneratorObjectVar(
  const AstRawString* name) {
DCHECK(is_function_scope() || is_module_scope() || is_repl_mode_scope())((void) 0);
DCHECK_NULL(generator_object_var())((void) 0);

Variable* result = EnsureRareData()->generator_object =
    NewTemporary(name, kNotAssigned);
result->set_is_used();
return result;
827}

829Scope* Scope::FinalizeBlockScope() {
DCHECK(is_block_scope())((void) 0);
831#ifdef DEBUG
DCHECK_NE(sibling_, this)((void) 0);
833#endif

if (variables_.occupancy() > 0 ||
    (is_declaration_scope() &&
     AsDeclarationScope()->sloppy_eval_can_extend_vars())) {
  return this;
}

DCHECK(!is_class_scope())((void) 0);

// Remove this scope from outer scope.
outer_scope()->RemoveInnerScope(this);

// Reparent inner scopes.
if (inner_scope_ != nullptr) {
  Scope* scope = inner_scope_;
  scope->outer_scope_ = outer_scope();
  while (scope->sibling_ != nullptr) {
    scope = scope->sibling_;
    scope->outer_scope_ = outer_scope();
  }
  scope->sibling_ = outer_scope()->inner_scope_;
  outer_scope()->inner_scope_ = inner_scope_;
  inner_scope_ = nullptr;
}

// Move unresolved variables
if (!unresolved_list_.is_empty()) {
  outer_scope()->unresolved_list_.Prepend(std::move(unresolved_list_));
  unresolved_list_.Clear();
}

if (inner_scope_calls_eval_) outer_scope()->inner_scope_calls_eval_ = true;

// No need to propagate sloppy_eval_can_extend_vars_, since if it was relevant
// to this scope we would have had to bail out at the top.
DCHECK(!is_declaration_scope() ||((void) 0)
       !AsDeclarationScope()->sloppy_eval_can_extend_vars())((void) 0);

// This block does not need a context.
num_heap_slots_ = 0;

// Mark scope as removed by making it its own sibling.
876#ifdef DEBUG
sibling_ = this;
878#endif

return nullptr;
881}

883void DeclarationScope::AddLocal(Variable* var) {
DCHECK(!already_resolved_)((void) 0);
// Temporaries are only placed in ClosureScopes.
DCHECK_EQ(GetClosureScope(), this)((void) 0);
locals_.Add(var);
888}

890void Scope::Snapshot::Reparent(DeclarationScope* new_parent) {
DCHECK(!IsCleared())((void) 0);
DCHECK_EQ(new_parent, outer_scope_and_calls_eval_.GetPointer()->inner_scope_)((void) 0);
DCHECK_EQ(new_parent->outer_scope_, outer_scope_and_calls_eval_.GetPointer())((void) 0);
DCHECK_EQ(new_parent, new_parent->GetClosureScope())((void) 0);
DCHECK_NULL(new_parent->inner_scope_)((void) 0);
DCHECK(new_parent->unresolved_list_.is_empty())((void) 0);
Scope* inner_scope = new_parent->sibling_;
if (inner_scope != top_inner_scope_) {
  for (; inner_scope->sibling() != top_inner_scope_;
       inner_scope = inner_scope->sibling()) {
    inner_scope->outer_scope_ = new_parent;
    if (inner_scope->inner_scope_calls_eval_) {
      new_parent->inner_scope_calls_eval_ = true;
    }
    DCHECK_NE(inner_scope, new_parent)((void) 0);
  }
  inner_scope->outer_scope_ = new_parent;
  if (inner_scope->inner_scope_calls_eval_) {
    new_parent->inner_scope_calls_eval_ = true;
  }
  new_parent->inner_scope_ = new_parent->sibling_;
  inner_scope->sibling_ = nullptr;
  // Reset the sibling rather than the inner_scope_ since we
  // want to keep new_parent there.
  new_parent->sibling_ = top_inner_scope_;
}

Scope* outer_scope = outer_scope_and_calls_eval_.GetPointer();
new_parent->unresolved_list_.MoveTail(&outer_scope->unresolved_list_,
                                      top_unresolved_);

// Move temporaries allocated for complex parameter initializers.
DeclarationScope* outer_closure = outer_scope->GetClosureScope();
for (auto it = top_local_; it != outer_closure->locals()->end(); ++it) {
  Variable* local = *it;
  DCHECK_EQ(VariableMode::kTemporary, local->mode())((void) 0);
  DCHECK_EQ(local->scope(), local->scope()->GetClosureScope())((void) 0);
  DCHECK_NE(local->scope(), new_parent)((void) 0);
  local->set_scope(new_parent);
}
new_parent->locals_.MoveTail(outer_closure->locals(), top_local_);
outer_closure->locals_.Rewind(top_local_);

// Move eval calls since Snapshot's creation into new_parent.
if (outer_scope_and_calls_eval_->calls_eval_) {
  new_parent->RecordDeclarationScopeEvalCall();
  new_parent->inner_scope_calls_eval_ = true;
}

// We are in the arrow function case. The calls eval we may have recorded
// is intended for the inner scope and we should simply restore the
// original "calls eval" flag of the outer scope.
RestoreEvalFlag();
Clear();
945}

947void Scope::ReplaceOuterScope(Scope* outer) {
DCHECK_NOT_NULL(outer)((void) 0);
DCHECK_NOT_NULL(outer_scope_)((void) 0);
DCHECK(!already_resolved_)((void) 0);
outer_scope_->RemoveInnerScope(this);
outer->AddInnerScope(this);
outer_scope_ = outer;
954}

956Variable* Scope::LookupInScopeInfo(const AstRawString* name, Scope* cache) {
DCHECK(!scope_info_.is_null())((void) 0);
DCHECK(this->IsOuterScopeOf(cache))((void) 0);
DCHECK(!cache->deserialized_scope_uses_external_cache())((void) 0);
// The case where where the cache can be another scope is when the cache scope
// is the last scope that doesn't use an external cache.
DCHECK_IMPLIES(((void) 0)
    cache != this,((void) 0)
    cache->outer_scope()->deserialized_scope_uses_external_cache())((void) 0);
DCHECK_NULL(cache->variables_.Lookup(name))((void) 0);
DisallowGarbageCollection no_gc;

String name_handle = *name->string();
ScopeInfo scope_info = *scope_info_;
// The Scope is backed up by ScopeInfo. This means it cannot operate in a
// heap-independent mode, and all strings must be internalized immediately. So
// it's ok to get the Handle<String> here.
bool found = false;

VariableLocation location;
int index;
VariableLookupResult lookup_result;

{
  location = VariableLocation::CONTEXT;
  index = scope_info.ContextSlotIndex(name->string(), &lookup_result);
  found = index >= 0;
}

if (!found && is_module_scope()) {
  location = VariableLocation::MODULE;
  index = scope_info.ModuleIndex(name_handle, &lookup_result.mode,
                                 &lookup_result.init_flag,
                                 &lookup_result.maybe_assigned_flag);
  found = index != 0;
}

if (!found) {
  index = scope_info.FunctionContextSlotIndex(name_handle);
  if (index < 0) return nullptr;  // Nowhere found.
  Variable* var = AsDeclarationScope()->DeclareFunctionVar(name, cache);
  DCHECK_EQ(VariableMode::kConst, var->mode())((void) 0);
  var->AllocateTo(VariableLocation::CONTEXT, index);
  return cache->variables_.Lookup(name);
}

if (!is_module_scope()) {
  DCHECK_NE(index, scope_info.ReceiverContextSlotIndex())((void) 0);
}

bool was_added;
Variable* var = cache->variables_.Declare(
    zone(), this, name, lookup_result.mode, NORMAL_VARIABLE,
    lookup_result.init_flag, lookup_result.maybe_assigned_flag,
    IsStaticFlag::kNotStatic, &was_added);
DCHECK(was_added)((void) 0);
var->AllocateTo(location, index);
return var;
1014}

1016Variable* DeclarationScope::DeclareParameter(const AstRawString* name,
                                           VariableMode mode,
                                           bool is_optional, bool is_rest,
                                           AstValueFactory* ast_value_factory,
                                           int position) {
DCHECK(!already_resolved_)((void) 0);
DCHECK(is_function_scope() || is_module_scope())((void) 0);
DCHECK(!has_rest_)((void) 0);
DCHECK(!is_optional || !is_rest)((void) 0);
DCHECK(!is_being_lazily_parsed_)((void) 0);
DCHECK(!was_lazily_parsed_)((void) 0);
Variable* var;
if (mode == VariableMode::kTemporary) {
  var = NewTemporary(name);
} else {
  var = LookupLocal(name);
  DCHECK_EQ(mode, VariableMode::kVar)((void) 0);
  DCHECK(var->is_parameter())((void) 0);
}
has_rest_ = is_rest;
var->set_initializer_position(position);
params_.Add(var, zone());
if (!is_rest) ++num_parameters_;
if (name == ast_value_factory->arguments_string()) {
  has_arguments_parameter_ = true;
}
// Params are automatically marked as used to make sure that the debugger and
// function.arguments sees them.
// TODO(verwaest): Reevaluate whether we always need to do this, since
// strict-mode function.arguments does not make the arguments available.
var->set_is_used();
return var;
1048}

1050void DeclarationScope::RecordParameter(bool is_rest) {
DCHECK(!already_resolved_)((void) 0);
DCHECK(is_function_scope() || is_module_scope())((void) 0);
DCHECK(is_being_lazily_parsed_)((void) 0);
DCHECK(!has_rest_)((void) 0);
has_rest_ = is_rest;
if (!is_rest) ++num_parameters_;
1057}

1059Variable* Scope::DeclareLocal(const AstRawString* name, VariableMode mode,
                            VariableKind kind, bool* was_added,
                            InitializationFlag init_flag) {
DCHECK(!already_resolved_)((void) 0);
// Private methods should be declared with ClassScope::DeclarePrivateName()
DCHECK(!IsPrivateMethodOrAccessorVariableMode(mode))((void) 0);
// This function handles VariableMode::kVar, VariableMode::kLet, and
// VariableMode::kConst modes.  VariableMode::kDynamic variables are
// introduced during variable allocation, and VariableMode::kTemporary
// variables are allocated via NewTemporary().
DCHECK(IsDeclaredVariableMode(mode))((void) 0);
DCHECK_IMPLIES(GetDeclarationScope()->is_being_lazily_parsed(),((void) 0)
               mode == VariableMode::kVar || mode == VariableMode::kLet ||((void) 0)
                   mode == VariableMode::kConst)((void) 0);
DCHECK(!GetDeclarationScope()->was_lazily_parsed())((void) 0);
Variable* var =
    Declare(zone(), name, mode, kind, init_flag, kNotAssigned, was_added);

// Pessimistically assume that top-level variables will be assigned and used.
//
// Top-level variables in a script can be accessed by other scripts or even
// become global properties. While this does not apply to top-level variables
// in a module (assuming they are not exported), we must still mark these as
// assigned because they might be accessed by a lazily parsed top-level
// function, which, for efficiency, we preparse without variable tracking.
if (is_script_scope() || is_module_scope()) {
  if (mode != VariableMode::kConst) var->SetMaybeAssigned();
  var->set_is_used();
}

return var;
1090}

1092Variable* Scope::DeclareVariable(
  Declaration* declaration, const AstRawString* name, int pos,
  VariableMode mode, VariableKind kind, InitializationFlag init,
  bool* was_added, bool* sloppy_mode_block_scope_function_redefinition,
  bool* ok) {
// Private methods should be declared with ClassScope::DeclarePrivateName()
DCHECK(!IsPrivateMethodOrAccessorVariableMode(mode))((void) 0);
DCHECK(IsDeclaredVariableMode(mode))((void) 0);
DCHECK(!already_resolved_)((void) 0);
DCHECK(!GetDeclarationScope()->is_being_lazily_parsed())((void) 0);
DCHECK(!GetDeclarationScope()->was_lazily_parsed())((void) 0);

if (mode == VariableMode::kVar && !is_declaration_scope()) {
  return GetDeclarationScope()->DeclareVariable(
      declaration, name, pos, mode, kind, init, was_added,
      sloppy_mode_block_scope_function_redefinition, ok);
}
DCHECK(!is_catch_scope())((void) 0);
DCHECK(!is_with_scope())((void) 0);
DCHECK(is_declaration_scope() ||((void) 0)
       (IsLexicalVariableMode(mode) && is_block_scope()))((void) 0);

DCHECK_NOT_NULL(name)((void) 0);

Variable* var = LookupLocal(name);
// Declare the variable in the declaration scope.
*was_added = var == nullptr;
if (V8_LIKELY(*was_added)(__builtin_expect(!!(*was_added), 1))) {
  if (V8_UNLIKELY(is_eval_scope() && is_sloppy(language_mode()) &&(__builtin_expect(!!(is_eval_scope() && is_sloppy(language_mode
()) && mode == VariableMode::kVar), 0))
                  mode == VariableMode::kVar)(__builtin_expect(!!(is_eval_scope() && is_sloppy(language_mode
()) && mode == VariableMode::kVar), 0))) {
    // In a var binding in a sloppy direct eval, pollute the enclosing scope
    // with this new binding by doing the following:
    // The proxy is bound to a lookup variable to force a dynamic declaration
    // using the DeclareEvalVar or DeclareEvalFunction runtime functions.
    DCHECK_EQ(NORMAL_VARIABLE, kind)((void) 0);
    var = NonLocal(name, VariableMode::kDynamic);
    // Mark the var as used in case anyone outside the eval wants to use it.
    var->set_is_used();
  } else {
    // Declare the name.
    var = DeclareLocal(name, mode, kind, was_added, init);
    DCHECK(*was_added)((void) 0);
  }
} else {
  var->SetMaybeAssigned();
  if (V8_UNLIKELY(IsLexicalVariableMode(mode) ||(__builtin_expect(!!(IsLexicalVariableMode(mode) || IsLexicalVariableMode
(var->mode())), 0))
                  IsLexicalVariableMode(var->mode()))(__builtin_expect(!!(IsLexicalVariableMode(mode) || IsLexicalVariableMode
(var->mode())), 0))) {
    // The name was declared in this scope before; check for conflicting
    // re-declarations. We have a conflict if either of the declarations is
    // not a var (in script scope, we also have to ignore legacy const for
    // compatibility). There is similar code in runtime.cc in the Declare
    // functions. The function CheckConflictingVarDeclarations checks for
    // var and let bindings from different scopes whereas this is a check
    // for conflicting declarations within the same scope. This check also
    // covers the special case
    //
    // function () { let x; { var x; } }
    //
    // because the var declaration is hoisted to the function scope where
    // 'x' is already bound.
    //
    // In harmony we treat re-declarations as early errors. See ES5 16 for a
    // definition of early errors.
    //
    // Allow duplicate function decls for web compat, see bug 4693.
    *ok = var->is_sloppy_block_function() &&
          kind == SLOPPY_BLOCK_FUNCTION_VARIABLE;
    *sloppy_mode_block_scope_function_redefinition = *ok;
  }
}
DCHECK_NOT_NULL(var)((void) 0);

// We add a declaration node for every declaration. The compiler
// will only generate code if necessary. In particular, declarations
// for inner local variables that do not represent functions won't
// result in any generated code.
//
// This will lead to multiple declaration nodes for the
// same variable if it is declared several times. This is not a
// semantic issue, but it may be a performance issue since it may
// lead to repeated DeclareEvalVar or DeclareEvalFunction calls.
decls_.Add(declaration);
declaration->set_var(var);
return var;
1176}

1178Variable* Scope::DeclareVariableName(const AstRawString* name,
                                   VariableMode mode, bool* was_added,
                                   VariableKind kind) {
DCHECK(IsDeclaredVariableMode(mode))((void) 0);
DCHECK(!already_resolved_)((void) 0);
DCHECK(GetDeclarationScope()->is_being_lazily_parsed())((void) 0);
// Private methods should be declared with ClassScope::DeclarePrivateName()
DCHECK(!IsPrivateMethodOrAccessorVariableMode(mode))((void) 0);
if (mode == VariableMode::kVar && !is_declaration_scope()) {
  return GetDeclarationScope()->DeclareVariableName(name, mode, was_added,
                                                    kind);
}
DCHECK(!is_with_scope())((void) 0);
DCHECK(!is_eval_scope())((void) 0);
DCHECK(is_declaration_scope() || IsLexicalVariableMode(mode))((void) 0);
DCHECK(scope_info_.is_null())((void) 0);

// Declare the variable in the declaration scope.
Variable* var = DeclareLocal(name, mode, kind, was_added);
if (!*was_added) {
  if (IsLexicalVariableMode(mode) || IsLexicalVariableMode(var->mode())) {
    if (!var->is_sloppy_block_function() ||
        kind != SLOPPY_BLOCK_FUNCTION_VARIABLE) {
      // Duplicate functions are allowed in the sloppy mode, but if this is
      // not a function declaration, it's an error. This is an error PreParser
      // hasn't previously detected.
      return nullptr;
    }
    // Sloppy block function redefinition.
  }
  var->SetMaybeAssigned();
}
var->set_is_used();
return var;
1212}

1214Variable* Scope::DeclareCatchVariableName(const AstRawString* name) {
DCHECK(!already_resolved_)((void) 0);
DCHECK(is_catch_scope())((void) 0);
DCHECK(scope_info_.is_null())((void) 0);

bool was_added;
Variable* result = Declare(zone(), name, VariableMode::kVar, NORMAL_VARIABLE,
                           kCreatedInitialized, kNotAssigned, &was_added);
DCHECK(was_added)((void) 0);
return result;
1224}

1226void Scope::AddUnresolved(VariableProxy* proxy) {
DCHECK(!already_resolved_)((void) 0);
DCHECK(!proxy->is_resolved())((void) 0);
unresolved_list_.Add(proxy);
1230}

1232Variable* DeclarationScope::DeclareDynamicGlobal(const AstRawString* name,
                                               VariableKind kind,
                                               Scope* cache) {
DCHECK(is_script_scope())((void) 0);
bool was_added;
return cache->variables_.Declare(
    zone(), this, name, VariableMode::kDynamicGlobal, kind,
    kCreatedInitialized, kNotAssigned, IsStaticFlag::kNotStatic, &was_added);
// TODO(neis): Mark variable as maybe-assigned?
1241}

1243bool Scope::RemoveUnresolved(VariableProxy* var) {
return unresolved_list_.Remove(var);
1245}

1247void Scope::DeleteUnresolved(VariableProxy* var) {
DCHECK(unresolved_list_.Contains(var))((void) 0);
var->mark_removed_from_unresolved();
1250}

1252Variable* Scope::NewTemporary(const AstRawString* name) {
return NewTemporary(name, kMaybeAssigned);
1254}

1256Variable* Scope::NewTemporary(const AstRawString* name,
                            MaybeAssignedFlag maybe_assigned) {
DeclarationScope* scope = GetClosureScope();
Variable* var = zone()->New<Variable>(scope, name, VariableMode::kTemporary,
                                      NORMAL_VARIABLE, kCreatedInitialized);
scope->AddLocal(var);
if (maybe_assigned == kMaybeAssigned) var->SetMaybeAssigned();
return var;
1264}

1266Declaration* DeclarationScope::CheckConflictingVarDeclarations(
  bool* allowed_catch_binding_var_redeclaration) {
if (has_checked_syntax_) return nullptr;
for (Declaration* decl : decls_) {
  // Lexical vs lexical conflicts within the same scope have already been
  // captured in Parser::Declare. The only conflicts we still need to check
  // are lexical vs nested var.
  if (decl->IsVariableDeclaration() &&
      decl->AsVariableDeclaration()->AsNested() != nullptr) {
    Scope* current = decl->AsVariableDeclaration()->AsNested()->scope();
    DCHECK(decl->var()->mode() == VariableMode::kVar ||((void) 0)
           decl->var()->mode() == VariableMode::kDynamic)((void) 0);
    // Iterate through all scopes until the declaration scope.
    do {
      // There is a conflict if there exists a non-VAR binding.
      Variable* other_var = current->LookupLocal(decl->var()->raw_name());
      if (current->is_catch_scope()) {
        *allowed_catch_binding_var_redeclaration |= other_var != nullptr;
        current = current->outer_scope();
        continue;
      }
      if (other_var != nullptr) {
        DCHECK(IsLexicalVariableMode(other_var->mode()))((void) 0);
        return decl;
      }
      current = current->outer_scope();
    } while (current != this);
  }
}

if (V8_LIKELY(!is_eval_scope())(__builtin_expect(!!(!is_eval_scope()), 1))) return nullptr;
if (!is_sloppy(language_mode())) return nullptr;

// Var declarations in sloppy eval are hoisted to the first non-eval
// declaration scope. Check for conflicts between the eval scope that
// declaration scope.
Scope* end = outer_scope()->GetNonEvalDeclarationScope()->outer_scope();

for (Declaration* decl : decls_) {
  if (IsLexicalVariableMode(decl->var()->mode())) continue;
  Scope* current = outer_scope_;
  // Iterate through all scopes until and including the declaration scope.
  do {
    // There is a conflict if there exists a non-VAR binding up to the
    // declaration scope in which this sloppy-eval runs.
    //
    // Use the current scope as the cache, since the general cache would be
    // the end scope.
    Variable* other_var =
        current->LookupInScopeOrScopeInfo(decl->var()->raw_name(), current);
    if (other_var != nullptr && !current->is_catch_scope()) {
      // If this is a VAR, then we know that it doesn't conflict with
      // anything, so we can't conflict with anything either. The one
      // exception is the binding variable in catch scopes, which is handled
      // by the if above.
      if (!IsLexicalVariableMode(other_var->mode())) break;
      return decl;
    }
    current = current->outer_scope();
  } while (current != end);
}
return nullptr;
1328}

1330const AstRawString* Scope::FindVariableDeclaredIn(Scope* scope,
                                                VariableMode mode_limit) {
const VariableMap& variables = scope->variables_;
for (ZoneHashMap::Entry* p = variables.Start(); p != nullptr;
     p = variables.Next(p)) {
  const AstRawString* name = static_cast<const AstRawString*>(p->key);
  Variable* var = LookupLocal(name);
  if (var != nullptr && var->mode() <= mode_limit) return name;
}
return nullptr;
1340}

1342void DeclarationScope::DeserializeReceiver(AstValueFactory* ast_value_factory) {
if (is_script_scope()) {
  DCHECK_NOT_NULL(receiver_)((void) 0);
  return;
}
DCHECK(has_this_declaration())((void) 0);
DeclareThis(ast_value_factory);
if (is_debug_evaluate_scope()) {
  receiver_->AllocateTo(VariableLocation::LOOKUP, -1);
} else {
  receiver_->AllocateTo(VariableLocation::CONTEXT,
                        scope_info_->ReceiverContextSlotIndex());
}
1355}

1357bool DeclarationScope::AllocateVariables(ParseInfo* info) {
// Module variables must be allocated before variable resolution
// to ensure that UpdateNeedsHoleCheck() can detect import variables.
if (is_module_scope()) AsModuleScope()->AllocateModuleVariables();

PrivateNameScopeIterator private_name_scope_iter(this);
if (!private_name_scope_iter.Done() &&
    !private_name_scope_iter.GetScope()->ResolvePrivateNames(info)) {
  DCHECK(info->pending_error_handler()->has_pending_error())((void) 0);
  return false;
}

if (!ResolveVariablesRecursively(info->scope())) {
  DCHECK(info->pending_error_handler()->has_pending_error())((void) 0);
  return false;
}

// Don't allocate variables of preparsed scopes.
if (!was_lazily_parsed()) AllocateVariablesRecursively();

return true;
1378}

1380bool Scope::HasThisReference() const {
if (is_declaration_scope() && AsDeclarationScope()->has_this_reference()) {
  return true;
}

for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
  if (!scope->is_declaration_scope() ||
      !scope->AsDeclarationScope()->has_this_declaration()) {
    if (scope->HasThisReference()) return true;
  }
}

return false;
1393}

1395bool Scope::AllowsLazyParsingWithoutUnresolvedVariables(
  const Scope* outer) const {
// If none of the outer scopes need to decide whether to context allocate
// specific variables, we can preparse inner functions without unresolved
// variables. Otherwise we need to find unresolved variables to force context
// allocation of the matching declarations. We can stop at the outer scope for
// the parse, since context allocation of those variables is already
// guaranteed to be correct.
for (const Scope* s = this; s != outer; s = s->outer_scope_) {
  // Eval forces context allocation on all outer scopes, so we don't need to
  // look at those scopes. Sloppy eval makes top-level non-lexical variables
  // dynamic, whereas strict-mode requires context allocation.
  if (s->is_eval_scope()) return is_sloppy(s->language_mode());
  // Catch scopes force context allocation of all variables.
  if (s->is_catch_scope()) continue;
  // With scopes do not introduce variables that need allocation.
  if (s->is_with_scope()) continue;
  DCHECK(s->is_module_scope() || s->is_block_scope() ||((void) 0)
         s->is_function_scope())((void) 0);
  return false;
}
return true;
1417}

1419bool DeclarationScope::AllowsLazyCompilation() const {
// Functions which force eager compilation and class member initializer
// functions are not lazily compilable.
return !force_eager_compilation_ &&
       !IsClassMembersInitializerFunction(function_kind());
1424}

1426int Scope::ContextChainLength(Scope* scope) const {
int n = 0;
for (const Scope* s = this; s != scope; s = s->outer_scope_) {
  DCHECK_NOT_NULL(s)((void) 0);  // scope must be in the scope chain
  if (s->NeedsContext()) n++;
}
return n;
1433}

1435int Scope::ContextChainLengthUntilOutermostSloppyEval() const {
int result = 0;
int length = 0;

for (const Scope* s = this; s != nullptr; s = s->outer_scope()) {
  if (!s->NeedsContext()) continue;
  length++;
  if (s->is_declaration_scope() &&
      s->AsDeclarationScope()->sloppy_eval_can_extend_vars()) {
    result = length;
  }
}

return result;
1449}

1451DeclarationScope* Scope::GetDeclarationScope() {
Scope* scope = this;
while (!scope->is_declaration_scope()) {
  scope = scope->outer_scope();
}
return scope->AsDeclarationScope();
1457}

1459DeclarationScope* Scope::GetNonEvalDeclarationScope() {
Scope* scope = this;
while (!scope->is_declaration_scope() || scope->is_eval_scope()) {
  scope = scope->outer_scope();
}
return scope->AsDeclarationScope();
1465}

1467const DeclarationScope* Scope::GetClosureScope() const {
const Scope* scope = this;
while (!scope->is_declaration_scope() || scope->is_block_scope()) {
  scope = scope->outer_scope();
}
return scope->AsDeclarationScope();
1473}

1475DeclarationScope* Scope::GetClosureScope() {
Scope* scope = this;
while (!scope->is_declaration_scope() || scope->is_block_scope()) {
  scope = scope->outer_scope();
}
return scope->AsDeclarationScope();
1481}

1483bool Scope::NeedsScopeInfo() const {
DCHECK(!already_resolved_)((void) 0);
DCHECK(GetClosureScope()->ShouldEagerCompile())((void) 0);
// The debugger expects all functions to have scope infos.
// TODO(yangguo): Remove this requirement.
if (is_function_scope()) return true;
return NeedsContext();
1490}

1492bool Scope::ShouldBanArguments() {
return GetReceiverScope()->should_ban_arguments();
1494}

1496DeclarationScope* Scope::GetReceiverScope() {
Scope* scope = this;
while (!scope->is_declaration_scope() ||
       (!scope->is_script_scope() &&
        !scope->AsDeclarationScope()->has_this_declaration())) {
  scope = scope->outer_scope();
}
return scope->AsDeclarationScope();
1504}

1506DeclarationScope* Scope::GetConstructorScope() {
Scope* scope = this;
while (scope != nullptr && !scope->IsConstructorScope()) {
  scope = scope->outer_scope();
}
if (scope == nullptr) {
  return nullptr;
}
DCHECK(scope->IsConstructorScope())((void) 0);
return scope->AsDeclarationScope();
1516}

1518Scope* Scope::GetHomeObjectScope() {
Scope* scope = this;
while (scope != nullptr && !scope->is_home_object_scope()) {
  if (scope->is_function_scope()) {
    FunctionKind function_kind = scope->AsDeclarationScope()->function_kind();
    // "super" in arrow functions binds outside the arrow function. But if we
    // find a function which doesn't bind "super" (is not a method etc.) and
    // not an arrow function, we know "super" here doesn't bind anywhere and
    // we can return nullptr.
    if (!IsArrowFunction(function_kind) && !BindsSuper(function_kind)) {
      return nullptr;
    }
  }
  if (scope->private_name_lookup_skips_outer_class()) {
    DCHECK(scope->outer_scope()->is_class_scope())((void) 0);
    scope = scope->outer_scope()->outer_scope();
  } else {
    scope = scope->outer_scope();
  }
}
return scope;
1539}

1541DeclarationScope* Scope::GetScriptScope() {
Scope* scope = this;
while (!scope->is_script_scope()) {
  scope = scope->outer_scope();
}
return scope->AsDeclarationScope();
1547}

1549Scope* Scope::GetOuterScopeWithContext() {
Scope* scope = outer_scope_;
while (scope && !scope->NeedsContext()) {
  scope = scope->outer_scope();
}
return scope;
1555}

1557namespace {
1558bool WasLazilyParsed(Scope* scope) {
return scope->is_declaration_scope() &&
       scope->AsDeclarationScope()->was_lazily_parsed();
1561}

1563}  // namespace

1565template <typename FunctionType>
1566void Scope::ForEach(FunctionType callback) {
Scope* scope = this;
while (true) {
3
←
Loop condition is true.  Entering loop body→
6
←
Loop condition is true.  Entering loop body→
  Iteration iteration = callback(scope);
7
←
Calling 'operator()'→
  // Try to descend into inner scopes first.
  if ((iteration3.1
'iteration' is equal to kDescend
 == Iteration::kDescend) && scope->inner_scope_ != nullptr) {
4
←
Assuming the condition is true→
5
←
Taking true branch→
    scope = scope->inner_scope_;
  } else {
    // Find the next outer scope with a sibling.
    while (scope->sibling_ == nullptr) {
      if (scope == this) return;
      scope = scope->outer_scope_;
    }
    if (scope == this) return;
    scope = scope->sibling_;
  }
}
1583}

1585bool Scope::IsConstructorScope() const {
return is_declaration_scope() &&
       IsClassConstructor(AsDeclarationScope()->function_kind());
1588}

1590bool Scope::IsOuterScopeOf(Scope* other) const {
Scope* scope = other;
while (scope) {
  if (scope == this) return true;
  scope = scope->outer_scope();
}
return false;
1597}

1599void Scope::CollectNonLocals(DeclarationScope* max_outer_scope,
                           Isolate* isolate, Handle<StringSet>* non_locals) {
this->ForEach([max_outer_scope, isolate, non_locals](Scope* scope) {
  // Module variables must be allocated before variable resolution
  // to ensure that UpdateNeedsHoleCheck() can detect import variables.
  if (scope->is_module_scope()) {
    scope->AsModuleScope()->AllocateModuleVariables();
  }

  // Lazy parsed declaration scopes are already partially analyzed. If there
  // are unresolved references remaining, they just need to be resolved in
  // outer scopes.
  Scope* lookup = WasLazilyParsed(scope) ? scope->outer_scope() : scope;

  for (VariableProxy* proxy : scope->unresolved_list_) {
    DCHECK(!proxy->is_resolved())((void) 0);
    Variable* var =
        Lookup<kParsedScope>(proxy, lookup, max_outer_scope->outer_scope());
    if (var == nullptr) {
      *non_locals = StringSet::Add(isolate, *non_locals, proxy->name());
    } else {
      // In this case we need to leave scopes in a way that they can be
      // allocated. If we resolved variables from lazy parsed scopes, we need
      // to context allocate the var.
      scope->ResolveTo(proxy, var);
      if (!var->is_dynamic() && lookup != scope)
        var->ForceContextAllocation();
    }
  }

  // Clear unresolved_list_ as it's in an inconsistent state.
  scope->unresolved_list_.Clear();
  return Iteration::kDescend;
});
1633}

1635void Scope::AnalyzePartially(DeclarationScope* max_outer_scope,
                           AstNodeFactory* ast_node_factory,
                           UnresolvedList* new_unresolved_list,
                           bool maybe_in_arrowhead) {
this->ForEach([max_outer_scope, ast_node_factory, new_unresolved_list,
2
←
Calling 'Scope::ForEach'→
               maybe_in_arrowhead](Scope* scope) {
  DCHECK_IMPLIES(scope->is_declaration_scope(),((void) 0)
                 !scope->AsDeclarationScope()->was_lazily_parsed())((void) 0);

  for (VariableProxy* proxy = scope->unresolved_list_.first();
9
←
Loop condition is true.  Entering loop body→
       proxy != nullptr; proxy = proxy->next_unresolved()) {
8
←
Assuming the condition is true→
    if (proxy->is_removed_from_unresolved()) continue;
10
←
Assuming the condition is false→
11
←
Taking false branch→
    DCHECK(!proxy->is_resolved())((void) 0);
    Variable* var =
        Lookup<kParsedScope>(proxy, scope, max_outer_scope->outer_scope());
12
←
Passing null pointer value via 4th parameter 'cache_scope'→
13
←
Calling 'Scope::Lookup'→
    if (var == nullptr) {
      // Don't copy unresolved references to the script scope, unless it's a
      // reference to a private name or method. In that case keep it so we
      // can fail later.
      if (!max_outer_scope->outer_scope()->is_script_scope() ||
          maybe_in_arrowhead) {
        VariableProxy* copy = ast_node_factory->CopyVariableProxy(proxy);
        new_unresolved_list->Add(copy);
      }
    } else {
      var->set_is_used();
      if (proxy->is_assigned()) var->SetMaybeAssigned();
    }
  }

  // Clear unresolved_list_ as it's in an inconsistent state.
  scope->unresolved_list_.Clear();
  return Iteration::kDescend;
});
1669}

1671Handle<StringSet> DeclarationScope::CollectNonLocals(
  Isolate* isolate, Handle<StringSet> non_locals) {
Scope::CollectNonLocals(this, isolate, &non_locals);
return non_locals;
1675}

1677void DeclarationScope::ResetAfterPreparsing(AstValueFactory* ast_value_factory,
                                          bool aborted) {
DCHECK(is_function_scope())((void) 0);

// Reset all non-trivial members.
params_.DropAndClear();
decls_.Clear();
locals_.Clear();
inner_scope_ = nullptr;
unresolved_list_.Clear();
sloppy_block_functions_.Clear();
rare_data_ = nullptr;
has_rest_ = false;
function_ = nullptr;

DCHECK_NE(zone(), ast_value_factory->single_parse_zone())((void) 0);
// Make sure this scope and zone aren't used for allocation anymore.
{
  // Get the zone, while variables_ is still valid
  Zone* zone = this->zone();
  variables_.Invalidate();
  zone->Reset();
}

if (aborted) {
  // Prepare scope for use in the outer zone.
  variables_ = VariableMap(ast_value_factory->single_parse_zone());
  if (!IsArrowFunction(function_kind_)) {
    has_simple_parameters_ = true;
    DeclareDefaultFunctionVariables(ast_value_factory);
  }
}

1710#ifdef DEBUG
needs_migration_ = false;
is_being_lazily_parsed_ = false;
1713#endif

was_lazily_parsed_ = !aborted;
1716}

1718bool Scope::IsSkippableFunctionScope() {
// Lazy non-arrow function scopes are skippable. Lazy functions are exactly
// those Scopes which have their own PreparseDataBuilder object. This
// logic ensures that the scope allocation data is consistent with the
// skippable function data (both agree on where the lazy function boundaries
// are).
if (!is_function_scope()) return false;
DeclarationScope* declaration_scope = AsDeclarationScope();
return !declaration_scope->is_arrow_scope() &&
       declaration_scope->preparse_data_builder() != nullptr;
1728}

1730void Scope::SavePreparseData(Parser* parser) {
this->ForEach([parser](Scope* scope) {
  if (scope->IsSkippableFunctionScope()) {
    scope->AsDeclarationScope()->SavePreparseDataForDeclarationScope(parser);
  }
  return Iteration::kDescend;
});
1737}

1739void DeclarationScope::SavePreparseDataForDeclarationScope(Parser* parser) {
if (preparse_data_builder_ == nullptr) return;
preparse_data_builder_->SaveScopeAllocationData(this, parser);
1742}

1744void DeclarationScope::AnalyzePartially(Parser* parser,
                                      AstNodeFactory* ast_node_factory,
                                      bool maybe_in_arrowhead) {
DCHECK(!force_eager_compilation_)((void) 0);
UnresolvedList new_unresolved_list;
if (!IsArrowFunction(function_kind_) &&
    (!outer_scope_->is_script_scope() || maybe_in_arrowhead ||
     (preparse_data_builder_ != nullptr &&
      preparse_data_builder_->HasInnerFunctions()))) {
  // Try to resolve unresolved variables for this Scope and migrate those
  // which cannot be resolved inside. It doesn't make sense to try to resolve
  // them in the outer Scopes here, because they are incomplete.
  Scope::AnalyzePartially(this, ast_node_factory, &new_unresolved_list,
1
Calling 'Scope::AnalyzePartially'→
                          maybe_in_arrowhead);

  // Migrate function_ to the right Zone.
  if (function_ != nullptr) {
    function_ = ast_node_factory->CopyVariable(function_);
  }

  SavePreparseData(parser);
}

1767#ifdef DEBUG
if (FLAG_print_scopes) {
  PrintF("Inner function scope:\n");
  Print();
}
1772#endif

ResetAfterPreparsing(ast_node_factory->ast_value_factory(), false);

unresolved_list_ = std::move(new_unresolved_list);
1777}

1779void DeclarationScope::RewriteReplGlobalVariables() {
DCHECK(is_script_scope())((void) 0);
if (!is_repl_mode_scope()) return;

for (VariableMap::Entry* p = variables_.Start(); p != nullptr;
     p = variables_.Next(p)) {
  Variable* var = reinterpret_cast<Variable*>(p->value);
  var->RewriteLocationForRepl();
}
1788}

1790#ifdef DEBUG
1791namespace {

1793const char* Header(ScopeType scope_type, FunctionKind function_kind,
                 bool is_declaration_scope) {
switch (scope_type) {
  case EVAL_SCOPE: return "eval";
  case FUNCTION_SCOPE:
    if (IsGeneratorFunction(function_kind)) return "function*";
    if (IsAsyncFunction(function_kind)) return "async function";
    if (IsArrowFunction(function_kind)) return "arrow";
    return "function";
  case MODULE_SCOPE: return "module";
  case SCRIPT_SCOPE: return "global";
  case CATCH_SCOPE: return "catch";
  case BLOCK_SCOPE: return is_declaration_scope ? "varblock" : "block";
  case CLASS_SCOPE:
    return "class";
  case WITH_SCOPE: return "with";
}
UNREACHABLE()V8_Fatal("unreachable code");
1811}

1813void Indent(int n, const char* str) { PrintF("%*s%s", n, "", str); }

1815void PrintName(const AstRawString* name) {
PrintF("%.*s", name->length(), name->raw_data());
1817}

1819void PrintLocation(Variable* var) {
switch (var->location()) {
  case VariableLocation::UNALLOCATED:
    break;
  case VariableLocation::PARAMETER:
    PrintF("parameter[%d]", var->index());
    break;
  case VariableLocation::LOCAL:
    PrintF("local[%d]", var->index());
    break;
  case VariableLocation::CONTEXT:
    PrintF("context[%d]", var->index());
    break;
  case VariableLocation::LOOKUP:
    PrintF("lookup");
    break;
  case VariableLocation::MODULE:
    PrintF("module");
    break;
  case VariableLocation::REPL_GLOBAL:
    PrintF("repl global[%d]", var->index());
    break;
}
1842}

1844void PrintVar(int indent, Variable* var) {
Indent(indent, VariableMode2String(var->mode()));
PrintF(" ");
if (var->raw_name()->IsEmpty())
  PrintF(".%p", reinterpret_cast<void*>(var));
else
  PrintName(var->raw_name());
PrintF(";  // (%p) ", reinterpret_cast<void*>(var));
PrintLocation(var);
bool comma = !var->IsUnallocated();
if (var->has_forced_context_allocation()) {
  if (comma) PrintF(", ");
  PrintF("forced context allocation");
  comma = true;
}
if (var->maybe_assigned() == kNotAssigned) {
  if (comma) PrintF(", ");
  PrintF("never assigned");
  comma = true;
}
if (var->initialization_flag() == kNeedsInitialization &&
    !var->binding_needs_init()) {
  if (comma) PrintF(", ");
  PrintF("hole initialization elided");
}
PrintF("\n");
1870}

1872void PrintMap(int indent, const char* label, VariableMap* map, bool locals,
            Variable* function_var) {
bool printed_label = false;
for (VariableMap::Entry* p = map->Start(); p != nullptr; p = map->Next(p)) {
  Variable* var = reinterpret_cast<Variable*>(p->value);
  if (var == function_var) continue;
  bool local = !IsDynamicVariableMode(var->mode());
  if ((locals ? local : !local) &&
      (var->is_used() || !var->IsUnallocated())) {
    if (!printed_label) {
      Indent(indent, label);
      printed_label = true;
    }
    PrintVar(indent, var);
  }
}
1888}

1890}  // anonymous namespace

1892void DeclarationScope::PrintParameters() {
PrintF(" (");
for (int i = 0; i < params_.length(); i++) {
  if (i > 0) PrintF(", ");
  const AstRawString* name = params_[i]->raw_name();
  if (name->IsEmpty()) {
    PrintF(".%p", reinterpret_cast<void*>(params_[i]));
  } else {
    PrintName(name);
  }
}
PrintF(")");
1904}

1906void Scope::Print(int n) {
int n0 = (n > 0 ? n : 0);
int n1 = n0 + 2;  // indentation

// Print header.
FunctionKind function_kind = is_function_scope()
                                 ? AsDeclarationScope()->function_kind()
                                 : FunctionKind::kNormalFunction;
Indent(n0, Header(scope_type_, function_kind, is_declaration_scope()));
if (scope_name_ != nullptr && !scope_name_->IsEmpty()) {
  PrintF(" ");
  PrintName(scope_name_);
}

// Print parameters, if any.
Variable* function = nullptr;
if (is_function_scope()) {
  AsDeclarationScope()->PrintParameters();
  function = AsDeclarationScope()->function_var();
}

PrintF(" { // (%p) (%d, %d)\n", reinterpret_cast<void*>(this),
       start_position(), end_position());
if (is_hidden()) {
  Indent(n1, "// is hidden\n");
}

// Function name, if any (named function literals, only).
if (function != nullptr) {
  Indent(n1, "// (local) function name: ");
  PrintName(function->raw_name());
  PrintF("\n");
}

// Scope info.
if (is_strict(language_mode())) {
  Indent(n1, "// strict mode scope\n");
}
1944#if V8_ENABLE_WEBASSEMBLY1
if (IsAsmModule()) Indent(n1, "// scope is an asm module\n");
1946#endif  // V8_ENABLE_WEBASSEMBLY
if (is_declaration_scope() &&
    AsDeclarationScope()->sloppy_eval_can_extend_vars()) {
  Indent(n1, "// scope calls sloppy 'eval'\n");
}
if (private_name_lookup_skips_outer_class()) {
  Indent(n1, "// scope skips outer class for #-names\n");
}
if (inner_scope_calls_eval_) Indent(n1, "// inner scope calls 'eval'\n");
if (is_declaration_scope()) {
  DeclarationScope* scope = AsDeclarationScope();
  if (scope->was_lazily_parsed()) Indent(n1, "// lazily parsed\n");
  if (scope->ShouldEagerCompile()) Indent(n1, "// will be compiled\n");
  if (scope->needs_private_name_context_chain_recalc()) {
    Indent(n1, "// needs #-name context chain recalc\n");
  }
  Indent(n1, "// ");
  PrintF("%s\n", FunctionKind2String(scope->function_kind()));
  if (scope->class_scope_has_private_brand()) {
    Indent(n1, "// class scope has private brand\n");
  }
}
if (num_stack_slots_ > 0) {
  Indent(n1, "// ");
  PrintF("%d stack slots\n", num_stack_slots_);
}
if (num_heap_slots_ > 0) {
  Indent(n1, "// ");
  PrintF("%d heap slots\n", num_heap_slots_);
}

// Print locals.
if (function != nullptr) {
  Indent(n1, "// function var:\n");
  PrintVar(n1, function);
}

// Print temporaries.
{
  bool printed_header = false;
  for (Variable* local : locals_) {
    if (local->mode() != VariableMode::kTemporary) continue;
    if (!printed_header) {
      printed_header = true;
      Indent(n1, "// temporary vars:\n");
    }
    PrintVar(n1, local);
  }
}

if (variables_.occupancy() > 0) {
  PrintMap(n1, "// local vars:\n", &variables_, true, function);
  PrintMap(n1, "// dynamic vars:\n", &variables_, false, function);
}

if (is_class_scope()) {
  ClassScope* class_scope = AsClassScope();
  if (class_scope->GetRareData() != nullptr) {
    PrintMap(n1, "// private name vars:\n",
             &(class_scope->GetRareData()->private_name_map), true, function);
    Variable* brand = class_scope->brand();
    if (brand != nullptr) {
      Indent(n1, "// brand var:\n");
      PrintVar(n1, brand);
    }
  }
  if (class_scope->class_variable() != nullptr) {
    Indent(n1, "// class var");
    PrintF("%s%s:\n",
           class_scope->class_variable()->is_used() ? ", used" : ", unused",
           class_scope->should_save_class_variable_index()
               ? ", index saved"
               : ", index not saved");
    PrintVar(n1, class_scope->class_variable());
  }
}

// Print inner scopes (disable by providing negative n).
if (n >= 0) {
  for (Scope* scope = inner_scope_; scope != nullptr;
       scope = scope->sibling_) {
    PrintF("\n");
    scope->Print(n1);
  }
}

Indent(n0, "}\n");
2033}

2035void Scope::CheckScopePositions() {
this->ForEach([](Scope* scope) {
  // Visible leaf scopes must have real positions.
  if (!scope->is_hidden() && scope->inner_scope_ == nullptr) {
    DCHECK_NE(kNoSourcePosition, scope->start_position())((void) 0);
    DCHECK_NE(kNoSourcePosition, scope->end_position())((void) 0);
  }
  return Iteration::kDescend;
});
2044}

2046void Scope::CheckZones() {
DCHECK(!needs_migration_)((void) 0);
this->ForEach([](Scope* scope) {
  if (WasLazilyParsed(scope)) {
    DCHECK_NULL(scope->zone())((void) 0);
    DCHECK_NULL(scope->inner_scope_)((void) 0);
    return Iteration::kContinue;
  }
  return Iteration::kDescend;
});
2056}
2057#endif  // DEBUG

2059Variable* Scope::NonLocal(const AstRawString* name, VariableMode mode) {
// Declare a new non-local.
DCHECK(IsDynamicVariableMode(mode))((void) 0);
bool was_added;
Variable* var = variables_.Declare(zone(), this, name, mode, NORMAL_VARIABLE,
                                   kCreatedInitialized, kNotAssigned,
                                   IsStaticFlag::kNotStatic, &was_added);
// Allocate it by giving it a dynamic lookup.
var->AllocateTo(VariableLocation::LOOKUP, -1);
return var;
2069}

2071// static
2072template <Scope::ScopeLookupMode mode>
2073Variable* Scope::Lookup(VariableProxy* proxy, Scope* scope,
                      Scope* outer_scope_end, Scope* cache_scope,
                      bool force_context_allocation) {
// If we have already passed the cache scope in earlier recursions, we should
// first quickly check if the current scope uses the cache scope before
// continuing.
if (mode13.1
is not equal to kDeserializedScope
 == kDeserializedScope &&
    scope->deserialized_scope_uses_external_cache()) {
  Variable* var = cache_scope->variables_.Lookup(proxy->raw_name());
  if (var != nullptr) return var;
}

while (true) {
14
←
Loop condition is true.  Entering loop body→
  DCHECK_IMPLIES(mode == kParsedScope, !scope->is_debug_evaluate_scope_)((void) 0);
  // Short-cut: whenever we find a debug-evaluate scope, just look everything
  // up dynamically. Debug-evaluate doesn't properly create scope info for the
  // lookups it does. It may not have a valid 'this' declaration, and anything
  // accessed through debug-evaluate might invalidly resolve to
  // stack-allocated variables.
  // TODO(yangguo): Remove once debug-evaluate creates proper ScopeInfo for
  // the scopes in which it's evaluating.
  if (mode14.1
is not equal to kDeserializedScope
 == kDeserializedScope &&
      V8_UNLIKELY(scope->is_debug_evaluate_scope_)(__builtin_expect(!!(scope->is_debug_evaluate_scope_), 0))) {
    DCHECK(scope->deserialized_scope_uses_external_cache() ||((void) 0)
           scope == cache_scope)((void) 0);
    return cache_scope->NonLocal(proxy->raw_name(), VariableMode::kDynamic);
  }

  // Try to find the variable in this scope.
  Variable* var;
  if (mode14.2
is equal to kParsedScope
 == kParsedScope) {
15
←
Taking true branch→
    var = scope->LookupLocal(proxy->raw_name());
  } else {
    DCHECK_EQ(mode, kDeserializedScope)((void) 0);
    bool external_cache = scope->deserialized_scope_uses_external_cache();
    if (!external_cache) {
      // Check the cache on each deserialized scope, up to the main cache
      // scope when we get to it (we may still have deserialized scopes
      // in-between the initial and cache scopes so we can't just check the
      // cache before the loop).
      var = scope->variables_.Lookup(proxy->raw_name());
      if (var != nullptr) return var;
    }
    var = scope->LookupInScopeInfo(proxy->raw_name(),
                                   external_cache ? cache_scope : scope);
  }

  // We found a variable and we are done. (Even if there is an 'eval' in this
  // scope which introduces the same variable again, the resulting variable
  // remains the same.)
  //
  // For sloppy eval though, we skip dynamic variable to avoid resolving to a
  // variable when the variable and proxy are in the same eval execution. The
  // variable is not available on subsequent lazy executions of functions in
  // the eval, so this avoids inner functions from looking up different
  // variables during eager and lazy compilation.
  //
  // TODO(leszeks): Maybe we want to restrict this to e.g. lookups of a proxy
  // living in a different scope to the current one, or some other
  // optimisation.
  if (var != nullptr &&
      !(scope->is_eval_scope() && var->mode() == VariableMode::kDynamic)) {
    if (mode == kParsedScope && force_context_allocation &&
        !var->is_dynamic()) {
      var->ForceContextAllocation();
    }
    return var;
  }

  if (scope->outer_scope_ == outer_scope_end) break;
16
←
Assuming 'outer_scope_end' is not equal to field 'outer_scope_'→
17
←
Taking false branch→

  DCHECK(!scope->is_script_scope())((void) 0);
  if (V8_UNLIKELY(scope->is_with_scope())(__builtin_expect(!!(scope->is_with_scope()), 0))) {
18
←
Taking true branch→
    return LookupWith(proxy, scope, outer_scope_end, cache_scope,
19
←
Passing null pointer value via 4th parameter 'cache_scope'→
20
←
Calling 'Scope::LookupWith'→
                      force_context_allocation);
  }
  if (V8_UNLIKELY((__builtin_expect(!!(scope->is_declaration_scope() &&
 scope->AsDeclarationScope()->sloppy_eval_can_extend_vars
()), 0))
          scope->is_declaration_scope() &&(__builtin_expect(!!(scope->is_declaration_scope() &&
 scope->AsDeclarationScope()->sloppy_eval_can_extend_vars
()), 0))
          scope->AsDeclarationScope()->sloppy_eval_can_extend_vars())(__builtin_expect(!!(scope->is_declaration_scope() &&
 scope->AsDeclarationScope()->sloppy_eval_can_extend_vars
()), 0))) {
    return LookupSloppyEval(proxy, scope, outer_scope_end, cache_scope,
                            force_context_allocation);
  }

  force_context_allocation |= scope->is_function_scope();
  scope = scope->outer_scope_;

  // TODO(verwaest): Separate through AnalyzePartially.
  if (mode == kParsedScope && !scope->scope_info_.is_null()) {
    DCHECK_NULL(cache_scope)((void) 0);
    cache_scope = scope->GetNonEvalDeclarationScope();
    return Lookup<kDeserializedScope>(proxy, scope, outer_scope_end,
                                      cache_scope);
  }
}

// We may just be trying to find all free variables. In that case, don't
// declare them in the outer scope.
// TODO(marja): Separate Lookup for preparsed scopes better.
if (mode == kParsedScope && !scope->is_script_scope()) {
  return nullptr;
}

// No binding has been found. Declare a variable on the global object.
return scope->AsDeclarationScope()->DeclareDynamicGlobal(
    proxy->raw_name(), NORMAL_VARIABLE,
    mode == kDeserializedScope ? cache_scope : scope);
2179}

2181template Variable* Scope::Lookup<Scope::kParsedScope>(
  VariableProxy* proxy, Scope* scope, Scope* outer_scope_end,
  Scope* cache_scope, bool force_context_allocation);
2184template Variable* Scope::Lookup<Scope::kDeserializedScope>(
  VariableProxy* proxy, Scope* scope, Scope* outer_scope_end,
  Scope* cache_scope, bool force_context_allocation);

2188Variable* Scope::LookupWith(VariableProxy* proxy, Scope* scope,
                          Scope* outer_scope_end, Scope* cache_scope,
                          bool force_context_allocation) {
DCHECK(scope->is_with_scope())((void) 0);

Variable* var =
    scope->outer_scope_->scope_info_.is_null()
21
←
'?' condition is false→
        ? Lookup<kParsedScope>(proxy, scope->outer_scope_, outer_scope_end,
                               nullptr, force_context_allocation)
        : Lookup<kDeserializedScope>(proxy, scope->outer_scope_,
                                     outer_scope_end, cache_scope);

if (var == nullptr) return var;
22
←
Assuming the condition is false→

// The current scope is a with scope, so the variable binding can not be
// statically resolved. However, note that it was necessary to do a lookup
// in the outer scope anyway, because if a binding exists in an outer
// scope, the associated variable has to be marked as potentially being
// accessed from inside of an inner with scope (the property may not be in
// the 'with' object).
if (!var->is_dynamic() && var->IsUnallocated()) {
23
←
Assuming the condition is false→
  DCHECK(!scope->already_resolved_)((void) 0);
  var->set_is_used();
  var->ForceContextAllocation();
  if (proxy->is_assigned()) var->SetMaybeAssigned();
}
Scope* target_scope;
if (scope->deserialized_scope_uses_external_cache()) {
24
←
Assuming the condition is true→
25
←
Taking true branch→
  DCHECK_NOT_NULL(cache_scope)((void) 0);
  cache_scope->variables_.Remove(var);
26
←
Called C++ object pointer is null
  target_scope = cache_scope;
} else {
  target_scope = scope;
}
Variable* dynamic =
    target_scope->NonLocal(proxy->raw_name(), VariableMode::kDynamic);
dynamic->set_local_if_not_shadowed(var);
return dynamic;
2226}

2228Variable* Scope::LookupSloppyEval(VariableProxy* proxy, Scope* scope,
                                Scope* outer_scope_end, Scope* cache_scope,
                                bool force_context_allocation) {
DCHECK(scope->is_declaration_scope() &&((void) 0)
       scope->AsDeclarationScope()->sloppy_eval_can_extend_vars())((void) 0);

// If we're compiling eval, it's possible that the outer scope is the first
// ScopeInfo-backed scope. We use the next declaration scope as the cache for
// this case, to avoid complexity around sloppy block function hoisting and
// conflict detection through catch scopes in the eval.
Scope* entry_cache = cache_scope == nullptr
                         ? scope->outer_scope()->GetNonEvalDeclarationScope()
                         : cache_scope;
Variable* var =
    scope->outer_scope_->scope_info_.is_null()
        ? Lookup<kParsedScope>(proxy, scope->outer_scope_, outer_scope_end,
                               nullptr, force_context_allocation)
        : Lookup<kDeserializedScope>(proxy, scope->outer_scope_,
                                     outer_scope_end, entry_cache);
if (var == nullptr) return var;

// We may not want to use the cache scope, change it back to the given scope
// if necessary.
if (!scope->deserialized_scope_uses_external_cache()) {
  // For a deserialized scope, we'll be replacing the cache_scope.
  DCHECK_IMPLIES(!scope->scope_info_.is_null(), cache_scope != nullptr)((void) 0);
  cache_scope = scope;
}

// A variable binding may have been found in an outer scope, but the current
// scope makes a sloppy 'eval' call, so the found variable may not be the
// correct one (the 'eval' may introduce a binding with the same name). In
// that case, change the lookup result to reflect this situation. Only
// scopes that can host var bindings (declaration scopes) need be considered
// here (this excludes block and catch scopes), and variable lookups at
// script scope are always dynamic.
if (var->IsGlobalObjectProperty()) {
  Scope* target = cache_scope == nullptr ? scope : cache_scope;
  var = target->NonLocal(proxy->raw_name(), VariableMode::kDynamicGlobal);
}

if (var->is_dynamic()) return var;

Variable* invalidated = var;
if (cache_scope != nullptr) cache_scope->variables_.Remove(invalidated);

Scope* target = cache_scope == nullptr ? scope : cache_scope;
var = target->NonLocal(proxy->raw_name(), VariableMode::kDynamicLocal);
var->set_local_if_not_shadowed(invalidated);

return var;
2279}

2281void Scope::ResolveVariable(VariableProxy* proxy) {
DCHECK(!proxy->is_resolved())((void) 0);
Variable* var = Lookup<kParsedScope>(proxy, this, nullptr);
DCHECK_NOT_NULL(var)((void) 0);
ResolveTo(proxy, var);
2286}

2288namespace {

2290void SetNeedsHoleCheck(Variable* var, VariableProxy* proxy) {
proxy->set_needs_hole_check();
var->ForceHoleInitialization();
2293}

2295void UpdateNeedsHoleCheck(Variable* var, VariableProxy* proxy, Scope* scope) {
if (var->mode() == VariableMode::kDynamicLocal) {
  // Dynamically introduced variables never need a hole check (since they're
  // VariableMode::kVar bindings, either from var or function declarations),
  // but the variable they shadow might need a hole check, which we want to do
  // if we decide that no shadowing variable was dynamically introoduced.
  DCHECK_EQ(kCreatedInitialized, var->initialization_flag())((void) 0);
  return UpdateNeedsHoleCheck(var->local_if_not_shadowed(), proxy, scope);
}

if (var->initialization_flag() == kCreatedInitialized) return;

// It's impossible to eliminate module import hole checks here, because it's
// unknown at compilation time whether the binding referred to in the
// exporting module itself requires hole checks.
if (var->location() == VariableLocation::MODULE && !var->IsExport()) {
  return SetNeedsHoleCheck(var, proxy);
}

// Check if the binding really needs an initialization check. The check
// can be skipped in the following situation: we have a VariableMode::kLet or
// VariableMode::kConst binding, both the Variable and the VariableProxy have
// the same declaration scope (i.e. they are both in global code, in the same
// function or in the same eval code), the VariableProxy is in the source
// physically located after the initializer of the variable, and that the
// initializer cannot be skipped due to a nonlinear scope.
//
// The condition on the closure scopes is a conservative check for
// nested functions that access a binding and are called before the
// binding is initialized:
//   function() { f(); let x = 1; function f() { x = 2; } }
//
// The check cannot be skipped on non-linear scopes, namely switch
// scopes, to ensure tests are done in cases like the following:
//   switch (1) { case 0: let x = 2; case 1: f(x); }
// The scope of the variable needs to be checked, in case the use is
// in a sub-block which may be linear.
if (var->scope()->GetClosureScope() != scope->GetClosureScope()) {
  return SetNeedsHoleCheck(var, proxy);
}

// We should always have valid source positions.
DCHECK_NE(var->initializer_position(), kNoSourcePosition)((void) 0);
DCHECK_NE(proxy->position(), kNoSourcePosition)((void) 0);

if (var->scope()->is_nonlinear() ||
    var->initializer_position() >= proxy->position()) {
  return SetNeedsHoleCheck(var, proxy);
}
2344}

2346}  // anonymous namespace

2348void Scope::ResolveTo(VariableProxy* proxy, Variable* var) {
DCHECK_NOT_NULL(var)((void) 0);
UpdateNeedsHoleCheck(var, proxy, this);
proxy->BindTo(var);
2352}

2354void Scope::ResolvePreparsedVariable(VariableProxy* proxy, Scope* scope,
                                   Scope* end) {
// Resolve the variable in all parsed scopes to force context allocation.
for (; scope != end; scope = scope->outer_scope_) {
  Variable* var = scope->LookupLocal(proxy->raw_name());
  if (var != nullptr) {
    var->set_is_used();
    if (!var->is_dynamic()) {
      var->ForceContextAllocation();
      if (proxy->is_assigned()) var->SetMaybeAssigned();
      return;
    }
  }
}
2368}

2370bool Scope::ResolveVariablesRecursively(Scope* end) {
// Lazy parsed declaration scopes are already partially analyzed. If there are
// unresolved references remaining, they just need to be resolved in outer
// scopes.
if (WasLazilyParsed(this)) {
  DCHECK_EQ(variables_.occupancy(), 0)((void) 0);
  // Resolve in all parsed scopes except for the script scope.
  if (!end->is_script_scope()) end = end->outer_scope();

  for (VariableProxy* proxy : unresolved_list_) {
    ResolvePreparsedVariable(proxy, outer_scope(), end);
  }
} else {
  // Resolve unresolved variables for this scope.
  for (VariableProxy* proxy : unresolved_list_) {
    ResolveVariable(proxy);
  }

  // Resolve unresolved variables for inner scopes.
  for (Scope* scope = inner_scope_; scope != nullptr;
       scope = scope->sibling_) {
    if (!scope->ResolveVariablesRecursively(end)) return false;
  }
}
return true;
2395}

2397bool Scope::MustAllocate(Variable* var) {
DCHECK(var->location() != VariableLocation::MODULE)((void) 0);
// Give var a read/write use if there is a chance it might be accessed
// via an eval() call.  This is only possible if the variable has a
// visible name.
if (!var->raw_name()->IsEmpty() &&
    (inner_scope_calls_eval_ || is_catch_scope() || is_script_scope())) {
  var->set_is_used();
  if (inner_scope_calls_eval_ && !var->is_this()) var->SetMaybeAssigned();
}
DCHECK(!var->has_forced_context_allocation() || var->is_used())((void) 0);
// Global variables do not need to be allocated.
return !var->IsGlobalObjectProperty() && var->is_used();
2410}


2413bool Scope::MustAllocateInContext(Variable* var) {
// If var is accessed from an inner scope, or if there is a possibility
// that it might be accessed from the current or an inner scope (through
// an eval() call or a runtime with lookup), it must be allocated in the
// context.
//
// Temporary variables are always stack-allocated.  Catch-bound variables are
// always context-allocated.
VariableMode mode = var->mode();
if (mode == VariableMode::kTemporary) return false;
if (is_catch_scope()) return true;
if (is_script_scope() || is_eval_scope()) {
  if (IsLexicalVariableMode(mode)) {
    return true;
  }
}
return var->has_forced_context_allocation() || inner_scope_calls_eval_;
2430}

2432void Scope::AllocateStackSlot(Variable* var) {
if (is_block_scope()) {
  outer_scope()->GetDeclarationScope()->AllocateStackSlot(var);
} else {
  var->AllocateTo(VariableLocation::LOCAL, num_stack_slots_++);
}
2438}


2441void Scope::AllocateHeapSlot(Variable* var) {
var->AllocateTo(VariableLocation::CONTEXT, num_heap_slots_++);
2443}

2445void DeclarationScope::AllocateParameterLocals() {
DCHECK(is_function_scope())((void) 0);

bool has_mapped_arguments = false;
if (arguments_ != nullptr) {
  DCHECK(!is_arrow_scope())((void) 0);
  if (MustAllocate(arguments_) && !has_arguments_parameter_) {
    // 'arguments' is used and does not refer to a function
    // parameter of the same name. If the arguments object
    // aliases formal parameters, we conservatively allocate
    // them specially in the loop below.
    has_mapped_arguments =
        GetArgumentsType() == CreateArgumentsType::kMappedArguments;
  } else {
    // 'arguments' is unused. Tell the code generator that it does not need to
    // allocate the arguments object by nulling out arguments_.
    arguments_ = nullptr;
  }
}

// The same parameter may occur multiple times in the parameters_ list.
// If it does, and if it is not copied into the context object, it must
// receive the highest parameter index for that parameter; thus iteration
// order is relevant!
for (int i = num_parameters() - 1; i >= 0; --i) {
  Variable* var = params_[i];
  DCHECK_NOT_NULL(var)((void) 0);
  DCHECK(!has_rest_ || var != rest_parameter())((void) 0);
  DCHECK_EQ(this, var->scope())((void) 0);
  if (has_mapped_arguments) {
    var->set_is_used();
    var->SetMaybeAssigned();
    var->ForceContextAllocation();
  }
  AllocateParameter(var, i);
}
2481}

2483void DeclarationScope::AllocateParameter(Variable* var, int index) {
if (!MustAllocate(var)) return;
if (has_forced_context_allocation_for_parameters() ||
    MustAllocateInContext(var)) {
  DCHECK(var->IsUnallocated() || var->IsContextSlot())((void) 0);
  if (var->IsUnallocated()) AllocateHeapSlot(var);
} else {
  DCHECK(var->IsUnallocated() || var->IsParameter())((void) 0);
  if (var->IsUnallocated()) {
    var->AllocateTo(VariableLocation::PARAMETER, index);
  }
}
2495}

2497void DeclarationScope::AllocateReceiver() {
if (!has_this_declaration()) return;
DCHECK_NOT_NULL(receiver())((void) 0);
DCHECK_EQ(receiver()->scope(), this)((void) 0);
AllocateParameter(receiver(), -1);
2502}

2504void Scope::AllocateNonParameterLocal(Variable* var) {
DCHECK_EQ(var->scope(), this)((void) 0);
if (var->IsUnallocated() && MustAllocate(var)) {
  if (MustAllocateInContext(var)) {
    AllocateHeapSlot(var);
    DCHECK_IMPLIES(is_catch_scope(),((void) 0)
                   var->index() == Context::THROWN_OBJECT_INDEX)((void) 0);
  } else {
    AllocateStackSlot(var);
  }
}
2515}

2517void Scope::AllocateNonParameterLocalsAndDeclaredGlobals() {
if (is_declaration_scope() && AsDeclarationScope()->is_arrow_scope()) {
  // In arrow functions, allocate non-temporaries first and then all the
  // temporaries to make the local variable ordering stable when reparsing to
  // collect source positions.
  for (Variable* local : locals_) {
    if (local->mode() != VariableMode::kTemporary)
      AllocateNonParameterLocal(local);
  }

  for (Variable* local : locals_) {
    if (local->mode() == VariableMode::kTemporary)
      AllocateNonParameterLocal(local);
  }
} else {
  for (Variable* local : locals_) {
    AllocateNonParameterLocal(local);
  }
}

if (is_declaration_scope()) {
  AsDeclarationScope()->AllocateLocals();
}
2540}

2542void DeclarationScope::AllocateLocals() {
// For now, function_ must be allocated at the very end.  If it gets
// allocated in the context, it must be the last slot in the context,
// because of the current ScopeInfo implementation (see
// ScopeInfo::ScopeInfo(FunctionScope* scope) constructor).
if (function_ != nullptr && MustAllocate(function_)) {
  AllocateNonParameterLocal(function_);
} else {
  function_ = nullptr;
}

DCHECK(!has_rest_ || !MustAllocate(rest_parameter()) ||((void) 0)
       !rest_parameter()->IsUnallocated())((void) 0);

if (new_target_ != nullptr && !MustAllocate(new_target_)) {
  new_target_ = nullptr;
}

NullifyRareVariableIf(RareVariable::kThisFunction,
                      [=](Variable* var) { return !MustAllocate(var); });
2562}

2564void ModuleScope::AllocateModuleVariables() {
for (const auto& it : module()->regular_imports()) {
  Variable* var = LookupLocal(it.first);
  var->AllocateTo(VariableLocation::MODULE, it.second->cell_index);
  DCHECK(!var->IsExport())((void) 0);
}

for (const auto& it : module()->regular_exports()) {
  Variable* var = LookupLocal(it.first);
  var->AllocateTo(VariableLocation::MODULE, it.second->cell_index);
  DCHECK(var->IsExport())((void) 0);
}
2576}

2578void Scope::AllocateVariablesRecursively() {
this->ForEach([](Scope* scope) -> Iteration {
  DCHECK(!scope->already_resolved_)((void) 0);
  if (WasLazilyParsed(scope)) return Iteration::kContinue;
  DCHECK_EQ(scope->ContextHeaderLength(), scope->num_heap_slots_)((void) 0);

  // Allocate variables for this scope.
  // Parameters must be allocated first, if any.
  if (scope->is_declaration_scope()) {
    scope->AsDeclarationScope()->AllocateReceiver();
    if (scope->is_function_scope()) {
      scope->AsDeclarationScope()->AllocateParameterLocals();
    }
  }
  scope->AllocateNonParameterLocalsAndDeclaredGlobals();

  // Force allocation of a context for this scope if necessary. For a 'with'
  // scope and for a function scope that makes an 'eval' call we need a
  // context, even if no local variables were statically allocated in the
  // scope. Likewise for modules and function scopes representing asm.js
  // modules. Also force a context, if the scope is stricter than the outer
  // scope.
  bool must_have_context =
      scope->is_with_scope() || scope->is_module_scope() ||
2602#if V8_ENABLE_WEBASSEMBLY1
      scope->IsAsmModule() ||
2604#endif  // V8_ENABLE_WEBASSEMBLY
      scope->ForceContextForLanguageMode() ||
      (scope->is_function_scope() &&
       scope->AsDeclarationScope()->sloppy_eval_can_extend_vars()) ||
      (scope->is_block_scope() && scope->is_declaration_scope() &&
       scope->AsDeclarationScope()->sloppy_eval_can_extend_vars());

  // If we didn't allocate any locals in the local context, then we only
  // need the minimal number of slots if we must have a context.
  if (scope->num_heap_slots_ == scope->ContextHeaderLength() &&
      !must_have_context) {
    scope->num_heap_slots_ = 0;
  }

  // Allocation done.
  DCHECK(scope->num_heap_slots_ == 0 ||((void) 0)
         scope->num_heap_slots_ >= scope->ContextHeaderLength())((void) 0);
  return Iteration::kDescend;
});
2623}

2625template <typename IsolateT>
2626void Scope::AllocateScopeInfosRecursively(IsolateT* isolate,
                                        MaybeHandle<ScopeInfo> outer_scope) {
DCHECK(scope_info_.is_null())((void) 0);
MaybeHandle<ScopeInfo> next_outer_scope = outer_scope;

if (NeedsScopeInfo()) {
  scope_info_ = ScopeInfo::Create(isolate, zone(), this, outer_scope);
  // The ScopeInfo chain should mirror the context chain, so we only link to
  // the next outer scope that needs a context.
  if (NeedsContext()) next_outer_scope = scope_info_;
}

// Allocate ScopeInfos for inner scopes.
for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
  if (!scope->is_function_scope() ||
      scope->AsDeclarationScope()->ShouldEagerCompile()) {
    scope->AllocateScopeInfosRecursively(isolate, next_outer_scope);
  }
}
2645}

2647template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE) void Scope::
  AllocateScopeInfosRecursively<Isolate>(Isolate* isolate,
                                         MaybeHandle<ScopeInfo> outer_scope);
2650template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE) void Scope::
  AllocateScopeInfosRecursively<LocalIsolate>(
      LocalIsolate* isolate, MaybeHandle<ScopeInfo> outer_scope);

2654void DeclarationScope::RecalcPrivateNameContextChain() {
// The outermost scope in a class heritage expression is marked to skip the
// class scope during private name resolution. It is possible, however, that
// either the class scope won't require a Context and ScopeInfo, or the
// outermost scope in the heritage position won't. Simply copying the bit from
// full parse into the ScopeInfo will break lazy compilation. In the former
// case the scope that is marked to skip its outer scope will incorrectly skip
// a different class scope than the one we intended to skip. In the latter
// case variables resolved through an inner scope will incorrectly check the
// class scope since we lost the skip bit from the outermost heritage scope.
//
// This method fixes both cases by, in outermost to innermost order, copying
// the value of the skip bit from outer scopes that don't require a Context.
DCHECK(needs_private_name_context_chain_recalc_)((void) 0);
this->ForEach([](Scope* scope) {
  Scope* outer = scope->outer_scope();
  if (!outer) return Iteration::kDescend;
  if (!outer->NeedsContext()) {
    scope->private_name_lookup_skips_outer_class_ =
        outer->private_name_lookup_skips_outer_class();
  }
  if (!scope->is_function_scope() ||
      scope->AsDeclarationScope()->ShouldEagerCompile()) {
    return Iteration::kDescend;
  }
  return Iteration::kContinue;
});
2681}

2683void DeclarationScope::RecordNeedsPrivateNameContextChainRecalc() {
DCHECK_EQ(GetClosureScope(), this)((void) 0);
DeclarationScope* scope;
for (scope = this; scope != nullptr;
     scope = scope->outer_scope() != nullptr
                 ? scope->outer_scope()->GetClosureScope()
                 : nullptr) {
  if (scope->needs_private_name_context_chain_recalc_) return;
  scope->needs_private_name_context_chain_recalc_ = true;
}
2693}

2695// static
2696template <typename IsolateT>
2697void DeclarationScope::AllocateScopeInfos(ParseInfo* info, IsolateT* isolate) {
DeclarationScope* scope = info->literal()->scope();

// No one else should have allocated a scope info for this scope yet.
DCHECK(scope->scope_info_.is_null())((void) 0);

MaybeHandle<ScopeInfo> outer_scope;
if (scope->outer_scope_ != nullptr) {
  DCHECK((std::is_same<Isolate, v8::internal::Isolate>::value))((void) 0);
  outer_scope = scope->outer_scope_->scope_info_;
}

if (scope->needs_private_name_context_chain_recalc()) {
  scope->RecalcPrivateNameContextChain();
}
scope->AllocateScopeInfosRecursively(isolate, outer_scope);

// The debugger expects all shared function infos to contain a scope info.
// Since the top-most scope will end up in a shared function info, make sure
// it has one, even if it doesn't need a scope info.
// TODO(yangguo): Remove this requirement.
if (scope->scope_info_.is_null()) {
  scope->scope_info_ =
      ScopeInfo::Create(isolate, scope->zone(), scope, outer_scope);
}

// Ensuring that the outer script scope has a scope info avoids having
// special case for native contexts vs other contexts.
if (info->script_scope() && info->script_scope()->scope_info_.is_null()) {
  info->script_scope()->scope_info_ = isolate->factory()->empty_scope_info();
}
2728}

2730template V8_EXPORT_PRIVATE void DeclarationScope::AllocateScopeInfos(
  ParseInfo* info, Isolate* isolate);
2732template V8_EXPORT_PRIVATE void DeclarationScope::AllocateScopeInfos(
  ParseInfo* info, LocalIsolate* isolate);

2735int Scope::ContextLocalCount() const {
if (num_heap_slots() == 0) return 0;
Variable* function =
    is_function_scope() ? AsDeclarationScope()->function_var() : nullptr;
bool is_function_var_in_context =
    function != nullptr && function->IsContextSlot();
return num_heap_slots() - ContextHeaderLength() -
       (is_function_var_in_context ? 1 : 0);
2743}

2745VariableProxy* Scope::NewHomeObjectVariableProxy(AstNodeFactory* factory,
                                               const AstRawString* name,
                                               int start_pos) {
// VariableProxies of the home object cannot be resolved like a normal
// variable. Consider the case of a super.property usage in heritage position:
//
//   class C extends super.foo { m() { super.bar(); } }
//
// The super.foo property access is logically nested under C's class scope,
// which also has a home object due to its own method m's usage of
// super.bar(). However, super.foo must resolve super in C's outer scope.
//
// Because of the above, home object VariableProxies are always made directly
// on the Scope that needs the home object instead of the innermost scope.
DCHECK(needs_home_object())((void) 0);
if (!scope_info_.is_null()) {
  // This is a lazy compile, so the home object's context slot is already
  // known.
  Variable* home_object = variables_.Lookup(name);
  if (home_object == nullptr) {
    VariableLookupResult lookup_result;
    int index = scope_info_->ContextSlotIndex(name->string(), &lookup_result);
    DCHECK_GE(index, 0)((void) 0);
    bool was_added;
    home_object = variables_.Declare(zone(), this, name, lookup_result.mode,
                                     NORMAL_VARIABLE, lookup_result.init_flag,
                                     lookup_result.maybe_assigned_flag,
                                     IsStaticFlag::kNotStatic, &was_added);
    DCHECK(was_added)((void) 0);
    home_object->AllocateTo(VariableLocation::CONTEXT, index);
  }
  return factory->NewVariableProxy(home_object, start_pos);
}
// This is not a lazy compile. Add the unresolved home object VariableProxy to
// the unresolved list of the home object scope, which is not necessarily the
// innermost scope.
VariableProxy* proxy =
    factory->NewVariableProxy(name, NORMAL_VARIABLE, start_pos);
AddUnresolved(proxy);
return proxy;
2785}

2787bool IsComplementaryAccessorPair(VariableMode a, VariableMode b) {
switch (a) {
  case VariableMode::kPrivateGetterOnly:
    return b == VariableMode::kPrivateSetterOnly;
  case VariableMode::kPrivateSetterOnly:
    return b == VariableMode::kPrivateGetterOnly;
  default:
    return false;
}
2796}

2798void ClassScope::FinalizeReparsedClassScope(
  Isolate* isolate, MaybeHandle<ScopeInfo> maybe_scope_info,
  AstValueFactory* ast_value_factory, bool needs_allocation_fixup) {
// Set this bit so that DelcarationScope::Analyze recognizes
// the reparsed instance member initializer scope.
2803#ifdef DEBUG
is_reparsed_class_scope_ = true;
2805#endif

if (!needs_allocation_fixup) {
  return;
}

// Restore variable allocation results for context-allocated variables in
// the class scope from ScopeInfo, so that we don't need to run
// resolution and allocation on these variables again when generating
// code for the initializer function.
DCHECK(!maybe_scope_info.is_null())((void) 0);
Handle<ScopeInfo> scope_info = maybe_scope_info.ToHandleChecked();
DCHECK_EQ(scope_info->scope_type(), CLASS_SCOPE)((void) 0);
DCHECK_EQ(scope_info->StartPosition(), start_position_)((void) 0);

int context_header_length = scope_info->ContextHeaderLength();
DisallowGarbageCollection no_gc;
for (auto it : ScopeInfo::IterateLocalNames(scope_info)) {
  int slot_index = context_header_length + it->index();
  DCHECK_LT(slot_index, scope_info->ContextLength())((void) 0);

  const AstRawString* string = ast_value_factory->GetString(
      it->name(), SharedStringAccessGuardIfNeeded(isolate));
  Variable* var = string->IsPrivateName() ? LookupLocalPrivateName(string)
                                          : LookupLocal(string);
  DCHECK_NOT_NULL(var)((void) 0);
  var->AllocateTo(VariableLocation::CONTEXT, slot_index);
}
scope_info_ = scope_info;
2834}

2836Variable* ClassScope::DeclarePrivateName(const AstRawString* name,
                                       VariableMode mode,
                                       IsStaticFlag is_static_flag,
                                       bool* was_added) {
Variable* result = EnsureRareData()->private_name_map.Declare(
    zone(), this, name, mode, NORMAL_VARIABLE,
    InitializationFlag::kNeedsInitialization, MaybeAssignedFlag::kNotAssigned,
    is_static_flag, was_added);
if (*was_added) {
  locals_.Add(result);
  has_static_private_methods_ |=
      (result->is_static() &&
       IsPrivateMethodOrAccessorVariableMode(result->mode()));
} else if (IsComplementaryAccessorPair(result->mode(), mode) &&
           result->is_static_flag() == is_static_flag) {
  *was_added = true;
  result->set_mode(VariableMode::kPrivateGetterAndSetter);
}
result->ForceContextAllocation();
return result;
2856}

2858Variable* ClassScope::LookupLocalPrivateName(const AstRawString* name) {
RareData* rare_data = GetRareData();
if (rare_data == nullptr) {
  return nullptr;
}
return rare_data->private_name_map.Lookup(name);
2864}

2866UnresolvedList::Iterator ClassScope::GetUnresolvedPrivateNameTail() {
RareData* rare_data = GetRareData();
if (rare_data == nullptr) {
  return UnresolvedList::Iterator();
}
return rare_data->unresolved_private_names.end();
2872}

2874void ClassScope::ResetUnresolvedPrivateNameTail(UnresolvedList::Iterator tail) {
RareData* rare_data = GetRareData();
if (rare_data == nullptr ||
    rare_data->unresolved_private_names.end() == tail) {
  return;
}

bool tail_is_empty = tail == UnresolvedList::Iterator();
if (tail_is_empty) {
  // If the saved tail is empty, the list used to be empty, so clear it.
  rare_data->unresolved_private_names.Clear();
} else {
  rare_data->unresolved_private_names.Rewind(tail);
}
2888}

2890void ClassScope::MigrateUnresolvedPrivateNameTail(
  AstNodeFactory* ast_node_factory, UnresolvedList::Iterator tail) {
RareData* rare_data = GetRareData();
if (rare_data == nullptr ||
    rare_data->unresolved_private_names.end() == tail) {
  return;
}
UnresolvedList migrated_names;

// If the saved tail is empty, the list used to be empty, so we should
// migrate everything after the head.
bool tail_is_empty = tail == UnresolvedList::Iterator();
UnresolvedList::Iterator it =
    tail_is_empty ? rare_data->unresolved_private_names.begin() : tail;

for (; it != rare_data->unresolved_private_names.end(); ++it) {
  VariableProxy* proxy = *it;
  VariableProxy* copy = ast_node_factory->CopyVariableProxy(proxy);
  migrated_names.Add(copy);
}

// Replace with the migrated copies.
if (tail_is_empty) {
  rare_data->unresolved_private_names.Clear();
} else {
  rare_data->unresolved_private_names.Rewind(tail);
}
rare_data->unresolved_private_names.Append(std::move(migrated_names));
2918}

2920Variable* ClassScope::LookupPrivateNameInScopeInfo(const AstRawString* name) {
DCHECK(!scope_info_.is_null())((void) 0);
DCHECK_NULL(LookupLocalPrivateName(name))((void) 0);
DisallowGarbageCollection no_gc;

VariableLookupResult lookup_result;
int index = scope_info_->ContextSlotIndex(name->string(), &lookup_result);
if (index < 0) {
  return nullptr;
}

DCHECK(IsConstVariableMode(lookup_result.mode))((void) 0);
DCHECK_EQ(lookup_result.init_flag, InitializationFlag::kNeedsInitialization)((void) 0);
DCHECK_EQ(lookup_result.maybe_assigned_flag, MaybeAssignedFlag::kNotAssigned)((void) 0);

// Add the found private name to the map to speed up subsequent
// lookups for the same name.
bool was_added;
Variable* var = DeclarePrivateName(name, lookup_result.mode,
                                   lookup_result.is_static_flag, &was_added);
DCHECK(was_added)((void) 0);
var->AllocateTo(VariableLocation::CONTEXT, index);
return var;
2943}

2945Variable* ClassScope::LookupPrivateName(VariableProxy* proxy) {
DCHECK(!proxy->is_resolved())((void) 0);

for (PrivateNameScopeIterator scope_iter(this); !scope_iter.Done();
     scope_iter.Next()) {
  ClassScope* scope = scope_iter.GetScope();
  // Try finding it in the private name map first, if it can't be found,
  // try the deseralized scope info.
  Variable* var = scope->LookupLocalPrivateName(proxy->raw_name());
  if (var == nullptr && !scope->scope_info_.is_null()) {
    var = scope->LookupPrivateNameInScopeInfo(proxy->raw_name());
  }
  if (var != nullptr) {
    return var;
  }
}
return nullptr;
2962}

2964bool ClassScope::ResolvePrivateNames(ParseInfo* info) {
RareData* rare_data = GetRareData();
if (rare_data == nullptr || rare_data->unresolved_private_names.is_empty()) {
  return true;
}

UnresolvedList& list = rare_data->unresolved_private_names;
for (VariableProxy* proxy : list) {
  Variable* var = LookupPrivateName(proxy);
  if (var == nullptr) {
    // It's only possible to fail to resolve private names here if
    // this is at the top level or the private name is accessed through eval.
    DCHECK(info->flags().is_eval() || outer_scope_->is_script_scope())((void) 0);
    Scanner::Location loc = proxy->location();
    info->pending_error_handler()->ReportMessageAt(
        loc.beg_pos, loc.end_pos,
        MessageTemplate::kInvalidPrivateFieldResolution, proxy->raw_name());
    return false;
  } else {
    proxy->BindTo(var);
  }
}

// By now all unresolved private names should be resolved so
// clear the list.
list.Clear();
return true;
2991}

2993VariableProxy* ClassScope::ResolvePrivateNamesPartially() {
RareData* rare_data = GetRareData();
if (rare_data == nullptr || rare_data->unresolved_private_names.is_empty()) {
  return nullptr;
}

PrivateNameScopeIterator private_name_scope_iter(this);
private_name_scope_iter.Next();
UnresolvedList& unresolved = rare_data->unresolved_private_names;
bool has_private_names = rare_data->private_name_map.capacity() > 0;

// If the class itself does not have private names, nor does it have
// an outer private name scope, then we are certain any private name access
// inside cannot be resolved.
if (!has_private_names && private_name_scope_iter.Done() &&
    !unresolved.is_empty()) {
  return unresolved.first();
}

for (VariableProxy* proxy = unresolved.first(); proxy != nullptr;) {
  DCHECK(proxy->IsPrivateName())((void) 0);
  VariableProxy* next = proxy->next_unresolved();
  unresolved.Remove(proxy);
  Variable* var = nullptr;

  // If we can find private name in the current class scope, we can bind
  // them immediately because it's going to shadow any outer private names.
  if (has_private_names) {
    var = LookupLocalPrivateName(proxy->raw_name());
    if (var != nullptr) {
      var->set_is_used();
      proxy->BindTo(var);
      // If the variable being accessed is a static private method, we need to
      // save the class variable in the context to check that the receiver is
      // the class during runtime.
      has_explicit_static_private_methods_access_ |=
          (var->is_static() &&
           IsPrivateMethodOrAccessorVariableMode(var->mode()));
    }
  }

  // If the current scope does not have declared private names,
  // try looking from the outer class scope later.
  if (var == nullptr) {
    // There's no outer private name scope so we are certain that the variable
    // cannot be resolved later.
    if (private_name_scope_iter.Done()) {
      return proxy;
    }

    // The private name may be found later in the outer private name scope, so
    // push it to the outer sopce.
    private_name_scope_iter.AddUnresolvedPrivateName(proxy);
  }

  proxy = next;
}

DCHECK(unresolved.is_empty())((void) 0);
return nullptr;
3053}

3055Variable* ClassScope::DeclareBrandVariable(AstValueFactory* ast_value_factory,
                                         IsStaticFlag is_static_flag,
                                         int class_token_pos) {
DCHECK_IMPLIES(GetRareData() != nullptr, GetRareData()->brand == nullptr)((void) 0);
bool was_added;
Variable* brand = Declare(zone(), ast_value_factory->dot_brand_string(),
                          VariableMode::kConst, NORMAL_VARIABLE,
                          InitializationFlag::kNeedsInitialization,
                          MaybeAssignedFlag::kNotAssigned, &was_added);
DCHECK(was_added)((void) 0);
brand->set_is_static_flag(is_static_flag);
brand->ForceContextAllocation();
brand->set_is_used();
EnsureRareData()->brand = brand;
brand->set_initializer_position(class_token_pos);
return brand;
3071}

3073Variable* ClassScope::DeclareClassVariable(AstValueFactory* ast_value_factory,
                                         const AstRawString* name,
                                         int class_token_pos) {
DCHECK_NULL(class_variable_)((void) 0);
bool was_added;
class_variable_ =
    Declare(zone(), name == nullptr ? ast_value_factory->dot_string() : name,
            VariableMode::kConst, NORMAL_VARIABLE,
            InitializationFlag::kNeedsInitialization,
            MaybeAssignedFlag::kMaybeAssigned, &was_added);
DCHECK(was_added)((void) 0);
class_variable_->set_initializer_position(class_token_pos);
return class_variable_;
3086}

3088PrivateNameScopeIterator::PrivateNameScopeIterator(Scope* start)
  : start_scope_(start), current_scope_(start) {
if (!start->is_class_scope() || start->AsClassScope()->IsParsingHeritage()) {
  Next();
}
3093}

3095void PrivateNameScopeIterator::Next() {
DCHECK(!Done())((void) 0);
Scope* inner = current_scope_;
Scope* scope = inner->outer_scope();
while (scope != nullptr) {
  if (scope->is_class_scope()) {
    if (!inner->private_name_lookup_skips_outer_class()) {
      current_scope_ = scope;
      return;
    }
    skipped_any_scopes_ = true;
  }
  inner = scope;
  scope = scope->outer_scope();
}
current_scope_ = nullptr;
3111}

3113void PrivateNameScopeIterator::AddUnresolvedPrivateName(VariableProxy* proxy) {
// During a reparse, current_scope_->already_resolved_ may be true here,
// because the class scope is deserialized while the function scope inside may
// be new.
DCHECK(!proxy->is_resolved())((void) 0);
DCHECK(proxy->IsPrivateName())((void) 0);
GetScope()->EnsureRareData()->unresolved_private_names.Add(proxy);
// Any closure scope that contain uses of private names that skips over a
// class scope due to heritage expressions need private name context chain
// recalculation, since not all scopes require a Context or ScopeInfo. See
// comment in DeclarationScope::RecalcPrivateNameContextChain.
if (V8_UNLIKELY(skipped_any_scopes_)(__builtin_expect(!!(skipped_any_scopes_), 0))) {
  start_scope_->GetClosureScope()->RecordNeedsPrivateNameContextChainRecalc();
}
3127}

3129}  // namespace internal
3130}  // namespace v8