// Copyright 2012 the V8 project authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

#include "src/ast/scopes.h"

#include <optional>

#include <set>

#include "src/ast/ast.h"

#include "src/base/logging.h"

#include "src/builtins/accessors.h"

#include "src/common/message-template.h"

#include "src/heap/local-factory-inl.h"

#include "src/logging/runtime-call-stats-scope.h"

#include "src/objects/scope-info.h"

#include "src/objects/string-inl.h"

#include "src/objects/string-set.h"

#include "src/parsing/parse-info.h"

#include "src/parsing/parser.h"

#include "src/parsing/preparse-data.h"

#include "src/zone/zone.h"

namespace v8 {

namespace internal {

// ----------------------------------------------------------------------------

// Implementation of LocalsMap

//

// Note: We are storing the handle locations as key values in the hash map.

// When inserting a new variable via Declare(), we rely on the fact that

// the handle location remains alive for the duration of that variable

// use. Because a Variable holding a handle with the same location exists

// this is ensured.

static_assert(sizeof(VariableMap) == (sizeof(void*) + 2 * sizeof(uint32_t) +

sizeof(ZoneAllocationPolicy)),

"Empty base optimization didn't kick in for VariableMap");

VariableMap::VariableMap(Zone* zone)

: ZoneHashMap(8, ZoneAllocationPolicy(zone)) {}

VariableMap::VariableMap(const VariableMap& other, Zone* zone)

: ZoneHashMap(other, ZoneAllocationPolicy(zone)) {}

Variable* 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());

// 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);

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);

}

void VariableMap::Remove(Variable* var) {

const AstRawString* name = var->raw_name();

ZoneHashMap::Remove(const_cast<AstRawString*>(name), name->Hash());

}

void VariableMap::Add(Variable* var) {

const AstRawString* name = var->raw_name();

Entry* p = ZoneHashMap::LookupOrInsert(const_cast<AstRawString*>(name),

name->Hash());

DCHECK_NULL(p->value);

DCHECK_EQ(name, p->key);

p->value = var;

}

Variable* 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);

DCHECK_NOT_NULL(p->value);

return reinterpret_cast<Variable*>(p->value);

}

return nullptr;

}

// ----------------------------------------------------------------------------

// Implementation of Scope

Scope::Scope(Zone* zone, ScopeType scope_type)

: outer_scope_(nullptr), variables_(zone), scope_type_(scope_type) {

DCHECK(is_script_scope());

SetDefaults();

}

Scope::Scope(Zone* zone, Scope* outer_scope, ScopeType scope_type)

: outer_scope_(outer_scope), variables_(zone), scope_type_(scope_type) {

DCHECK(!is_script_scope());

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);

}

Variable* 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);

home_object_variable->set_is_used();

home_object_variable->ForceContextAllocation();

return home_object_variable;

}

Variable* 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);

static_home_object_variable->set_is_used();

static_home_object_variable->ForceContextAllocation();

return static_home_object_variable;

}

DeclarationScope::DeclarationScope(Zone* zone,

AstValueFactory* ast_value_factory,

REPLMode repl_mode)

: Scope(zone, repl_mode == REPLMode::kYes ? REPL_MODE_SCOPE : SCRIPT_SCOPE),

function_kind_(repl_mode == REPLMode::kYes

? FunctionKind::kAsyncFunction

: FunctionKind::kNormalFunction),

params_(4, zone) {

DCHECK(is_script_scope());

SetDefaults();

receiver_ = DeclareDynamicGlobal(ast_value_factory->this_string(),

THIS_VARIABLE, this);

}

DeclarationScope::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(!is_script_scope());

SetDefaults();

}

ModuleScope::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);

}

ModuleScope::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);

}

ClassScope::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);

}

template <typename IsolateT>

ClassScope::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);

EnsureRareData()->brand = brand;

}

// If the class variable is context-allocated and its index is

// saved for deserialization, deserialize it.

if (scope_info->HasSavedClassVariable()) {

Tagged<String> name;

int index;

std::tie(name, index) = scope_info->SavedClassVariable();

DCHECK_EQ(scope_info->ContextLocalMode(index), VariableMode::kConst);

DCHECK_EQ(scope_info->ContextLocalInitFlag(index),

InitializationFlag::kNeedsInitialization);

DCHECK_EQ(scope_info->ContextLocalMaybeAssignedFlag(index),

MaybeAssignedFlag::kMaybeAssigned);

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());

set_start_position(scope_info->StartPosition());

set_end_position(scope_info->EndPosition());

}

template ClassScope::ClassScope(Isolate* isolate, Zone* zone,

AstValueFactory* ast_value_factory,

Handle<ScopeInfo> scope_info);

template ClassScope::ClassScope(LocalIsolate* isolate, Zone* zone,

AstValueFactory* ast_value_factory,

Handle<ScopeInfo> scope_info);

Scope::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());

SetDefaults();

#ifdef DEBUG

already_resolved_ = true;

#endif

set_language_mode(scope_info->language_mode());

DCHECK_EQ(ContextHeaderLength(), num_heap_slots_);

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 existence of the home

// object variable (we don't store it explicitly).

DCHECK_NOT_NULL(ast_value_factory);

int home_object_index = scope_info->ContextSlotIndex(

*ast_value_factory->dot_home_object_string()->string());

DCHECK_IMPLIES(home_object_index >= 0,

scope_type == CLASS_SCOPE || scope_type == BLOCK_SCOPE);

if (home_object_index >= 0) {

is_block_scope_for_object_literal_ = true;

}

}

}

DeclarationScope::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(!is_script_scope());

SetDefaults();

if (scope_info->SloppyEvalCanExtendVars()) {

DCHECK(!is_eval_scope());

sloppy_eval_can_extend_vars_ = true;

}

if (scope_info->ClassScopeHasPrivateBrand()) {

DCHECK(IsClassConstructor(function_kind()));

class_scope_has_private_brand_ = true;

}

}

Scope::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();

#ifdef DEBUG

already_resolved_ = true;

#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);

AllocateHeapSlot(variable);

}

void DeclarationScope::SetDefaults() {

is_declaration_scope_ = true;

has_simple_parameters_ = true;

#if V8_ENABLE_WEBASSEMBLY

is_asm_module_ = false;

#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;

#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;

#endif

}

void Scope::SetDefaults() {

#ifdef DEBUG

scope_name_ = nullptr;

already_resolved_ = false;

needs_migration_ = false;

#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;

needs_home_object_ = false;

is_block_scope_for_object_literal_ = false;

has_using_declaration_ = false;

has_await_using_declaration_ = false;

is_wrapped_function_ = false;

num_stack_slots_ = 0;

num_heap_slots_ = ContextHeaderLength();

set_language_mode(LanguageMode::kSloppy);

}

bool Scope::HasSimpleParameters() {

DeclarationScope* scope = GetClosureScope();

return !scope->is_function_scope() || scope->has_simple_parameters();

}

void DeclarationScope::set_should_eager_compile() {

should_eager_compile_ = !was_lazily_parsed_;

}

#if V8_ENABLE_WEBASSEMBLY

void DeclarationScope::set_is_asm_module() { is_asm_module_ = true; }

bool Scope::IsAsmModule() const {

return is_function_scope() && AsDeclarationScope()->is_asm_module();

}

bool 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;

}

#endif // V8_ENABLE_WEBASSEMBLY

template <typename IsolateT>

Scope* Scope::DeserializeScopeChain(IsolateT* isolate, Zone* zone,

Tagged<ScopeInfo> scope_info,

DeclarationScope* script_scope,

AstValueFactory* ast_value_factory,

DeserializationMode deserialization_mode,

ParseInfo* parse_info) {

// Reconstruct the outer scope chain from a closure's context chain.

Scope* current_scope = nullptr;

Scope* innermost_scope = nullptr;

Scope* outer_scope = nullptr;

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->is_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));

}

DCHECK(!scope_info->HasOuterScopeInfo());

break;

} else if (scope_info->scope_type() == FUNCTION_SCOPE) {

outer_scope = zone->New<DeclarationScope>(

zone, FUNCTION_SCOPE, ast_value_factory, handle(scope_info, isolate));

#if V8_ENABLE_WEBASSEMBLY

if (scope_info->IsAsmModule()) {

outer_scope->AsDeclarationScope()->set_is_asm_module();

}

#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);

if (parse_info) {

parse_info->set_has_module_in_scope_chain();

}

} else {

DCHECK_EQ(scope_info->scope_type(), CATCH_SCOPE);

DCHECK_EQ(scope_info->ContextLocalCount(), 1);

DCHECK_EQ(scope_info->ContextLocalMode(0), VariableMode::kVar);

DCHECK_EQ(scope_info->ContextLocalInitFlag(0), kCreatedInitialized);

DCHECK(scope_info->HasInlinedLocalNames());

Tagged<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 (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()

: Tagged<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;

}

template <typename IsolateT>

void Scope::SetScriptScopeInfo(IsolateT* isolate,

DeclarationScope* script_scope) {

if (script_scope->scope_info_.is_null()) {

script_scope->SetScriptScopeInfo(

isolate->factory()->global_this_binding_scope_info());

}

}

template EXPORT_TEMPLATE_DEFINE(

V8_EXPORT_PRIVATE) void Scope::SetScriptScopeInfo(Isolate* isolate,

DeclarationScope*

script_scope);

template EXPORT_TEMPLATE_DEFINE(

V8_EXPORT_PRIVATE) void Scope::SetScriptScopeInfo(LocalIsolate* isolate,

DeclarationScope*

script_scope);

template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)

Scope* Scope::DeserializeScopeChain(

Isolate* isolate, Zone* zone, Tagged<ScopeInfo> scope_info,

DeclarationScope* script_scope, AstValueFactory* ast_value_factory,

DeserializationMode deserialization_mode, ParseInfo* parse_info);

template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)

Scope* Scope::DeserializeScopeChain(

LocalIsolate* isolate, Zone* zone, Tagged<ScopeInfo> scope_info,

DeclarationScope* script_scope, AstValueFactory* ast_value_factory,

DeserializationMode deserialization_mode, ParseInfo* parse_info);

DeclarationScope* Scope::AsDeclarationScope() {

// Here and below: if an attacker corrupts the in-sandox SFI::unique_id or

// fields of a Script object, we can get confused about which type of scope

// we're operating on. These CHECKs defend against that.

SBXCHECK(is_declaration_scope());

return static_cast<DeclarationScope*>(this);

}

const DeclarationScope* Scope::AsDeclarationScope() const {

SBXCHECK(is_declaration_scope());

return static_cast<const DeclarationScope*>(this);

}

ModuleScope* Scope::AsModuleScope() {

SBXCHECK(is_module_scope());

return static_cast<ModuleScope*>(this);

}

const ModuleScope* Scope::AsModuleScope() const {

SBXCHECK(is_module_scope());

return static_cast<const ModuleScope*>(this);

}

ClassScope* Scope::AsClassScope() {

SBXCHECK(is_class_scope());

return static_cast<ClassScope*>(this);

}

const ClassScope* Scope::AsClassScope() const {

SBXCHECK(is_class_scope());

return static_cast<const ClassScope*>(this);

}

void DeclarationScope::DeclareSloppyBlockFunction(

SloppyBlockFunctionStatement* sloppy_block_function) {

sloppy_block_functions_.Add(sloppy_block_function);

}

void DeclarationScope::HoistSloppyBlockFunctions(AstNodeFactory* factory) {

DCHECK(is_sloppy(language_mode()));

DCHECK(is_function_scope() || is_eval_scope() || is_script_scope() ||

(is_block_scope() && outer_scope()->is_function_scope()));

DCHECK(HasSimpleParameters() || is_block_scope() || is_being_lazily_parsed_);

DCHECK_EQ(factory == nullptr, is_being_lazily_parsed_);

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() ||

is_script_scope());

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()) &&

!var->is_sloppy_block_function()) {

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_);

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.

//

// This synthesized var for Annex B functions-in-block (FiB) may be

// declared multiple times for the same var scope, such as in the case of

// shadowed functions-in-block like the following:

//

// {

// function f() {}

// { function f() {} }

// }

//

// Redeclarations for vars do not create new bindings, but the

// redeclarations' initializers are still run. That is, shadowed FiB will

// result in multiple assignments to the same synthesized var.

Variable* var = DeclareVariable(

declaration, name, pos, VariableMode::kVar, NORMAL_VARIABLE,

Variable::DefaultInitializationFlag(VariableMode::kVar), &was_added,

nullptr, &ok);

DCHECK(ok);

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_);

bool was_added;

Variable* var = DeclareVariableName(name, VariableMode::kVar, &was_added);

if (sloppy_block_function->init() == Token::kAssign) {

var->SetMaybeAssigned();

}

}

}

}

void DeclarationScope::TakeUnresolvedReferencesFromParent() {

DCHECK(outer_scope_->reparsing_for_class_initializer_);

unresolved_list_.MoveTail(&outer_scope_->unresolved_list_,

outer_scope_->unresolved_list_.begin());

}

bool DeclarationScope::Analyze(ParseInfo* info) {

RCS_SCOPE(info->runtime_call_stats(),

RuntimeCallCounterId::kCompileScopeAnalysis,

RuntimeCallStats::kThreadSpecific);

DCHECK_NOT_NULL(info->literal());

DeclarationScope* scope = info->literal()->scope();

std::optional<AllowHandleDereference> allow_deref;

#ifdef DEBUG

if (scope->outer_scope() && !scope->outer_scope()->scope_info_.is_null()) {

allow_deref.emplace();

}

#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() ||

scope->outer_scope()->already_resolved_);

// 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);

allow_deref.emplace();

info->consumed_preparse_data()->RestoreScopeAllocationData(

scope, info->ast_value_factory(), info->zone());

}

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

scope->RewriteReplGlobalVariables();

#ifdef DEBUG

if (v8_flags.print_scopes) {

PrintF("Global scope:\n");

scope->Print();

}

scope->CheckScopePositions();

scope->CheckZones();

#endif

return true;

}

void DeclarationScope::DeclareThis(AstValueFactory* ast_value_factory) {

DCHECK(has_this_declaration());

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);

// Derived constructors have hole checks when calling super. Mark the 'this'

// variable as having hole initialization forced so that TDZ elision analysis

// applies and numbers the variable.

if (derived_constructor) {

receiver_->ForceHoleInitialization(

Variable::kHasHoleCheckUseInUnknownScope);

}

locals_.Add(receiver_);

}

void DeclarationScope::DeclareArguments(AstValueFactory* ast_value_factory) {

DCHECK(is_function_scope());

DCHECK(!is_arrow_scope());

// 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;

}

}

void DeclarationScope::DeclareDefaultFunctionVariables(

AstValueFactory* ast_value_factory) {

DCHECK(is_function_scope());

DCHECK(!is_arrow_scope());

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);

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);

}

}

Variable* DeclarationScope::DeclareFunctionVar(const AstRawString* name,

Scope* cache) {

DCHECK(is_function_scope());

if (cache == nullptr) {

DCHECK_NULL(function_);

cache = this;

} else if (function_ != nullptr) {

return function_;

}

DCHECK(this->IsOuterScopeOf(cache));

DCHECK_NULL(cache->variables_.Lookup(name));

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_;

}

Variable* DeclarationScope::DeclareGeneratorObjectVar(

const AstRawString* name) {

DCHECK(is_function_scope() || is_module_scope() || is_repl_mode_scope());

DCHECK_NULL(generator_object_var());

Variable* result = EnsureRareData()->generator_object =

NewTemporary(name, kNotAssigned);

result->set_is_used();

return result;

}

Scope* Scope::FinalizeBlockScope() {

DCHECK(is_block_scope());

#ifdef DEBUG

DCHECK_NE(sibling_, this);

#endif

if (variables_.occupancy() > 0 ||

(is_declaration_scope() &&

AsDeclarationScope()->sloppy_eval_can_extend_vars())) {

return this;

}

DCHECK(!is_class_scope());

// 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() ||

!AsDeclarationScope()->sloppy_eval_can_extend_vars());

// This block does not need a context.

num_heap_slots_ = 0;

// Mark scope as removed by making it its own sibling.

#ifdef DEBUG

sibling_ = this;

#endif

return nullptr;

}

void DeclarationScope::AddLocal(Variable* var) {

DCHECK(!already_resolved_);

// Temporaries are only placed in ClosureScopes.

DCHECK_EQ(GetClosureScope(), this);

locals_.Add(var);

}

void Scope::Snapshot::Reparent(DeclarationScope* new_parent) {

DCHECK_EQ(new_parent, outer_scope_->inner_scope_);

DCHECK_EQ(new_parent->outer_scope_, outer_scope_);

DCHECK_EQ(new_parent, new_parent->GetClosureScope());

DCHECK_NULL(new_parent->inner_scope_);

DCHECK(new_parent->unresolved_list_.is_empty());

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);

}

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_;

}

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());

DCHECK_EQ(local->scope(), local->scope()->GetClosureScope());

DCHECK_NE(local->scope(), new_parent);

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_->calls_eval_) {

new_parent->RecordEvalCall();

outer_scope_->calls_eval_ = false;

declaration_scope_->sloppy_eval_can_extend_vars_ = false;

}

}

Variable* Scope::LookupInScopeInfo(const AstRawString* name, Scope* cache) {

DCHECK(!scope_info_.is_null());

DCHECK(this->IsOuterScopeOf(cache));

DCHECK_NULL(cache->variables_.Lookup(name));

DisallowGarbageCollection no_gc;

Tagged<String> name_handle = *name->string();

Tagged<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_handle, &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());

var->AllocateTo(VariableLocation::CONTEXT, index);

return cache->variables_.Lookup(name);

}

if (!is_module_scope()) {

DCHECK_NE(index, scope_info->ReceiverContextSlotIndex());

}