#include <scopes.h>

Inheritance diagram for v8::internal::Scope:

Collaboration diagram for v8::internal::Scope:

Public Member Functions
	Scope (Scope outer_scope, ScopeType scope_type, AstValueFactory value_factory, Zone *zone)

void	SetScopeName (const AstRawString *scope_name)

void	Initialize ()

Scope *	FinalizeBlockScope ()

Zone *	zone () const

Variable *	LookupLocal (const AstRawString *name)

Variable *	LookupFunctionVar (const AstRawString name, AstNodeFactory< AstNullVisitor > factory)

Variable *	Lookup (const AstRawString *name)

void	DeclareFunctionVar (VariableDeclaration *declaration)

Variable *	DeclareParameter (const AstRawString *name, VariableMode mode)

Variable *	DeclareLocal (const AstRawString name, VariableMode mode, InitializationFlag init_flag, MaybeAssignedFlag maybe_assigned_flag=kNotAssigned, Interface interface=Interface::NewValue())

Variable *	DeclareDynamicGlobal (const AstRawString *name)

template<class Visitor >
VariableProxy *	NewUnresolved (AstNodeFactory< Visitor > factory, const AstRawString name, Interface *interface=Interface::NewValue(), int position=RelocInfo::kNoPosition)

void	RemoveUnresolved (VariableProxy *var)

Variable *	NewInternal (const AstRawString *name)

Variable *	NewTemporary (const AstRawString *name)

void	AddDeclaration (Declaration *declaration)

void	SetIllegalRedeclaration (Expression *expression)

void	VisitIllegalRedeclaration (AstVisitor *visitor)

bool	HasIllegalRedeclaration () const

Declaration *	CheckConflictingVarDeclarations ()

void	RecordWithStatement ()

void	RecordEvalCall ()

void	SetStrictMode (StrictMode strict_mode)

void	SetAsmModule ()

int	start_position () const

void	set_start_position (int statement_pos)

int	end_position () const

void	set_end_position (int statement_pos)

void	ForceContextAllocation ()

bool	has_forced_context_allocation () const

bool	is_eval_scope () const

bool	is_function_scope () const

bool	is_module_scope () const

bool	is_global_scope () const

bool	is_catch_scope () const

bool	is_block_scope () const

bool	is_with_scope () const

bool	is_declaration_scope () const

bool	is_strict_eval_scope () const

bool	calls_eval () const

bool	calls_sloppy_eval ()

bool	outer_scope_calls_sloppy_eval () const

bool	asm_module () const

bool	asm_function () const

bool	inside_with () const

bool	contains_with () const

ScopeType	scope_type () const

StrictMode	strict_mode () const

Variable *	receiver ()

VariableDeclaration *	function () const

Variable *	parameter (int index) const

int	num_parameters () const

Variable *	arguments () const

ZoneList< Declaration * > *	declarations ()

ZoneList< Scope * > *	inner_scopes ()

Scope *	outer_scope () const

Interface *	interface () const

void	CollectStackAndContextLocals (ZoneList< Variable * > stack_locals, ZoneList< Variable > *context_locals)

int	num_var_or_const ()

int	num_stack_slots () const

int	num_heap_slots () const

int	StackLocalCount () const

int	ContextLocalCount () const

int	num_modules () const

Variable *	module_var () const

void	ForceEagerCompilation ()

bool	AllowsLazyCompilation () const

bool	AllowsLazyCompilationWithoutContext () const

bool	HasTrivialOuterContext () const

bool	HasLazyCompilableOuterContext () const

int	ContextChainLength (Scope *scope)

Scope *	GlobalScope ()

Scope *	DeclarationScope ()

Handle< ScopeInfo >	GetScopeInfo ()

void	GetNestedScopeChain (List< Handle< ScopeInfo > > *chain, int statement_position)

bool	IsDeclared (const AstRawString *name)

Public Member Functions inherited from v8::internal::ZoneObject
	INLINE (void operator new(size_t size, Zone zone))

void	operator delete (void *, size_t)

void	operator delete (void pointer, Zone zone)

Static Public Member Functions
static bool	Analyze (CompilationInfo *info)

static Scope *	DeserializeScopeChain (Context context, Scope global_scope, Zone *zone)

Protected Types
enum	BindingKind { BOUND , BOUND_EVAL_SHADOWED , UNBOUND , UNBOUND_EVAL_SHADOWED , DYNAMIC_LOOKUP }

Protected Member Functions
bool	already_resolved ()

Variable *	NonLocal (const AstRawString *name, VariableMode mode)

Variable *	LookupRecursive (VariableProxy proxy, BindingKind binding_kind, AstNodeFactory< AstNullVisitor > *factory)

MUST_USE_RESULT bool	ResolveVariable (CompilationInfo info, VariableProxy proxy, AstNodeFactory< AstNullVisitor > *factory)

MUST_USE_RESULT bool	ResolveVariablesRecursively (CompilationInfo info, AstNodeFactory< AstNullVisitor > factory)

void	PropagateScopeInfo (bool outer_scope_calls_sloppy_eval)

bool	HasTrivialContext () const

bool	MustAllocate (Variable *var)

bool	MustAllocateInContext (Variable *var)

bool	HasArgumentsParameter ()

void	AllocateStackSlot (Variable *var)

void	AllocateHeapSlot (Variable *var)

void	AllocateParameterLocals ()

void	AllocateNonParameterLocal (Variable *var)

void	AllocateNonParameterLocals ()

void	AllocateVariablesRecursively ()

void	AllocateModulesRecursively (Scope *host_scope)

MUST_USE_RESULT bool	AllocateVariables (CompilationInfo info, AstNodeFactory< AstNullVisitor > factory)

Protected Attributes
Isolate *const	isolate_

Scope *	outer_scope_

ZoneList< Scope * >	inner_scopes_

ScopeType	scope_type_

const AstRawString *	scope_name_

VariableMap	variables_

ZoneList< Variable * >	internals_

ZoneList< Variable * >	temps_

ZoneList< Variable * >	params_

DynamicScopePart *	dynamics_

ZoneList< VariableProxy * >	unresolved_

ZoneList< Declaration * >	decls_

Variable *	receiver_

VariableDeclaration *	function_

Variable *	arguments_

Interface *	interface_

Expression *	illegal_redecl_

bool	scope_inside_with_

bool	scope_contains_with_

bool	scope_calls_eval_

bool	asm_module_

bool	asm_function_

StrictMode	strict_mode_

int	start_position_

int	end_position_

bool	outer_scope_calls_sloppy_eval_

bool	inner_scope_calls_eval_

bool	force_eager_compilation_

bool	force_context_allocation_

bool	already_resolved_

int	num_var_or_const_

int	num_stack_slots_

int	num_heap_slots_

int	num_modules_

Variable *	module_var_

Handle< ScopeInfo >	scope_info_

Private Member Functions
	Scope (Scope inner_scope, ScopeType type, Handle< ScopeInfo > scope_info, AstValueFactory value_factory, Zone *zone)

	Scope (Scope inner_scope, const AstRawString catch_variable_name, AstValueFactory value_factory, Zone zone)

void	AddInnerScope (Scope *inner_scope)

void	SetDefaults (ScopeType type, Scope *outer_scope, Handle< ScopeInfo > scope_info)

Private Attributes
AstValueFactory *	ast_value_factory_

Zone *	zone_

Friends
class	ParserFactory

Detailed Description

Definition at line 70 of file scopes.h.

Member Enumeration Documentation

◆ BindingKind

enum v8::internal::Scope::BindingKind

protected

Enumerator
BOUND
BOUND_EVAL_SHADOWED
UNBOUND
UNBOUND_EVAL_SHADOWED
DYNAMIC_LOOKUP

Definition at line 516 of file scopes.h.

                    {
     // The variable reference could be statically resolved to a variable binding
     // which is returned. There is no 'with' statement between the reference and
     // the binding and no scope between the reference scope (inclusive) and
     // binding scope (exclusive) makes a sloppy 'eval' call.
     BOUND,
  
     // The variable reference could be statically resolved to a variable binding
     // which is returned. There is no 'with' statement between the reference and
     // the binding, but some scope between the reference scope (inclusive) and
     // binding scope (exclusive) makes a sloppy 'eval' call, that might
     // possibly introduce variable bindings shadowing the found one. Thus the
     // found variable binding is just a guess.
     BOUND_EVAL_SHADOWED,
  
     // The variable reference could not be statically resolved to any binding
     // and thus should be considered referencing a global variable. NULL is
     // returned. The variable reference is not inside any 'with' statement and
     // no scope between the reference scope (inclusive) and global scope
     // (exclusive) makes a sloppy 'eval' call.
     UNBOUND,
  
     // The variable reference could not be statically resolved to any binding
     // NULL is returned. The variable reference is not inside any 'with'
     // statement, but some scope between the reference scope (inclusive) and
     // global scope (exclusive) makes a sloppy 'eval' call, that might
     // possibly introduce a variable binding. Thus the reference should be
     // considered referencing a global variable unless it is shadowed by an
     // 'eval' introduced binding.
     UNBOUND_EVAL_SHADOWED,
  
     // The variable could not be statically resolved and needs to be looked up
     // dynamically. NULL is returned. There are two possible reasons:
     // * A 'with' statement has been encountered and there is no variable
     //   binding for the name between the variable reference and the 'with'.
     //   The variable potentially references a property of the 'with' object.
     // * The code is being executed as part of a call to 'eval' and the calling
     //   context chain contains either a variable binding for the name or it
     //   contains a 'with' context.
     DYNAMIC_LOOKUP
   };

Constructor & Destructor Documentation

◆ Scope() [1/3]

v8::internal::Scope::Scope	(	Scope *	outer_scope,
		ScopeType	scope_type,
		AstValueFactory *	value_factory,
		Zone *	zone
	)

Definition at line 70 of file scopes.cc.

     : isolate_(zone->isolate()),
       inner_scopes_(4, zone),
       variables_(zone),
       internals_(4, zone),
       temps_(4, zone),
       params_(4, zone),
       unresolved_(16, zone),
       decls_(4, zone),
       interface_(FLAG_harmony_modules &&
                  (scope_type == MODULE_SCOPE || scope_type == GLOBAL_SCOPE)
                      ? Interface::NewModule(zone) : NULL),
       already_resolved_(false),
       ast_value_factory_(ast_value_factory),
       zone_(zone) {
   SetDefaults(scope_type, outer_scope, Handle<ScopeInfo>::null());
   // The outermost scope must be a global scope.
   DCHECK(scope_type == GLOBAL_SCOPE || outer_scope != NULL);
   DCHECK(!HasIllegalRedeclaration());
 }

References DCHECK, v8::internal::GLOBAL_SCOPE, HasIllegalRedeclaration(), NULL, outer_scope(), scope_type(), and SetDefaults().

Referenced by DeserializeScopeChain().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Scope() [2/3]

v8::internal::Scope::Scope	(	Scope *	inner_scope,
		ScopeType	type,
		Handle< ScopeInfo >	scope_info,
		AstValueFactory *	value_factory,
		Zone *	zone
	)

private

Definition at line 93 of file scopes.cc.

     : isolate_(zone->isolate()),
       inner_scopes_(4, zone),
       variables_(zone),
       internals_(4, zone),
       temps_(4, zone),
       params_(4, zone),
       unresolved_(16, zone),
       decls_(4, zone),
       interface_(NULL),
       already_resolved_(true),
       ast_value_factory_(value_factory),
       zone_(zone) {
   SetDefaults(scope_type, NULL, scope_info);
   if (!scope_info.is_null()) {
     num_heap_slots_ = scope_info_->ContextLength();
   }
   // Ensure at least MIN_CONTEXT_SLOTS to indicate a materialized context.
   num_heap_slots_ = Max(num_heap_slots_,
                         static_cast<int>(Context::MIN_CONTEXT_SLOTS));
   AddInnerScope(inner_scope);
 }

References AddInnerScope(), v8::internal::Handle< T >::is_null(), v8::internal::Max(), v8::internal::Context::MIN_CONTEXT_SLOTS, NULL, num_heap_slots_, scope_info_, scope_type(), and SetDefaults().

Here is the call graph for this function:

◆ Scope() [3/3]

v8::internal::Scope::Scope	(	Scope *	inner_scope,
		const AstRawString *	catch_variable_name,
		AstValueFactory *	value_factory,
		Zone *	zone
	)

private

Definition at line 121 of file scopes.cc.

     : isolate_(zone->isolate()),
       inner_scopes_(1, zone),
       variables_(zone),
       internals_(0, zone),
       temps_(0, zone),
       params_(0, zone),
       unresolved_(0, zone),
       decls_(0, zone),
       interface_(NULL),
       already_resolved_(true),
       ast_value_factory_(value_factory),
       zone_(zone) {
   SetDefaults(CATCH_SCOPE, NULL, Handle<ScopeInfo>::null());
   AddInnerScope(inner_scope);
   ++num_var_or_const_;
   num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
   Variable* variable = variables_.Declare(this,
                                           catch_variable_name,
                                           VAR,
                                           true,  // Valid left-hand side.
                                           Variable::NORMAL,
                                           kCreatedInitialized);
   AllocateHeapSlot(variable);
 }

References AddInnerScope(), AllocateHeapSlot(), v8::internal::CATCH_SCOPE, v8::internal::VariableMap::Declare(), v8::internal::kCreatedInitialized, v8::internal::Context::MIN_CONTEXT_SLOTS, v8::internal::Variable::NORMAL, NULL, num_heap_slots_, num_var_or_const_, SetDefaults(), v8::internal::VAR, and variables_.

Here is the call graph for this function:

Member Function Documentation

◆ AddDeclaration()

void v8::internal::Scope::AddDeclaration ( Declaration * declaration )

Definition at line 525 of file scopes.cc.

                                                    {
   decls_.Add(declaration, zone());
 }

References decls_, and zone().

Referenced by v8::internal::Parser::Declare().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddInnerScope()

void v8::internal::Scope::AddInnerScope ( Scope * inner_scope )

inlineprivate

Definition at line 612 of file scopes.h.

                                          {
     if (inner_scope != NULL) {
       inner_scopes_.Add(inner_scope, zone_);
       inner_scope->outer_scope_ = this;
     }
   }

References inner_scopes_, NULL, outer_scope_, and zone_.

Referenced by DeserializeScopeChain(), FinalizeBlockScope(), and Scope().

Here is the caller graph for this function:

◆ AllocateHeapSlot()

void v8::internal::Scope::AllocateHeapSlot ( Variable * var )

protected

Definition at line 1238 of file scopes.cc.

                                           {
   var->AllocateTo(Variable::CONTEXT, num_heap_slots_++);
 }

References v8::internal::Variable::AllocateTo(), v8::internal::Variable::CONTEXT, and num_heap_slots_.

Referenced by AllocateNonParameterLocal(), AllocateParameterLocals(), and Scope().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AllocateModulesRecursively()

void v8::internal::Scope::AllocateModulesRecursively ( Scope * host_scope )

protected

Definition at line 1382 of file scopes.cc.

                                                         {
   if (already_resolved()) return;
   if (is_module_scope()) {
     DCHECK(interface_->IsFrozen());
     DCHECK(module_var_ == NULL);
     module_var_ =
         host_scope->NewInternal(ast_value_factory_->dot_module_string());
     ++host_scope->num_modules_;
   }
  
   for (int i = 0; i < inner_scopes_.length(); i++) {
     Scope* inner_scope = inner_scopes_.at(i);
     inner_scope->AllocateModulesRecursively(host_scope);
   }
 }

References AllocateModulesRecursively(), already_resolved(), ast_value_factory_, DCHECK, inner_scopes_, interface_, is_module_scope(), v8::internal::Interface::IsFrozen(), module_var_, NewInternal(), NULL, and num_modules_.

Referenced by AllocateModulesRecursively(), and AllocateVariables().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AllocateNonParameterLocal()

void v8::internal::Scope::AllocateNonParameterLocal ( Variable * var )

protected

Definition at line 1299 of file scopes.cc.

                                                    {
   DCHECK(var->scope() == this);
   DCHECK(!var->IsVariable(isolate_->factory()->dot_result_string()) ||
          !var->IsStackLocal());
   if (var->IsUnallocated() && MustAllocate(var)) {
     if (MustAllocateInContext(var)) {
       AllocateHeapSlot(var);
     } else {
       AllocateStackSlot(var);
     }
   }
 }

References AllocateHeapSlot(), AllocateStackSlot(), DCHECK, v8::internal::Isolate::factory(), isolate_, v8::internal::Variable::IsStackLocal(), v8::internal::Variable::IsUnallocated(), v8::internal::Variable::IsVariable(), MustAllocate(), MustAllocateInContext(), and v8::internal::Variable::scope().

Referenced by AllocateNonParameterLocals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AllocateNonParameterLocals()

void v8::internal::Scope::AllocateNonParameterLocals ( )

protected

Definition at line 1313 of file scopes.cc.

                                        {
   // All variables that have no rewrite yet are non-parameter locals.
   for (int i = 0; i < temps_.length(); i++) {
     AllocateNonParameterLocal(temps_[i]);
   }
  
   for (int i = 0; i < internals_.length(); i++) {
     AllocateNonParameterLocal(internals_[i]);
   }
  
   ZoneList<VarAndOrder> vars(variables_.occupancy(), zone());
   for (VariableMap::Entry* p = variables_.Start();
        p != NULL;
        p = variables_.Next(p)) {
     Variable* var = reinterpret_cast<Variable*>(p->value);
     vars.Add(VarAndOrder(var, p->order), zone());
   }
   vars.Sort(VarAndOrder::Compare);
   int var_count = vars.length();
   for (int i = 0; i < var_count; i++) {
     AllocateNonParameterLocal(vars[i].var());
   }
  
   // 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_ != NULL) {
     AllocateNonParameterLocal(function_->proxy()->var());
   }
 }

References v8::internal::List< T, AllocationPolicy >::Add(), AllocateNonParameterLocal(), v8::internal::VarAndOrder::Compare(), function_, internals_, v8::internal::TemplateHashMapImpl< AllocationPolicy >::Next(), NULL, v8::internal::TemplateHashMapImpl< AllocationPolicy >::occupancy(), v8::internal::List< T, AllocationPolicy >::Sort(), v8::internal::TemplateHashMapImpl< AllocationPolicy >::Start(), temps_, variables_, and zone().

Referenced by AllocateVariablesRecursively().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AllocateParameterLocals()

void v8::internal::Scope::AllocateParameterLocals ( )

protected

Definition at line 1243 of file scopes.cc.

                                     {
   DCHECK(is_function_scope());
   Variable* arguments = LookupLocal(ast_value_factory_->arguments_string());
   DCHECK(arguments != NULL);  // functions have 'arguments' declared implicitly
  
   bool uses_sloppy_arguments = false;
  
   if (MustAllocate(arguments) && !HasArgumentsParameter()) {
     // 'arguments' is used. Unless there is also a parameter called
     // 'arguments', we must be conservative and allocate all parameters to
     // the context assuming they will be captured by the arguments object.
     // If we have a parameter named 'arguments', a (new) value is always
     // assigned to it via the function invocation. Then 'arguments' denotes
     // that specific parameter value and cannot be used to access the
     // parameters, which is why we don't need to allocate an arguments
     // object in that case.
  
     // We are using 'arguments'. Tell the code generator that is needs to
     // allocate the arguments object by setting 'arguments_'.
     arguments_ = arguments;
  
     // In strict mode 'arguments' does not alias formal parameters.
     // Therefore in strict mode we allocate parameters as if 'arguments'
     // were not used.
     uses_sloppy_arguments = strict_mode() == SLOPPY;
   }
  
   // 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 = params_.length() - 1; i >= 0; --i) {
     Variable* var = params_[i];
     DCHECK(var->scope() == this);
     if (uses_sloppy_arguments || has_forced_context_allocation()) {
       // Force context allocation of the parameter.
       var->ForceContextAllocation();
     }
  
     if (MustAllocate(var)) {
       if (MustAllocateInContext(var)) {
         DCHECK(var->IsUnallocated() || var->IsContextSlot());
         if (var->IsUnallocated()) {
           AllocateHeapSlot(var);
         }
       } else {
         DCHECK(var->IsUnallocated() || var->IsParameter());
         if (var->IsUnallocated()) {
           var->AllocateTo(Variable::PARAMETER, i);
         }
       }
     }
   }
 }

References AllocateHeapSlot(), v8::internal::Variable::AllocateTo(), arguments(), arguments_, ast_value_factory_, DCHECK, v8::internal::Variable::ForceContextAllocation(), has_forced_context_allocation(), HasArgumentsParameter(), is_function_scope(), v8::internal::Variable::IsContextSlot(), v8::internal::Variable::IsParameter(), v8::internal::Variable::IsUnallocated(), LookupLocal(), MustAllocate(), MustAllocateInContext(), NULL, v8::internal::Variable::PARAMETER, params_, v8::internal::Variable::scope(), v8::internal::SLOPPY, and strict_mode().

Referenced by AllocateVariablesRecursively().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AllocateStackSlot()

void v8::internal::Scope::AllocateStackSlot ( Variable * var )

protected

Definition at line 1233 of file scopes.cc.

                                            {
   var->AllocateTo(Variable::LOCAL, num_stack_slots_++);
 }

References v8::internal::Variable::AllocateTo(), v8::internal::Variable::LOCAL, and num_stack_slots_.

Referenced by AllocateNonParameterLocal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AllocateVariables()

bool v8::internal::Scope::AllocateVariables	(	CompilationInfo *	info,
		AstNodeFactory< AstNullVisitor > *	factory
	)

protected

Definition at line 636 of file scopes.cc.

                                                                        {
   // 1) Propagate scope information.
   bool outer_scope_calls_sloppy_eval = false;
   if (outer_scope_ != NULL) {
     outer_scope_calls_sloppy_eval =
         outer_scope_->outer_scope_calls_sloppy_eval() |
         outer_scope_->calls_sloppy_eval();
   }
   PropagateScopeInfo(outer_scope_calls_sloppy_eval);
  
   // 2) Allocate module instances.
   if (FLAG_harmony_modules && (is_global_scope() || is_module_scope())) {
     DCHECK(num_modules_ == 0);
     AllocateModulesRecursively(this);
   }
  
   // 3) Resolve variables.
   if (!ResolveVariablesRecursively(info, factory)) return false;
  
   // 4) Allocate variables.
   AllocateVariablesRecursively();
  
   return true;
 }

References AllocateModulesRecursively(), AllocateVariablesRecursively(), calls_sloppy_eval(), DCHECK, is_global_scope(), is_module_scope(), NULL, num_modules_, outer_scope_, outer_scope_calls_sloppy_eval(), PropagateScopeInfo(), and ResolveVariablesRecursively().

Referenced by Analyze().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AllocateVariablesRecursively()

void v8::internal::Scope::AllocateVariablesRecursively ( )

protected

Definition at line 1346 of file scopes.cc.

                                          {
   // Allocate variables for inner scopes.
   for (int i = 0; i < inner_scopes_.length(); i++) {
     inner_scopes_[i]->AllocateVariablesRecursively();
   }
  
   // If scope is already resolved, we still need to allocate
   // variables in inner scopes which might not had been resolved yet.
   if (already_resolved()) return;
   // The number of slots required for variables.
   num_stack_slots_ = 0;
   num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
  
   // Allocate variables for this scope.
   // Parameters must be allocated first, if any.
   if (is_function_scope()) AllocateParameterLocals();
   AllocateNonParameterLocals();
  
   // 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.
   bool must_have_context = is_with_scope() || is_module_scope() ||
       (is_function_scope() && calls_eval());
  
   // 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 (num_heap_slots_ == Context::MIN_CONTEXT_SLOTS && !must_have_context) {
     num_heap_slots_ = 0;
   }
  
   // Allocation done.
   DCHECK(num_heap_slots_ == 0 || num_heap_slots_ >= Context::MIN_CONTEXT_SLOTS);
 }

References AllocateNonParameterLocals(), AllocateParameterLocals(), already_resolved(), calls_eval(), DCHECK, inner_scopes_, is_function_scope(), is_module_scope(), is_with_scope(), v8::internal::Context::MIN_CONTEXT_SLOTS, num_heap_slots_, and num_stack_slots_.

Referenced by AllocateVariables().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AllowsLazyCompilation()

bool v8::internal::Scope::AllowsLazyCompilation ( ) const

Definition at line 705 of file scopes.cc.

                                         {
   return !force_eager_compilation_ && HasLazyCompilableOuterContext();
 }

References force_eager_compilation_, and HasLazyCompilableOuterContext().

Referenced by v8::internal::CompilationInfo::ShouldSelfOptimize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AllowsLazyCompilationWithoutContext()

bool v8::internal::Scope::AllowsLazyCompilationWithoutContext ( ) const

Definition at line 710 of file scopes.cc.

                                                       {
   return !force_eager_compilation_ && HasTrivialOuterContext();
 }

References force_eager_compilation_, and HasTrivialOuterContext().

Here is the call graph for this function:

◆ already_resolved()

bool v8::internal::Scope::already_resolved ( )

inlineprotected

Definition at line 506 of file scopes.h.

506 { return already_resolved_; }

References already_resolved_.

Referenced by AllocateModulesRecursively(), AllocateVariablesRecursively(), Analyze(), DeclareLocal(), DeclareParameter(), ForceContextAllocation(), Initialize(), LookupRecursive(), NewInternal(), NewTemporary(), and NewUnresolved().

Here is the caller graph for this function:

◆ Analyze()

bool v8::internal::Scope::Analyze ( CompilationInfo * info )

static

Definition at line 260 of file scopes.cc.

                                          {
   DCHECK(info->function() != NULL);
   Scope* scope = info->function()->scope();
   Scope* top = scope;
  
   // Traverse the scope tree up to the first unresolved scope or the global
   // scope and start scope resolution and variable allocation from that scope.
   while (!top->is_global_scope() &&
          !top->outer_scope()->already_resolved()) {
     top = top->outer_scope();
   }
  
   // Allocate the variables.
   {
     AstNodeFactory<AstNullVisitor> ast_node_factory(
         info->zone(), info->ast_value_factory(), info->ast_node_id_gen());
     if (!top->AllocateVariables(info, &ast_node_factory)) return false;
   }
  
 #ifdef DEBUG
   if (info->isolate()->bootstrapper()->IsActive()
           ? FLAG_print_builtin_scopes
           : FLAG_print_scopes) {
     scope->Print();
   }
  
   if (FLAG_harmony_modules && FLAG_print_interfaces && top->is_global_scope()) {
     PrintF("global : ");
     top->interface()->Print();
   }
 #endif
  
   info->PrepareForCompilation(scope);
   return true;
 }

References AllocateVariables(), already_resolved(), v8::internal::CompilationInfo::ast_node_id_gen(), v8::internal::CompilationInfo::ast_value_factory(), v8::internal::Isolate::bootstrapper(), DCHECK, v8::internal::CompilationInfo::function(), interface(), is_global_scope(), v8::internal::CompilationInfo::isolate(), NULL, outer_scope(), v8::internal::CompilationInfo::PrepareForCompilation(), v8::internal::PrintF(), and v8::internal::CompilationInfo::zone().

Referenced by v8::internal::CompileOptimizedPrologue(), v8::internal::CompileUnoptimizedCode(), v8::internal::compiler::Parse(), v8::internal::ScopeIterator::ScopeIterator(), and v8::internal::HOptimizedGraphBuilder::TryInline().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ arguments()

Variable* v8::internal::Scope::arguments ( ) const

inline

Definition at line 324 of file scopes.h.

324 { return arguments_; }

References arguments_.

Referenced by AllocateParameterLocals(), v8::internal::compiler::AstGraphBuilder::CreateGraph(), v8::internal::HOptimizedGraphBuilder::SetUpScope(), and v8::internal::compiler::JSInliner::TryInlineCall().

Here is the caller graph for this function:

◆ asm_function()

bool v8::internal::Scope::asm_function ( ) const

inline

Definition at line 288 of file scopes.h.

288 { return asm_function_; }

v8::internal::Scope::asm_function_

bool asm_function_

Definition: scopes.h:474

References asm_function_.

Referenced by v8::internal::ScopeInfo::Create().

Here is the caller graph for this function:

◆ asm_module()

bool v8::internal::Scope::asm_module ( ) const

inline

Definition at line 287 of file scopes.h.

287 { return asm_module_; }

v8::internal::Scope::asm_module_

bool asm_module_

Definition: scopes.h:472

References asm_module_.

Referenced by v8::internal::ScopeInfo::Create().

Here is the caller graph for this function:

◆ calls_eval()

bool v8::internal::Scope::calls_eval ( ) const

inline

Definition at line 280 of file scopes.h.

280 { return scope_calls_eval_; }

v8::internal::Scope::scope_calls_eval_

bool scope_calls_eval_

Definition: scopes.h:470

References scope_calls_eval_.

Referenced by AllocateVariablesRecursively(), v8::internal::HOptimizedGraphBuilder::BuildGraph(), and v8::internal::ScopeInfo::Create().

Here is the caller graph for this function:

◆ calls_sloppy_eval()

bool v8::internal::Scope::calls_sloppy_eval ( )

inline

Definition at line 281 of file scopes.h.

                            {
     return scope_calls_eval_ && strict_mode_ == SLOPPY;
   }

References scope_calls_eval_, v8::internal::SLOPPY, and strict_mode_.

Referenced by AllocateVariables(), LookupRecursive(), and PropagateScopeInfo().

Here is the caller graph for this function:

◆ CheckConflictingVarDeclarations()

Declaration * v8::internal::Scope::CheckConflictingVarDeclarations ( )

Definition at line 545 of file scopes.cc.

                                                     {
   int length = decls_.length();
   for (int i = 0; i < length; i++) {
     Declaration* decl = decls_[i];
     if (decl->mode() != VAR) continue;
     const AstRawString* name = decl->proxy()->raw_name();
  
     // Iterate through all scopes until and including the declaration scope.
     Scope* previous = NULL;
     Scope* current = decl->scope();
     do {
       // There is a conflict if there exists a non-VAR binding.
       Variable* other_var = current->variables_.Lookup(name);
       if (other_var != NULL && other_var->mode() != VAR) {
         return decl;
       }
       previous = current;
       current = current->outer_scope_;
     } while (!previous->is_declaration_scope());
   }
   return NULL;
 }

References decls_, is_declaration_scope(), v8::internal::VariableMap::Lookup(), v8::internal::Declaration::mode(), v8::internal::Variable::mode(), name, NULL, outer_scope_, v8::internal::Declaration::proxy(), v8::internal::Declaration::scope(), v8::internal::VAR, and variables_.

Referenced by v8::internal::Parser::CheckConflictingVarDeclarations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CollectStackAndContextLocals()

void v8::internal::Scope::CollectStackAndContextLocals	(	ZoneList< Variable * > *	stack_locals,
		ZoneList< Variable * > *	context_locals
	)

Definition at line 584 of file scopes.cc.

                                                                               {
   DCHECK(stack_locals != NULL);
   DCHECK(context_locals != NULL);
  
   // Collect internals which are always allocated on the heap.
   for (int i = 0; i < internals_.length(); i++) {
     Variable* var = internals_[i];
     if (var->is_used()) {
       DCHECK(var->IsContextSlot());
       context_locals->Add(var, zone());
     }
   }
  
   // Collect temporaries which are always allocated on the stack, unless the
   // context as a whole has forced context allocation.
   for (int i = 0; i < temps_.length(); i++) {
     Variable* var = temps_[i];
     if (var->is_used()) {
       if (var->IsContextSlot()) {
         DCHECK(has_forced_context_allocation());
         context_locals->Add(var, zone());
       } else {
         DCHECK(var->IsStackLocal());
         stack_locals->Add(var, zone());
       }
     }
   }
  
   // Collect declared local variables.
   ZoneList<VarAndOrder> vars(variables_.occupancy(), zone());
   for (VariableMap::Entry* p = variables_.Start();
        p != NULL;
        p = variables_.Next(p)) {
     Variable* var = reinterpret_cast<Variable*>(p->value);
     if (var->is_used()) {
       vars.Add(VarAndOrder(var, p->order), zone());
     }
   }
   vars.Sort(VarAndOrder::Compare);
   int var_count = vars.length();
   for (int i = 0; i < var_count; i++) {
     Variable* var = vars[i].var();
     if (var->IsStackLocal()) {
       stack_locals->Add(var, zone());
     } else if (var->IsContextSlot()) {
       context_locals->Add(var, zone());
     }
   }
 }

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::VarAndOrder::Compare(), DCHECK, has_forced_context_allocation(), internals_, v8::internal::Variable::is_used(), v8::internal::Variable::IsContextSlot(), v8::internal::Variable::IsStackLocal(), v8::internal::TemplateHashMapImpl< AllocationPolicy >::Next(), NULL, v8::internal::TemplateHashMapImpl< AllocationPolicy >::occupancy(), v8::internal::List< T, AllocationPolicy >::Sort(), v8::internal::TemplateHashMapImpl< AllocationPolicy >::Start(), temps_, variables_, and zone().

Referenced by v8::internal::ScopeInfo::Create(), v8::internal::AstTyper::ObserveTypesAtOsrEntry(), and v8::internal::FunctionInfoListener::SerializeFunctionScope().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ contains_with()

bool v8::internal::Scope::contains_with ( ) const

inline

Definition at line 293 of file scopes.h.

293 { return scope_contains_with_; }

v8::internal::Scope::scope_contains_with_

bool scope_contains_with_

Definition: scopes.h:467

References scope_contains_with_.

Referenced by DeserializeScopeChain().

Here is the caller graph for this function:

◆ ContextChainLength()

int v8::internal::Scope::ContextChainLength ( Scope * scope )

Definition at line 715 of file scopes.cc.

                                           {
   int n = 0;
   for (Scope* s = this; s != scope; s = s->outer_scope_) {
     DCHECK(s != NULL);  // scope must be in the scope chain
     if (s->is_with_scope() || s->num_heap_slots() > 0) n++;
     // Catch and module scopes always have heap slots.
     DCHECK(!s->is_catch_scope() || s->num_heap_slots() > 0);
     DCHECK(!s->is_module_scope() || s->num_heap_slots() > 0);
   }
   return n;
 }

References DCHECK, NULL, and outer_scope_.

Referenced by v8::internal::HOptimizedGraphBuilder::BuildContextChainWalk(), v8::internal::compiler::AstGraphBuilder::BuildVariableAssignment(), and v8::internal::compiler::AstGraphBuilder::BuildVariableLoad().

Here is the caller graph for this function:

◆ ContextLocalCount()

int v8::internal::Scope::ContextLocalCount ( ) const

Definition at line 1405 of file scopes.cc.

                                    {
   if (num_heap_slots() == 0) return 0;
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS -
       (function_ != NULL && function_->proxy()->var()->IsContextSlot() ? 1 : 0);
 }

References function_, v8::internal::Context::MIN_CONTEXT_SLOTS, NULL, and num_heap_slots().

Referenced by v8::internal::ScopeInfo::Create(), v8::internal::AstTyper::ObserveTypesAtOsrEntry(), and v8::internal::FunctionInfoListener::SerializeFunctionScope().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ declarations()

ZoneList<Declaration*>* v8::internal::Scope::declarations ( )

inline

Definition at line 327 of file scopes.h.

327 { return &decls_; }

References decls_.

Referenced by v8::internal::FullCodeGenerator::AllocateModules(), v8::internal::HOptimizedGraphBuilder::BuildGraph(), v8::internal::compiler::AstGraphBuilder::CreateGraph(), v8::internal::AstTyper::Run(), and v8::internal::HOptimizedGraphBuilder::TryInline().

Here is the caller graph for this function:

◆ DeclarationScope()

Scope * v8::internal::Scope::DeclarationScope ( )

Definition at line 737 of file scopes.cc.

                                {
   Scope* scope = this;
   while (!scope->is_declaration_scope()) {
     scope = scope->outer_scope();
   }
   return scope;
 }

References is_declaration_scope(), and outer_scope().

Referenced by v8::internal::ParserTraits::CheckFunctionLiteralInsideTopLevelObjectLiteral(), v8::internal::ParserTraits::CheckPossibleEvalCall(), HasLazyCompilableOuterContext(), and v8::internal::Parser::ParseFunctionLiteral().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeclareDynamicGlobal()

Variable * v8::internal::Scope::DeclareDynamicGlobal ( const AstRawString * name )

Definition at line 476 of file scopes.cc.

                                                               {
   DCHECK(is_global_scope());
   return variables_.Declare(this,
                             name,
                             DYNAMIC_GLOBAL,
                             true,
                             Variable::NORMAL,
                             kCreatedInitialized);
 }

References DCHECK, v8::internal::VariableMap::Declare(), v8::internal::DYNAMIC_GLOBAL, is_global_scope(), v8::internal::kCreatedInitialized, name, v8::internal::Variable::NORMAL, and variables_.

Referenced by ResolveVariable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeclareFunctionVar()

void v8::internal::Scope::DeclareFunctionVar ( VariableDeclaration * declaration )

inline

Definition at line 120 of file scopes.h.

                                                             {
     DCHECK(is_function_scope());
     function_ = declaration;
   }

References DCHECK, function_, and is_function_scope().

Referenced by LookupFunctionVar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeclareLocal()

Variable * v8::internal::Scope::DeclareLocal	(	const AstRawString *	name,
		VariableMode	mode,
		InitializationFlag	init_flag,
		MaybeAssignedFlag	maybe_assigned_flag = `kNotAssigned`,
		Interface *	interface = `Interface::NewValue()`
	)

Definition at line 461 of file scopes.cc.

                                                     {
   DCHECK(!already_resolved());
   // This function handles VAR, LET, and CONST modes.  DYNAMIC variables are
   // introduces during variable allocation, INTERNAL variables are allocated
   // explicitly, and TEMPORARY variables are allocated via NewTemporary().
   DCHECK(IsDeclaredVariableMode(mode));
   ++num_var_or_const_;
   return variables_.Declare(this, name, mode, true, Variable::NORMAL, init_flag,
                             maybe_assigned_flag, interface);
 }

References already_resolved(), DCHECK, v8::internal::VariableMap::Declare(), interface(), v8::internal::IsDeclaredVariableMode(), mode(), name, v8::internal::Variable::NORMAL, num_var_or_const_, and variables_.

Referenced by v8::internal::Parser::Declare(), and v8::internal::Parser::ParseTryStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeclareParameter()

Variable * v8::internal::Scope::DeclareParameter	(	const AstRawString *	name,
		VariableMode	mode
	)

Definition at line 451 of file scopes.cc.

                                                                              {
   DCHECK(!already_resolved());
   DCHECK(is_function_scope());
   Variable* var = variables_.Declare(this, name, mode, true, Variable::NORMAL,
                                      kCreatedInitialized);
   params_.Add(var, zone());
   return var;
 }

References already_resolved(), DCHECK, v8::internal::VariableMap::Declare(), is_function_scope(), v8::internal::kCreatedInitialized, mode(), name, v8::internal::Variable::NORMAL, params_, variables_, and zone().

Referenced by v8::internal::CheckAndDeclareArrowParameter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeserializeScopeChain()

Scope * v8::internal::Scope::DeserializeScopeChain	(	Context *	context,
		Scope *	global_scope,
		Zone *	zone
	)

static

Definition at line 187 of file scopes.cc.

                                                 {
   // Reconstruct the outer scope chain from a closure's context chain.
   Scope* current_scope = NULL;
   Scope* innermost_scope = NULL;
   bool contains_with = false;
   while (!context->IsNativeContext()) {
     if (context->IsWithContext()) {
       Scope* with_scope = new(zone) Scope(current_scope,
                                           WITH_SCOPE,
                                           Handle<ScopeInfo>::null(),
                                           global_scope->ast_value_factory_,
                                           zone);
       current_scope = with_scope;
       // All the inner scopes are inside a with.
       contains_with = true;
       for (Scope* s = innermost_scope; s != NULL; s = s->outer_scope()) {
         s->scope_inside_with_ = true;
       }
     } else if (context->IsGlobalContext()) {
       ScopeInfo* scope_info = ScopeInfo::cast(context->extension());
       current_scope = new(zone) Scope(current_scope,
                                       GLOBAL_SCOPE,
                                       Handle<ScopeInfo>(scope_info),
                                       global_scope->ast_value_factory_,
                                       zone);
     } else if (context->IsModuleContext()) {
       ScopeInfo* scope_info = ScopeInfo::cast(context->module()->scope_info());
       current_scope = new(zone) Scope(current_scope,
                                       MODULE_SCOPE,
                                       Handle<ScopeInfo>(scope_info),
                                       global_scope->ast_value_factory_,
                                       zone);
     } else if (context->IsFunctionContext()) {
       ScopeInfo* scope_info = context->closure()->shared()->scope_info();
       current_scope = new(zone) Scope(current_scope,
                                       FUNCTION_SCOPE,
                                       Handle<ScopeInfo>(scope_info),
                                       global_scope->ast_value_factory_,
                                       zone);
       if (scope_info->IsAsmFunction()) current_scope->asm_function_ = true;
       if (scope_info->IsAsmModule()) current_scope->asm_module_ = true;
     } else if (context->IsBlockContext()) {
       ScopeInfo* scope_info = ScopeInfo::cast(context->extension());
       current_scope = new(zone) Scope(current_scope,
                                       BLOCK_SCOPE,
                                       Handle<ScopeInfo>(scope_info),
                                       global_scope->ast_value_factory_,
                                       zone);
     } else {
       DCHECK(context->IsCatchContext());
       String* name = String::cast(context->extension());
       current_scope = new (zone) Scope(
           current_scope,
           global_scope->ast_value_factory_->GetString(Handle<String>(name)),
           global_scope->ast_value_factory_, zone);
     }
     if (contains_with) current_scope->RecordWithStatement();
     if (innermost_scope == NULL) innermost_scope = current_scope;
  
     // Forget about a with when we move to a context for a different function.
     if (context->previous()->closure() != context->closure()) {
       contains_with = false;
     }
     context = context->previous();
   }
  
   global_scope->AddInnerScope(current_scope);
   global_scope->PropagateScopeInfo(false);
   return (innermost_scope == NULL) ? global_scope : innermost_scope;
 }

Referenced by v8::internal::Parser::DoParseProgram(), and v8::internal::Parser::ParseLazy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ end_position()

int v8::internal::Scope::end_position ( ) const

inline

Definition at line 246 of file scopes.h.

246 { return end_position_; }

v8::internal::Scope::end_position_

int end_position_

Definition: scopes.h:479

References end_position_.

Referenced by GetNestedScopeChain(), and v8::internal::Parser::ParseFunctionLiteral().

Here is the caller graph for this function:

◆ FinalizeBlockScope()

Scope * v8::internal::Scope::FinalizeBlockScope ( )

Definition at line 345 of file scopes.cc.

                                  {
   DCHECK(is_block_scope());
   DCHECK(internals_.is_empty());
   DCHECK(temps_.is_empty());
   DCHECK(params_.is_empty());
  
   if (num_var_or_const() > 0) return this;
  
   // Remove this scope from outer scope.
   for (int i = 0; i < outer_scope_->inner_scopes_.length(); i++) {
     if (outer_scope_->inner_scopes_[i] == this) {
       outer_scope_->inner_scopes_.Remove(i);
       break;
     }
   }
  
   // Reparent inner scopes.
   for (int i = 0; i < inner_scopes_.length(); i++) {
     outer_scope()->AddInnerScope(inner_scopes_[i]);
   }
  
   // Move unresolved variables
   for (int i = 0; i < unresolved_.length(); i++) {
     outer_scope()->unresolved_.Add(unresolved_[i], zone());
   }
  
   return NULL;
 }

References v8::internal::List< T, AllocationPolicy >::Add(), AddInnerScope(), DCHECK, inner_scopes_, internals_, is_block_scope(), NULL, num_var_or_const(), outer_scope(), outer_scope_, params_, temps_, unresolved_, and zone().

Referenced by v8::internal::Parser::ParseForStatement(), and v8::internal::Parser::ParseScopedBlock().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ForceContextAllocation()

void v8::internal::Scope::ForceContextAllocation ( )

inline

Definition at line 252 of file scopes.h.

                                 {
     DCHECK(!already_resolved());
     force_context_allocation_ = true;
   }

References already_resolved(), DCHECK, and force_context_allocation_.

Here is the call graph for this function:

◆ ForceEagerCompilation()

void v8::internal::Scope::ForceEagerCompilation ( )

inline

Definition at line 364 of file scopes.h.

364 { force_eager_compilation_ = true; }

References force_eager_compilation_.

Referenced by v8::internal::Parser::ParseNativeDeclaration().

Here is the caller graph for this function:

◆ function()

VariableDeclaration* v8::internal::Scope::function ( ) const

inline

Definition at line 309 of file scopes.h.

                                         {
     DCHECK(is_function_scope());
     return function_;
   }

References DCHECK, function_, and is_function_scope().

Referenced by v8::internal::HOptimizedGraphBuilder::BuildGraph(), v8::internal::ScopeInfo::Create(), v8::internal::compiler::AstGraphBuilder::CreateGraph(), and v8::internal::AstTyper::Run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetNestedScopeChain()

void v8::internal::Scope::GetNestedScopeChain	(	List< Handle< ScopeInfo > > *	chain,
		int	statement_position
	)

Definition at line 754 of file scopes.cc.

                   {
   if (!is_eval_scope()) chain->Add(Handle<ScopeInfo>(GetScopeInfo()));
  
   for (int i = 0; i < inner_scopes_.length(); i++) {
     Scope* scope = inner_scopes_[i];
     int beg_pos = scope->start_position();
     int end_pos = scope->end_position();
     DCHECK(beg_pos >= 0 && end_pos >= 0);
     if (beg_pos <= position && position < end_pos) {
       scope->GetNestedScopeChain(chain, position);
       return;
     }
   }
 }

References DCHECK, end_position(), GetNestedScopeChain(), GetScopeInfo(), inner_scopes_, is_eval_scope(), and start_position().

Referenced by GetNestedScopeChain(), and v8::internal::ScopeIterator::RetrieveScopeChain().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetScopeInfo()

Handle< ScopeInfo > v8::internal::Scope::GetScopeInfo ( )

Definition at line 746 of file scopes.cc.

                                       {
   if (scope_info_.is_null()) {
     scope_info_ = ScopeInfo::Create(this, zone());
   }
   return scope_info_;
 }

References v8::internal::ScopeInfo::Create(), scope_info_, and zone().

Referenced by v8::internal::FullCodeGenerator::AllocateModules(), and GetNestedScopeChain().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GlobalScope()

Scope * v8::internal::Scope::GlobalScope ( )

Definition at line 728 of file scopes.cc.

                           {
   Scope* scope = this;
   while (!scope->is_global_scope()) {
     scope = scope->outer_scope();
   }
   return scope;
 }

References is_global_scope(), and outer_scope().

Here is the call graph for this function:

◆ has_forced_context_allocation()

bool v8::internal::Scope::has_forced_context_allocation ( ) const

inline

Definition at line 256 of file scopes.h.

                                              {
     return force_context_allocation_;
   }

References force_context_allocation_.

Referenced by AllocateParameterLocals(), CollectStackAndContextLocals(), MustAllocateInContext(), and SetDefaults().

Here is the caller graph for this function:

◆ HasArgumentsParameter()

bool v8::internal::Scope::HasArgumentsParameter ( )

protected

Definition at line 1222 of file scopes.cc.

                                   {
   for (int i = 0; i < params_.length(); i++) {
     if (params_[i]->name().is_identical_to(
             isolate_->factory()->arguments_string())) {
       return true;
     }
   }
   return false;
 }

References v8::internal::Isolate::factory(), isolate_, name, and params_.

Referenced by AllocateParameterLocals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasIllegalRedeclaration()

bool v8::internal::Scope::HasIllegalRedeclaration ( ) const

inline

Definition at line 198 of file scopes.h.

198 { return illegal_redecl_ != NULL; }

v8::internal::Scope::illegal_redecl_

Expression * illegal_redecl_

Definition: scopes.h:460

References illegal_redecl_, and NULL.

Referenced by v8::internal::HOptimizedGraphBuilder::BuildGraph(), v8::internal::OptimizedCompileJob::CreateGraph(), Scope(), SetIllegalRedeclaration(), and VisitIllegalRedeclaration().

Here is the caller graph for this function:

◆ HasLazyCompilableOuterContext()

bool v8::internal::Scope::HasLazyCompilableOuterContext ( ) const

Definition at line 687 of file scopes.cc.

                                                 {
   Scope* outer = outer_scope_;
   if (outer == NULL) return true;
   // We have to prevent lazy compilation if this scope is inside a with scope
   // and all declaration scopes between them have empty contexts. Such
   // declaration scopes may become invisible during scope info deserialization.
   outer = outer->DeclarationScope();
   bool found_non_trivial_declarations = false;
   for (const Scope* scope = outer; scope != NULL; scope = scope->outer_scope_) {
     if (scope->is_with_scope() && !found_non_trivial_declarations) return false;
     if (scope->is_declaration_scope() && scope->num_heap_slots() > 0) {
       found_non_trivial_declarations = true;
     }
   }
   return true;
 }

References DeclarationScope(), NULL, and outer_scope_.

Referenced by AllowsLazyCompilation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasTrivialContext()

bool v8::internal::Scope::HasTrivialContext ( ) const

protected

Definition at line 663 of file scopes.cc.

                                     {
   // A function scope has a trivial context if it always is the global
   // context. We iteratively scan out the context chain to see if
   // there is anything that makes this scope non-trivial; otherwise we
   // return true.
   for (const Scope* scope = this; scope != NULL; scope = scope->outer_scope_) {
     if (scope->is_eval_scope()) return false;
     if (scope->scope_inside_with_) return false;
     if (scope->num_heap_slots_ > 0) return false;
   }
   return true;
 }

References NULL.

Referenced by HasTrivialOuterContext().

Here is the caller graph for this function:

◆ HasTrivialOuterContext()

bool v8::internal::Scope::HasTrivialOuterContext ( ) const

Definition at line 677 of file scopes.cc.

                                          {
   Scope* outer = outer_scope_;
   if (outer == NULL) return true;
   // Note that the outer context may be trivial in general, but the current
   // scope may be inside a 'with' statement in which case the outer context
   // for this scope is not trivial.
   return !scope_inside_with_ && outer->HasTrivialContext();
 }

References HasTrivialContext(), NULL, outer_scope_, and scope_inside_with_.

Referenced by AllowsLazyCompilationWithoutContext().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Initialize()

void v8::internal::Scope::Initialize ( )

Definition at line 297 of file scopes.cc.

                        {
   DCHECK(!already_resolved());
  
   // Add this scope as a new inner scope of the outer scope.
   if (outer_scope_ != NULL) {
     outer_scope_->inner_scopes_.Add(this, zone());
     scope_inside_with_ = outer_scope_->scope_inside_with_ || is_with_scope();
   } else {
     scope_inside_with_ = is_with_scope();
   }
  
   // Declare convenience variables.
   // Declare and allocate receiver (even for the global scope, and even
   // if naccesses_ == 0).
   // NOTE: When loading parameters in the global scope, we must take
   // care not to access them as properties of the global object, but
   // instead load them directly from the stack. Currently, the only
   // such parameter is 'this' which is passed on the stack when
   // invoking scripts
   if (is_declaration_scope()) {
     Variable* var =
         variables_.Declare(this,
                            ast_value_factory_->this_string(),
                            VAR,
                            false,
                            Variable::THIS,
                            kCreatedInitialized);
     var->AllocateTo(Variable::PARAMETER, -1);
     receiver_ = var;
   } else {
     DCHECK(outer_scope() != NULL);
     receiver_ = outer_scope()->receiver();
   }
  
   if (is_function_scope()) {
     // Declare 'arguments' variable which exists in all functions.
     // Note that it might never be accessed, in which case it won't be
     // allocated during variable allocation.
     variables_.Declare(this,
                        ast_value_factory_->arguments_string(),
                        VAR,
                        true,
                        Variable::ARGUMENTS,
                        kCreatedInitialized);
   }
 }

References v8::internal::Variable::AllocateTo(), already_resolved(), v8::internal::Variable::ARGUMENTS, ast_value_factory_, DCHECK, v8::internal::VariableMap::Declare(), inner_scopes_, is_declaration_scope(), is_function_scope(), is_with_scope(), v8::internal::kCreatedInitialized, NULL, outer_scope(), outer_scope_, v8::internal::Variable::PARAMETER, receiver(), receiver_, scope_inside_with_, v8::internal::Variable::THIS, v8::internal::VAR, variables_, and zone().

Referenced by v8::internal::Parser::DesugarLetBindingsInForStatement(), and v8::internal::Parser::NewScope().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inner_scopes()

ZoneList<Scope*>* v8::internal::Scope::inner_scopes ( )

inline

Definition at line 330 of file scopes.h.

330 { return &inner_scopes_; }

References inner_scopes_.

◆ inside_with()

bool v8::internal::Scope::inside_with ( ) const

inline

Definition at line 291 of file scopes.h.

291 { return scope_inside_with_; }

References scope_inside_with_.

◆ interface()

Interface* v8::internal::Scope::interface ( ) const

inline

Definition at line 336 of file scopes.h.

336 { return interface_; }

References interface_.

Referenced by v8::internal::FullCodeGenerator::AllocateModules(), Analyze(), DeclareLocal(), NewUnresolved(), and v8::internal::Parser::ParseModuleUrl().

Here is the caller graph for this function:

◆ is_block_scope()

bool v8::internal::Scope::is_block_scope ( ) const

inline

Definition at line 269 of file scopes.h.

269 { return scope_type_ == BLOCK_SCOPE; }

v8::internal::Scope::scope_type_

ScopeType scope_type_

Definition: scopes.h:427

References v8::internal::BLOCK_SCOPE, and scope_type_.

Referenced by v8::internal::Parser::Declare(), FinalizeBlockScope(), MustAllocate(), and MustAllocateInContext().

Here is the caller graph for this function:

◆ is_catch_scope()

bool v8::internal::Scope::is_catch_scope ( ) const

inline

Definition at line 268 of file scopes.h.

268 { return scope_type_ == CATCH_SCOPE; }

References v8::internal::CATCH_SCOPE, and scope_type_.

Referenced by MustAllocate(), and MustAllocateInContext().

Here is the caller graph for this function:

◆ is_declaration_scope()

bool v8::internal::Scope::is_declaration_scope ( ) const

inline

Definition at line 271 of file scopes.h.

                                     {
     return is_eval_scope() || is_function_scope() ||
         is_module_scope() || is_global_scope();
   }

References is_eval_scope(), is_function_scope(), is_global_scope(), and is_module_scope().

Referenced by CheckConflictingVarDeclarations(), DeclarationScope(), and Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_eval_scope()

bool v8::internal::Scope::is_eval_scope ( ) const

inline

Definition at line 264 of file scopes.h.

264 { return scope_type_ == EVAL_SCOPE; }

v8::internal::EVAL_SCOPE

@ EVAL_SCOPE

Definition: globals.h:646

References v8::internal::EVAL_SCOPE, and scope_type_.

Referenced by v8::internal::Parser::Declare(), GetNestedScopeChain(), is_declaration_scope(), is_strict_eval_scope(), v8::internal::Parser::ParseReturnStatement(), and v8::internal::Rewriter::Rewrite().

Here is the caller graph for this function:

◆ is_function_scope()

bool v8::internal::Scope::is_function_scope ( ) const

inline

Definition at line 265 of file scopes.h.

265 { return scope_type_ == FUNCTION_SCOPE; }

References v8::internal::FUNCTION_SCOPE, and scope_type_.

Referenced by AllocateParameterLocals(), AllocateVariablesRecursively(), v8::internal::HOptimizedGraphBuilder::BuildGraph(), v8::internal::ScopeInfo::Create(), v8::internal::compiler::AstGraphBuilder::CreateGraph(), v8::internal::Parser::Declare(), DeclareFunctionVar(), DeclareParameter(), function(), Initialize(), is_declaration_scope(), LookupRecursive(), parameter(), v8::internal::AstTyper::Run(), and SetDefaults().

Here is the caller graph for this function:

◆ is_global_scope()

bool v8::internal::Scope::is_global_scope ( ) const

inline

Definition at line 267 of file scopes.h.

267 { return scope_type_ == GLOBAL_SCOPE; }

References v8::internal::GLOBAL_SCOPE, and scope_type_.

Referenced by v8::internal::FullCodeGenerator::AllocateModules(), AllocateVariables(), Analyze(), v8::internal::ParserTraits::CheckFunctionLiteralInsideTopLevelObjectLiteral(), v8::internal::Parser::Declare(), DeclareDynamicGlobal(), GlobalScope(), is_declaration_scope(), v8::internal::Variable::IsGlobalObjectProperty(), LookupRecursive(), MustAllocate(), MustAllocateInContext(), v8::internal::Parser::ParseReturnStatement(), v8::internal::Parser::ParseVariableDeclarations(), RecordEvalCall(), ResolveVariable(), ResolveVariablesRecursively(), v8::internal::Rewriter::Rewrite(), and v8::internal::FullCodeGenerator::VisitDeclarations().

Here is the caller graph for this function:

◆ is_module_scope()

bool v8::internal::Scope::is_module_scope ( ) const

inline

Definition at line 266 of file scopes.h.

266 { return scope_type_ == MODULE_SCOPE; }

References v8::internal::MODULE_SCOPE, and scope_type_.

Referenced by AllocateModulesRecursively(), AllocateVariables(), AllocateVariablesRecursively(), v8::internal::Parser::Declare(), is_declaration_scope(), MustAllocate(), and MustAllocateInContext().

Here is the caller graph for this function:

◆ is_strict_eval_scope()

bool v8::internal::Scope::is_strict_eval_scope ( ) const

inline

Definition at line 275 of file scopes.h.

                                     {
     return is_eval_scope() && strict_mode_ == STRICT;
   }

References is_eval_scope(), v8::internal::STRICT, and strict_mode_.

Referenced by v8::internal::Parser::Declare().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_with_scope()

bool v8::internal::Scope::is_with_scope ( ) const

inline

Definition at line 270 of file scopes.h.

270 { return scope_type_ == WITH_SCOPE; }

References scope_type_, and v8::internal::WITH_SCOPE.

Referenced by AllocateVariablesRecursively(), Initialize(), and LookupRecursive().

Here is the caller graph for this function:

◆ IsDeclared()

bool v8::internal::Scope::IsDeclared ( const AstRawString * name )

inline

Definition at line 399 of file scopes.h.

                                             {
     // During formal parameter list parsing the scope only contains
     // two variables inserted at initialization: "this" and "arguments".
     // "this" is an invalid parameter name and "arguments" is invalid parameter
     // name in strict mode. Therefore looking up with the map which includes
     // "this" and "arguments" in addition to all formal parameters is safe.
     return variables_.Lookup(name) != NULL;
   }

References v8::internal::VariableMap::Lookup(), name, NULL, and variables_.

Referenced by v8::internal::CheckAndDeclareArrowParameter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lookup()

Variable * v8::internal::Scope::Lookup ( const AstRawString * name )

Definition at line 440 of file scopes.cc.

                                                 {
   for (Scope* scope = this;
        scope != NULL;
        scope = scope->outer_scope()) {
     Variable* var = scope->LookupLocal(name);
     if (var != NULL) return var;
   }
   return NULL;
 }

References name, and NULL.

Referenced by v8::internal::Parser::Declare().

Here is the caller graph for this function:

◆ LookupFunctionVar()

Variable * v8::internal::Scope::LookupFunctionVar	(	const AstRawString *	name,
		AstNodeFactory< AstNullVisitor > *	factory
	)

Definition at line 416 of file scopes.cc.

                                                                             {
   if (function_ != NULL && function_->proxy()->raw_name() == name) {
     return function_->proxy()->var();
   } else if (!scope_info_.is_null()) {
     // If we are backed by a scope info, try to lookup the variable there.
     VariableMode mode;
     int index = scope_info_->FunctionContextSlotIndex(*(name->string()), &mode);
     if (index < 0) return NULL;
     Variable* var = new(zone()) Variable(
         this, name, mode, true /* is valid LHS */,
         Variable::NORMAL, kCreatedInitialized);
     VariableProxy* proxy = factory->NewVariableProxy(var);
     VariableDeclaration* declaration = factory->NewVariableDeclaration(
         proxy, mode, this, RelocInfo::kNoPosition);
     DeclareFunctionVar(declaration);
     var->AllocateTo(Variable::CONTEXT, index);
     return var;
   } else {
     return NULL;
   }
 }

References v8::internal::Variable::AllocateTo(), v8::internal::Variable::CONTEXT, DeclareFunctionVar(), function_, v8::internal::kCreatedInitialized, v8::internal::RelocInfo::kNoPosition, mode(), name, v8::internal::Variable::NORMAL, NULL, scope_info_, and zone().

Referenced by LookupRecursive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LookupLocal()

Variable * v8::internal::Scope::LookupLocal ( const AstRawString * name )

Definition at line 375 of file scopes.cc.

                                                      {
   Variable* result = variables_.Lookup(name);
   if (result != NULL || scope_info_.is_null()) {
     return result;
   }
   // 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.
   Handle<String> name_handle = name->string();
   // If we have a serialized scope info, we might find the variable there.
   // There should be no local slot with the given name.
   DCHECK(scope_info_->StackSlotIndex(*name_handle) < 0);
  
   // Check context slot lookup.
   VariableMode mode;
   Variable::Location location = Variable::CONTEXT;
   InitializationFlag init_flag;
   MaybeAssignedFlag maybe_assigned_flag;
   int index = ScopeInfo::ContextSlotIndex(scope_info_, name_handle, &mode,
                                           &init_flag, &maybe_assigned_flag);
   if (index < 0) {
     // Check parameters.
     index = scope_info_->ParameterIndex(*name_handle);
     if (index < 0) return NULL;
  
     mode = DYNAMIC;
     location = Variable::LOOKUP;
     init_flag = kCreatedInitialized;
     // Be conservative and flag parameters as maybe assigned. Better information
     // would require ScopeInfo to serialize the maybe_assigned bit also for
     // parameters.
     maybe_assigned_flag = kMaybeAssigned;
   }
  
   Variable* var = variables_.Declare(this, name, mode, true, Variable::NORMAL,
                                      init_flag, maybe_assigned_flag);
   var->AllocateTo(location, index);
   return var;
 }

References v8::internal::Variable::AllocateTo(), v8::internal::Variable::CONTEXT, v8::internal::ScopeInfo::ContextSlotIndex(), DCHECK, v8::internal::VariableMap::Declare(), v8::internal::DYNAMIC, v8::internal::kCreatedInitialized, v8::internal::kMaybeAssigned, v8::internal::VariableMap::Lookup(), v8::internal::Variable::LOOKUP, mode(), name, v8::internal::Variable::NORMAL, NULL, scope_info_, and variables_.

Referenced by AllocateParameterLocals(), v8::internal::ModuleInfo::Create(), v8::internal::Parser::Declare(), LookupRecursive(), and v8::internal::Parser::ParseModuleLiteral().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LookupRecursive()

Variable * v8::internal::Scope::LookupRecursive	(	VariableProxy *	proxy,
		BindingKind *	binding_kind,
		AstNodeFactory< AstNullVisitor > *	factory
	)

protected

Definition at line 963 of file scopes.cc.

                                                                           {
   DCHECK(binding_kind != NULL);
   if (already_resolved() && is_with_scope()) {
     // Short-cut: if the scope is deserialized from a scope info, variable
     // allocation is already fixed.  We can simply return with dynamic lookup.
     *binding_kind = DYNAMIC_LOOKUP;
     return NULL;
   }
  
   // Try to find the variable in this scope.
   Variable* var = LookupLocal(proxy->raw_name());
  
   // 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.)
   if (var != NULL) {
     *binding_kind = BOUND;
     return var;
   }
  
   // We did not find a variable locally. Check against the function variable,
   // if any. We can do this for all scopes, since the function variable is
   // only present - if at all - for function scopes.
   *binding_kind = UNBOUND;
   var = LookupFunctionVar(proxy->raw_name(), factory);
   if (var != NULL) {
     *binding_kind = BOUND;
   } else if (outer_scope_ != NULL) {
     var = outer_scope_->LookupRecursive(proxy, binding_kind, factory);
     if (*binding_kind == BOUND && (is_function_scope() || is_with_scope())) {
       var->ForceContextAllocation();
     }
   } else {
     DCHECK(is_global_scope());
   }
  
   if (is_with_scope()) {
     DCHECK(!already_resolved());
     // 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 != NULL && proxy->is_assigned()) var->set_maybe_assigned();
     *binding_kind = DYNAMIC_LOOKUP;
     return NULL;
   } else if (calls_sloppy_eval()) {
     // 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.
     if (*binding_kind == BOUND) {
       *binding_kind = BOUND_EVAL_SHADOWED;
     } else if (*binding_kind == UNBOUND) {
       *binding_kind = UNBOUND_EVAL_SHADOWED;
     }
   }
   return var;
 }

References already_resolved(), BOUND, BOUND_EVAL_SHADOWED, calls_sloppy_eval(), DCHECK, DYNAMIC_LOOKUP, v8::internal::Variable::ForceContextAllocation(), is_function_scope(), is_global_scope(), is_with_scope(), LookupFunctionVar(), LookupLocal(), LookupRecursive(), NULL, outer_scope_, v8::internal::Variable::set_maybe_assigned(), UNBOUND, and UNBOUND_EVAL_SHADOWED.

Referenced by LookupRecursive(), and ResolveVariable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ module_var()

Variable* v8::internal::Scope::module_var ( ) const

inline

Definition at line 361 of file scopes.h.

361 { return module_var_; }

References module_var_.

Referenced by v8::internal::FullCodeGenerator::AllocateModules().

Here is the caller graph for this function:

◆ MustAllocate()

bool v8::internal::Scope::MustAllocate ( Variable * var )

protected

Definition at line 1179 of file scopes.cc.

                                       {
   // 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->is_this() || !var->raw_name()->IsEmpty()) &&
       (var->has_forced_context_allocation() ||
        scope_calls_eval_ ||
        inner_scope_calls_eval_ ||
        scope_contains_with_ ||
        is_catch_scope() ||
        is_block_scope() ||
        is_module_scope() ||
        is_global_scope())) {
     var->set_is_used();
     if (scope_calls_eval_ || inner_scope_calls_eval_) var->set_maybe_assigned();
   }
   // Global variables do not need to be allocated.
   return !var->IsGlobalObjectProperty() && var->is_used();
 }

References v8::internal::Variable::has_forced_context_allocation(), inner_scope_calls_eval_, is_block_scope(), is_catch_scope(), is_global_scope(), is_module_scope(), v8::internal::Variable::is_this(), v8::internal::Variable::is_used(), v8::internal::AstString::IsEmpty(), v8::internal::Variable::IsGlobalObjectProperty(), v8::internal::Variable::raw_name(), scope_calls_eval_, scope_contains_with_, v8::internal::Variable::set_is_used(), and v8::internal::Variable::set_maybe_assigned().

Referenced by AllocateNonParameterLocal(), and AllocateParameterLocals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MustAllocateInContext()

bool v8::internal::Scope::MustAllocateInContext ( Variable * var )

protected

Definition at line 1200 of file scopes.cc.

                                                {
   // 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.
   //
   // Exceptions: If the scope as a whole has forced context allocation, all
   // variables will have context allocation, even temporaries.  Otherwise
   // temporary variables are always stack-allocated.  Catch-bound variables are
   // always context-allocated.
   if (has_forced_context_allocation()) return true;
   if (var->mode() == TEMPORARY) return false;
   if (var->mode() == INTERNAL) return true;
   if (is_catch_scope() || is_block_scope() || is_module_scope()) return true;
   if (is_global_scope() && IsLexicalVariableMode(var->mode())) return true;
   return var->has_forced_context_allocation() ||
       scope_calls_eval_ ||
       inner_scope_calls_eval_ ||
       scope_contains_with_;
 }

References has_forced_context_allocation(), v8::internal::Variable::has_forced_context_allocation(), inner_scope_calls_eval_, v8::internal::INTERNAL, is_block_scope(), is_catch_scope(), is_global_scope(), is_module_scope(), v8::internal::IsLexicalVariableMode(), v8::internal::Variable::mode(), scope_calls_eval_, scope_contains_with_, and v8::internal::TEMPORARY.

Referenced by AllocateNonParameterLocal(), and AllocateParameterLocals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NewInternal()

Variable * v8::internal::Scope::NewInternal ( const AstRawString * name )

Definition at line 499 of file scopes.cc.

                                                      {
   DCHECK(!already_resolved());
   Variable* var = new(zone()) Variable(this,
                                        name,
                                        INTERNAL,
                                        false,
                                        Variable::NORMAL,
                                        kCreatedInitialized);
   internals_.Add(var, zone());
   return var;
 }

References already_resolved(), DCHECK, v8::internal::INTERNAL, internals_, v8::internal::kCreatedInitialized, name, v8::internal::Variable::NORMAL, and zone().

Referenced by AllocateModulesRecursively().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NewTemporary()

Variable * v8::internal::Scope::NewTemporary ( const AstRawString * name )

Definition at line 512 of file scopes.cc.

                                                       {
   DCHECK(!already_resolved());
   Variable* var = new(zone()) Variable(this,
                                        name,
                                        TEMPORARY,
                                        true,
                                        Variable::NORMAL,
                                        kCreatedInitialized);
   temps_.Add(var, zone());
   return var;
 }

References already_resolved(), DCHECK, v8::internal::kCreatedInitialized, name, v8::internal::Variable::NORMAL, v8::internal::TEMPORARY, temps_, and zone().

Referenced by v8::internal::Rewriter::Rewrite().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NewUnresolved()

template<class Visitor >

VariableProxy* v8::internal::Scope::NewUnresolved	(	AstNodeFactory< Visitor > *	factory,
		const AstRawString *	name,
		Interface *	interface = `Interface::NewValue()`,
		int	position = `RelocInfo::kNoPosition`
	)

inline

Definition at line 145 of file scopes.h.

                                                                     {
     // Note that we must not share the unresolved variables with
     // the same name because they may be removed selectively via
     // RemoveUnresolved().
     DCHECK(!already_resolved());
     VariableProxy* proxy =
         factory->NewVariableProxy(name, false, interface, position);
     unresolved_.Add(proxy, zone_);
     return proxy;
   }

References v8::internal::List< T, AllocationPolicy >::Add(), already_resolved(), DCHECK, interface(), name, unresolved_, and zone_.

Referenced by v8::internal::ParserTraits::ExpressionFromIdentifier(), v8::internal::Parser::NewUnresolved(), and v8::internal::Parser::ParseVariableDeclarations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NonLocal()

Variable * v8::internal::Scope::NonLocal	(	const AstRawString *	name,
		VariableMode	mode
	)

protected

Definition at line 942 of file scopes.cc.

                                                                      {
   if (dynamics_ == NULL) dynamics_ = new (zone()) DynamicScopePart(zone());
   VariableMap* map = dynamics_->GetMap(mode);
   Variable* var = map->Lookup(name);
   if (var == NULL) {
     // Declare a new non-local.
     InitializationFlag init_flag = (mode == VAR)
         ? kCreatedInitialized : kNeedsInitialization;
     var = map->Declare(NULL,
                        name,
                        mode,
                        true,
                        Variable::NORMAL,
                        init_flag);
     // Allocate it by giving it a dynamic lookup.
     var->AllocateTo(Variable::LOOKUP, -1);
   }
   return var;
 }

References v8::internal::Variable::AllocateTo(), dynamics_, v8::internal::DynamicScopePart::GetMap(), v8::internal::kCreatedInitialized, v8::internal::kNeedsInitialization, v8::internal::Variable::LOOKUP, map, mode(), name, v8::internal::Variable::NORMAL, NULL, v8::internal::VAR, and zone().

Referenced by ResolveVariable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ num_heap_slots()

int v8::internal::Scope::num_heap_slots ( ) const

inline

Definition at line 352 of file scopes.h.

352 { return num_heap_slots_; }

References num_heap_slots_.

Referenced by ContextLocalCount(), v8::internal::ScopeInfo::Create(), v8::internal::CompilationInfo::num_heap_slots(), and v8::internal::HOptimizedGraphBuilder::TryInline().

Here is the caller graph for this function:

◆ num_modules()

int v8::internal::Scope::num_modules ( ) const

inline

Definition at line 358 of file scopes.h.

358 { return num_modules_; }

References num_modules_.

Referenced by v8::internal::FullCodeGenerator::VisitDeclarations().

Here is the caller graph for this function:

◆ num_parameters()

int v8::internal::Scope::num_parameters ( ) const

inline

Definition at line 321 of file scopes.h.

321 { return params_.length(); }

References params_.

Referenced by v8::internal::compiler::AstGraphBuilder::BuildLocalFunctionContext(), v8::internal::ScopeInfo::Create(), v8::internal::OptimizedCompileJob::CreateGraph(), v8::internal::compiler::AstGraphBuilder::Environment::Environment(), v8::internal::LCodeGen::GeneratePrologue(), v8::internal::HOptimizedGraphBuilder::HandleCompoundAssignment(), v8::internal::CompilationInfo::num_parameters(), v8::internal::AstTyper::ObserveTypesAtOsrEntry(), and v8::internal::HOptimizedGraphBuilder::SetUpScope().

Here is the caller graph for this function:

◆ num_stack_slots()

int v8::internal::Scope::num_stack_slots ( ) const

inline

Definition at line 351 of file scopes.h.

351 { return num_stack_slots_; }

References num_stack_slots_.

Referenced by v8::internal::ScopeInfo::Create(), v8::internal::OptimizedCompileJob::CreateGraph(), and StackLocalCount().

Here is the caller graph for this function:

◆ num_var_or_const()

int v8::internal::Scope::num_var_or_const ( )

inline

Definition at line 348 of file scopes.h.

348 { return num_var_or_const_; }

References num_var_or_const_.

Referenced by FinalizeBlockScope().

Here is the caller graph for this function:

◆ outer_scope()

Scope* v8::internal::Scope::outer_scope ( ) const

inline

Definition at line 333 of file scopes.h.

333 { return outer_scope_; }

References outer_scope_.

Referenced by Analyze(), DeclarationScope(), FinalizeBlockScope(), GlobalScope(), Initialize(), Scope(), v8::internal::FunctionInfoListener::SerializeFunctionScope(), and SetDefaults().

Here is the caller graph for this function:

◆ outer_scope_calls_sloppy_eval()

bool v8::internal::Scope::outer_scope_calls_sloppy_eval ( ) const

inline

Definition at line 284 of file scopes.h.

                                              {
     return outer_scope_calls_sloppy_eval_;
   }

References outer_scope_calls_sloppy_eval_.

Referenced by AllocateVariables(), and PropagateScopeInfo().

Here is the caller graph for this function:

◆ parameter()

Variable* v8::internal::Scope::parameter ( int index ) const

inline

Definition at line 316 of file scopes.h.

                                        {
     DCHECK(is_function_scope());
     return params_[index];
   }

References DCHECK, is_function_scope(), and params_.

Referenced by v8::internal::compiler::AstGraphBuilder::BuildLocalFunctionContext(), v8::internal::ScopeInfo::Create(), v8::internal::LCodeGen::GeneratePrologue(), and v8::internal::AstTyper::ObserveTypesAtOsrEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PropagateScopeInfo()

void v8::internal::Scope::PropagateScopeInfo ( bool outer_scope_calls_sloppy_eval )

protected

Definition at line 1156 of file scopes.cc.

                                                                   {
   if (outer_scope_calls_sloppy_eval) {
     outer_scope_calls_sloppy_eval_ = true;
   }
  
   bool calls_sloppy_eval =
       this->calls_sloppy_eval() || outer_scope_calls_sloppy_eval_;
   for (int i = 0; i < inner_scopes_.length(); i++) {
     Scope* inner = inner_scopes_[i];
     inner->PropagateScopeInfo(calls_sloppy_eval);
     if (inner->scope_calls_eval_ || inner->inner_scope_calls_eval_) {
       inner_scope_calls_eval_ = true;
     }
     if (inner->force_eager_compilation_) {
       force_eager_compilation_ = true;
     }
     if (asm_module_ && inner->scope_type() == FUNCTION_SCOPE) {
       inner->asm_function_ = true;
     }
   }
 }

References asm_function_, asm_module_, calls_sloppy_eval(), force_eager_compilation_, v8::internal::FUNCTION_SCOPE, inner_scope_calls_eval_, inner_scopes_, outer_scope_calls_sloppy_eval(), outer_scope_calls_sloppy_eval_, PropagateScopeInfo(), scope_calls_eval_, and scope_type().

Referenced by AllocateVariables(), DeserializeScopeChain(), and PropagateScopeInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ receiver()

Variable* v8::internal::Scope::receiver ( )

inline

Definition at line 305 of file scopes.h.

305 { return receiver_; }

References receiver_.

Referenced by Initialize(), v8::internal::AstTyper::ObserveTypesAtOsrEntry(), and v8::internal::ParserTraits::ThisExpression().

Here is the caller graph for this function:

◆ RecordEvalCall()

void v8::internal::Scope::RecordEvalCall ( )

inline

Definition at line 212 of file scopes.h.

212 { if (!is_global_scope()) scope_calls_eval_ = true; }

References is_global_scope(), and scope_calls_eval_.

Referenced by v8::internal::ParserTraits::CheckPossibleEvalCall().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RecordWithStatement()

void v8::internal::Scope::RecordWithStatement ( )

inline

Definition at line 209 of file scopes.h.

209 { scope_contains_with_ = true; }

References scope_contains_with_.

Referenced by DeserializeScopeChain().

Here is the caller graph for this function:

◆ RemoveUnresolved()

void v8::internal::Scope::RemoveUnresolved ( VariableProxy * var )

Definition at line 487 of file scopes.cc.

                                                {
   // Most likely (always?) any variable we want to remove
   // was just added before, so we search backwards.
   for (int i = unresolved_.length(); i-- > 0;) {
     if (unresolved_[i] == var) {
       unresolved_.Remove(i);
       return;
     }
   }
 }

References v8::internal::List< T, AllocationPolicy >::Remove(), and unresolved_.

Here is the call graph for this function:

◆ ResolveVariable()

bool v8::internal::Scope::ResolveVariable	(	CompilationInfo *	info,
		VariableProxy *	proxy,
		AstNodeFactory< AstNullVisitor > *	factory
	)

protected

Definition at line 1027 of file scopes.cc.

                                                                      {
   DCHECK(info->global_scope()->is_global_scope());
  
   // If the proxy is already resolved there's nothing to do
   // (functions and consts may be resolved by the parser).
   if (proxy->var() != NULL) return true;
  
   // Otherwise, try to resolve the variable.
   BindingKind binding_kind;
   Variable* var = LookupRecursive(proxy, &binding_kind, factory);
   switch (binding_kind) {
     case BOUND:
       // We found a variable binding.
       break;
  
     case BOUND_EVAL_SHADOWED:
       // We either found a variable binding that might be shadowed by eval  or
       // gave up on it (e.g. by encountering a local with the same in the outer
       // scope which was not promoted to a context, this can happen if we use
       // debugger to evaluate arbitrary expressions at a break point).
       if (var->IsGlobalObjectProperty()) {
         var = NonLocal(proxy->raw_name(), DYNAMIC_GLOBAL);
       } else if (var->is_dynamic()) {
         var = NonLocal(proxy->raw_name(), DYNAMIC);
       } else {
         Variable* invalidated = var;
         var = NonLocal(proxy->raw_name(), DYNAMIC_LOCAL);
         var->set_local_if_not_shadowed(invalidated);
       }
       break;
  
     case UNBOUND:
       // No binding has been found. Declare a variable on the global object.
       var = info->global_scope()->DeclareDynamicGlobal(proxy->raw_name());
       break;
  
     case UNBOUND_EVAL_SHADOWED:
       // No binding has been found. But some scope makes a sloppy 'eval' call.
       var = NonLocal(proxy->raw_name(), DYNAMIC_GLOBAL);
       break;
  
     case DYNAMIC_LOOKUP:
       // The variable could not be resolved statically.
       var = NonLocal(proxy->raw_name(), DYNAMIC);
       break;
   }
  
   DCHECK(var != NULL);
   if (proxy->is_assigned()) var->set_maybe_assigned();
  
   if (FLAG_harmony_scoping && strict_mode() == STRICT &&
       var->is_const_mode() && proxy->is_assigned()) {
     // Assignment to const. Throw a syntax error.
     MessageLocation location(
         info->script(), proxy->position(), proxy->position());
     Isolate* isolate = info->isolate();
     Factory* factory = isolate->factory();
     Handle<JSArray> array = factory->NewJSArray(0);
     Handle<Object> error;
     MaybeHandle<Object> maybe_error =
         factory->NewSyntaxError("harmony_const_assign", array);
     if (maybe_error.ToHandle(&error)) isolate->Throw(*error, &location);
     return false;
   }
  
   if (FLAG_harmony_modules) {
     bool ok;
 #ifdef DEBUG
     if (FLAG_print_interface_details) {
       PrintF("# Resolve %.*s:\n", var->raw_name()->length(),
              var->raw_name()->raw_data());
     }
 #endif
     proxy->interface()->Unify(var->interface(), zone(), &ok);
     if (!ok) {
 #ifdef DEBUG
       if (FLAG_print_interfaces) {
         PrintF("SCOPES TYPE ERROR\n");
         PrintF("proxy: ");
         proxy->interface()->Print();
         PrintF("var: ");
         var->interface()->Print();
       }
 #endif
  
       // Inconsistent use of module. Throw a syntax error.
       // TODO(rossberg): generate more helpful error message.
       MessageLocation location(
           info->script(), proxy->position(), proxy->position());
       Isolate* isolate = info->isolate();
       Factory* factory = isolate->factory();
       Handle<JSArray> array = factory->NewJSArray(1);
       JSObject::SetElement(array, 0, var->name(), NONE, STRICT).Assert();
       Handle<Object> error;
       MaybeHandle<Object> maybe_error =
           factory->NewSyntaxError("module_type_error", array);
       if (maybe_error.ToHandle(&error)) isolate->Throw(*error, &location);
       return false;
     }
   }
  
   proxy->BindTo(var);
  
   return true;
 }

Referenced by ResolveVariablesRecursively().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ResolveVariablesRecursively()

bool v8::internal::Scope::ResolveVariablesRecursively	(	CompilationInfo *	info,
		AstNodeFactory< AstNullVisitor > *	factory
	)

protected

Definition at line 1136 of file scopes.cc.

                                              {
   DCHECK(info->global_scope()->is_global_scope());
  
   // Resolve unresolved variables for this scope.
   for (int i = 0; i < unresolved_.length(); i++) {
     if (!ResolveVariable(info, unresolved_[i], factory)) return false;
   }
  
   // Resolve unresolved variables for inner scopes.
   for (int i = 0; i < inner_scopes_.length(); i++) {
     if (!inner_scopes_[i]->ResolveVariablesRecursively(info, factory))
       return false;
   }
  
   return true;
 }

References DCHECK, v8::internal::CompilationInfo::global_scope(), inner_scopes_, is_global_scope(), ResolveVariable(), and unresolved_.

Referenced by AllocateVariables().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scope_type()

ScopeType v8::internal::Scope::scope_type ( ) const

inline

Definition at line 299 of file scopes.h.

299 { return scope_type_; }

References scope_type_.

Referenced by v8::internal::ScopeInfo::Create(), PropagateScopeInfo(), Scope(), and SetDefaults().

Here is the caller graph for this function:

◆ set_end_position()

void v8::internal::Scope::set_end_position ( int statement_pos )

inline

Definition at line 247 of file scopes.h.

                                            {
     end_position_ = statement_pos;
   }

References end_position_.

Referenced by v8::internal::Parser::DesugarLetBindingsInForStatement(), v8::internal::Parser::ParseForStatement(), v8::internal::Parser::ParseModuleLiteral(), v8::internal::Parser::ParseOnBackground(), v8::internal::Parser::ParseProgram(), v8::internal::Parser::ParseScopedBlock(), v8::internal::Parser::ParseSourceElements(), v8::internal::Parser::ParseTryStatement(), and v8::internal::Parser::ParseWithStatement().

Here is the caller graph for this function:

◆ set_start_position()

void v8::internal::Scope::set_start_position ( int statement_pos )

inline

Definition at line 243 of file scopes.h.

                                              {
     start_position_ = statement_pos;
   }

References start_position_.

Referenced by v8::internal::Parser::ParseForStatement(), v8::internal::Parser::ParseFunctionLiteral(), v8::internal::Parser::ParseModuleLiteral(), v8::internal::Parser::ParseScopedBlock(), v8::internal::Parser::ParseSourceElements(), v8::internal::Parser::ParseTryStatement(), and v8::internal::Parser::ParseWithStatement().

Here is the caller graph for this function:

◆ SetAsmModule()

void v8::internal::Scope::SetAsmModule ( )

inline

Definition at line 218 of file scopes.h.

218 { asm_module_ = true; }

References asm_module_.

◆ SetDefaults()

void v8::internal::Scope::SetDefaults	(	ScopeType	type,
		Scope *	outer_scope,
		Handle< ScopeInfo >	scope_info
	)

private

Definition at line 149 of file scopes.cc.

                                                       {
   outer_scope_ = outer_scope;
   scope_type_ = scope_type;
   scope_name_ = ast_value_factory_->empty_string();
   dynamics_ = NULL;
   receiver_ = NULL;
   function_ = NULL;
   arguments_ = NULL;
   illegal_redecl_ = NULL;
   scope_inside_with_ = false;
   scope_contains_with_ = false;
   scope_calls_eval_ = false;
   asm_module_ = false;
   asm_function_ = outer_scope != NULL && outer_scope->asm_module_;
   // Inherit the strict mode from the parent scope.
   strict_mode_ = outer_scope != NULL ? outer_scope->strict_mode_ : SLOPPY;
   outer_scope_calls_sloppy_eval_ = false;
   inner_scope_calls_eval_ = false;
   force_eager_compilation_ = false;
   force_context_allocation_ = (outer_scope != NULL && !is_function_scope())
       ? outer_scope->has_forced_context_allocation() : false;
   num_var_or_const_ = 0;
   num_stack_slots_ = 0;
   num_heap_slots_ = 0;
   num_modules_ = 0;
   module_var_ = NULL,
   scope_info_ = scope_info;
   start_position_ = RelocInfo::kNoPosition;
   end_position_ = RelocInfo::kNoPosition;
   if (!scope_info.is_null()) {
     scope_calls_eval_ = scope_info->CallsEval();
     strict_mode_ = scope_info->strict_mode();
   }
 }

References arguments_, asm_function_, asm_module_, ast_value_factory_, dynamics_, end_position_, force_context_allocation_, force_eager_compilation_, function_, has_forced_context_allocation(), illegal_redecl_, inner_scope_calls_eval_, is_function_scope(), v8::internal::Handle< T >::is_null(), v8::internal::RelocInfo::kNoPosition, module_var_, NULL, num_heap_slots_, num_modules_, num_stack_slots_, num_var_or_const_, outer_scope(), outer_scope_, outer_scope_calls_sloppy_eval_, receiver_, scope_calls_eval_, scope_contains_with_, scope_info_, scope_inside_with_, scope_name_, scope_type(), scope_type_, v8::internal::SLOPPY, start_position_, and strict_mode_.

Referenced by Scope().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetIllegalRedeclaration()

void v8::internal::Scope::SetIllegalRedeclaration ( Expression * expression )

Definition at line 530 of file scopes.cc.

                                                           {
   // Record only the first illegal redeclaration.
   if (!HasIllegalRedeclaration()) {
     illegal_redecl_ = expression;
   }
   DCHECK(HasIllegalRedeclaration());
 }

References DCHECK, HasIllegalRedeclaration(), and illegal_redecl_.

Referenced by v8::internal::Parser::Declare().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetScopeName()

void v8::internal::Scope::SetScopeName ( const AstRawString * scope_name )

inline

Definition at line 87 of file scopes.h.

                                                     {
     scope_name_ = scope_name;
   }

References scope_name_.

◆ SetStrictMode()

void v8::internal::Scope::SetStrictMode ( StrictMode strict_mode )

inline

Definition at line 215 of file scopes.h.

215 { strict_mode_ = strict_mode; }

References strict_mode(), and strict_mode_.

Referenced by v8::internal::Parser::ParseLazy(), and v8::internal::Parser::ParseModuleLiteral().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StackLocalCount()

int v8::internal::Scope::StackLocalCount ( ) const

Definition at line 1399 of file scopes.cc.

                                  {
   return num_stack_slots() -
       (function_ != NULL && function_->proxy()->var()->IsStackLocal() ? 1 : 0);
 }

References function_, NULL, and num_stack_slots().

Referenced by v8::internal::ScopeInfo::Create(), v8::internal::AstTyper::ObserveTypesAtOsrEntry(), and v8::internal::FunctionInfoListener::SerializeFunctionScope().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ start_position()

int v8::internal::Scope::start_position ( ) const

inline

Definition at line 242 of file scopes.h.

242 { return start_position_; }

References start_position_.

Referenced by GetNestedScopeChain(), and v8::internal::Parser::ParseFunctionLiteral().

Here is the caller graph for this function:

◆ strict_mode()

StrictMode v8::internal::Scope::strict_mode ( ) const

inline

Definition at line 302 of file scopes.h.

302 { return strict_mode_; }

References strict_mode_.

Referenced by AllocateParameterLocals(), v8::internal::ScopeInfo::Create(), v8::internal::Parser::Declare(), v8::internal::Parser::ParseFunctionLiteral(), v8::internal::Parser::ParseLazy(), v8::internal::Parser::ParseVariableDeclarations(), ResolveVariable(), and SetStrictMode().

Here is the caller graph for this function:

◆ VisitIllegalRedeclaration()

void v8::internal::Scope::VisitIllegalRedeclaration ( AstVisitor * visitor )

Definition at line 539 of file scopes.cc.

                                                          {
   DCHECK(HasIllegalRedeclaration());
   illegal_redecl_->Accept(visitor);
 }

References v8::internal::AstNode::Accept(), DCHECK, HasIllegalRedeclaration(), and illegal_redecl_.

Here is the call graph for this function:

◆ zone()

Zone* v8::internal::Scope::zone ( ) const

inline

Definition at line 98 of file scopes.h.

98 { return zone_; }

References zone_.

Referenced by AddDeclaration(), AllocateNonParameterLocals(), CollectStackAndContextLocals(), DeclareParameter(), DeserializeScopeChain(), FinalizeBlockScope(), GetScopeInfo(), Initialize(), LookupFunctionVar(), NewInternal(), NewTemporary(), NonLocal(), and ResolveVariable().

Here is the caller graph for this function:

Friends And Related Function Documentation

◆ ParserFactory

friend class ParserFactory

friend

Definition at line 418 of file scopes.h.

Member Data Documentation

◆ already_resolved_

bool v8::internal::Scope::already_resolved_

protected

Definition at line 489 of file scopes.h.

Referenced by already_resolved().

◆ arguments_

Variable* v8::internal::Scope::arguments_

protected

Definition at line 455 of file scopes.h.

Referenced by AllocateParameterLocals(), arguments(), and SetDefaults().

◆ asm_function_

bool v8::internal::Scope::asm_function_

protected

Definition at line 474 of file scopes.h.

Referenced by asm_function(), DeserializeScopeChain(), PropagateScopeInfo(), and SetDefaults().

◆ asm_module_

bool v8::internal::Scope::asm_module_

protected

Definition at line 472 of file scopes.h.

Referenced by asm_module(), DeserializeScopeChain(), PropagateScopeInfo(), SetAsmModule(), and SetDefaults().

◆ ast_value_factory_

AstValueFactory* v8::internal::Scope::ast_value_factory_

private

Definition at line 623 of file scopes.h.

Referenced by AllocateModulesRecursively(), AllocateParameterLocals(), DeserializeScopeChain(), Initialize(), and SetDefaults().

◆ decls_

ZoneList<Declaration*> v8::internal::Scope::decls_

protected

Definition at line 449 of file scopes.h.

Referenced by AddDeclaration(), CheckConflictingVarDeclarations(), and declarations().

◆ dynamics_

DynamicScopePart* v8::internal::Scope::dynamics_

protected

Definition at line 445 of file scopes.h.

Referenced by NonLocal(), and SetDefaults().

◆ end_position_

int v8::internal::Scope::end_position_

protected

Definition at line 479 of file scopes.h.

Referenced by end_position(), set_end_position(), and SetDefaults().

◆ force_context_allocation_

bool v8::internal::Scope::force_context_allocation_

protected

Definition at line 485 of file scopes.h.

Referenced by ForceContextAllocation(), has_forced_context_allocation(), and SetDefaults().

◆ force_eager_compilation_

bool v8::internal::Scope::force_eager_compilation_

protected

Definition at line 484 of file scopes.h.

Referenced by AllowsLazyCompilation(), AllowsLazyCompilationWithoutContext(), ForceEagerCompilation(), PropagateScopeInfo(), and SetDefaults().

◆ function_

VariableDeclaration* v8::internal::Scope::function_

protected

Definition at line 453 of file scopes.h.

Referenced by AllocateNonParameterLocals(), ContextLocalCount(), DeclareFunctionVar(), function(), LookupFunctionVar(), SetDefaults(), and StackLocalCount().

◆ illegal_redecl_

Expression* v8::internal::Scope::illegal_redecl_

protected

Definition at line 460 of file scopes.h.

Referenced by HasIllegalRedeclaration(), SetDefaults(), SetIllegalRedeclaration(), and VisitIllegalRedeclaration().

◆ inner_scope_calls_eval_

bool v8::internal::Scope::inner_scope_calls_eval_

protected

Definition at line 483 of file scopes.h.

Referenced by MustAllocate(), MustAllocateInContext(), PropagateScopeInfo(), and SetDefaults().

◆ inner_scopes_

ZoneList<Scope*> v8::internal::Scope::inner_scopes_

protected

Definition at line 424 of file scopes.h.

Referenced by AddInnerScope(), AllocateModulesRecursively(), AllocateVariablesRecursively(), FinalizeBlockScope(), GetNestedScopeChain(), Initialize(), inner_scopes(), PropagateScopeInfo(), and ResolveVariablesRecursively().

◆ interface_

Interface* v8::internal::Scope::interface_

protected

Definition at line 457 of file scopes.h.

Referenced by AllocateModulesRecursively(), and interface().

◆ internals_

ZoneList<Variable*> v8::internal::Scope::internals_

protected

Definition at line 439 of file scopes.h.

Referenced by AllocateNonParameterLocals(), CollectStackAndContextLocals(), FinalizeBlockScope(), and NewInternal().

◆ isolate_

Isolate* const v8::internal::Scope::isolate_

protected

Definition at line 420 of file scopes.h.

Referenced by AllocateNonParameterLocal(), and HasArgumentsParameter().

◆ module_var_

Variable* v8::internal::Scope::module_var_

protected

Definition at line 502 of file scopes.h.

Referenced by AllocateModulesRecursively(), module_var(), and SetDefaults().

◆ num_heap_slots_

int v8::internal::Scope::num_heap_slots_

protected

Definition at line 496 of file scopes.h.

Referenced by AllocateHeapSlot(), AllocateVariablesRecursively(), num_heap_slots(), Scope(), and SetDefaults().

◆ num_modules_

int v8::internal::Scope::num_modules_

protected

Definition at line 499 of file scopes.h.

Referenced by AllocateModulesRecursively(), AllocateVariables(), num_modules(), and SetDefaults().

◆ num_stack_slots_

int v8::internal::Scope::num_stack_slots_

protected

Definition at line 495 of file scopes.h.

Referenced by AllocateStackSlot(), AllocateVariablesRecursively(), num_stack_slots(), and SetDefaults().

◆ num_var_or_const_

int v8::internal::Scope::num_var_or_const_

protected

Definition at line 492 of file scopes.h.

Referenced by DeclareLocal(), num_var_or_const(), Scope(), and SetDefaults().

◆ outer_scope_

Scope* v8::internal::Scope::outer_scope_

protected

Definition at line 423 of file scopes.h.

Referenced by AddInnerScope(), AllocateVariables(), CheckConflictingVarDeclarations(), ContextChainLength(), FinalizeBlockScope(), HasLazyCompilableOuterContext(), HasTrivialOuterContext(), Initialize(), LookupRecursive(), outer_scope(), and SetDefaults().

◆ outer_scope_calls_sloppy_eval_

bool v8::internal::Scope::outer_scope_calls_sloppy_eval_

protected

Definition at line 482 of file scopes.h.

Referenced by outer_scope_calls_sloppy_eval(), PropagateScopeInfo(), and SetDefaults().

◆ params_

ZoneList<Variable*> v8::internal::Scope::params_

protected

Definition at line 443 of file scopes.h.

Referenced by AllocateParameterLocals(), DeclareParameter(), FinalizeBlockScope(), HasArgumentsParameter(), num_parameters(), and parameter().

◆ receiver_

Variable* v8::internal::Scope::receiver_

protected

Definition at line 451 of file scopes.h.

Referenced by Initialize(), receiver(), and SetDefaults().

◆ scope_calls_eval_

bool v8::internal::Scope::scope_calls_eval_

protected

Definition at line 470 of file scopes.h.

Referenced by calls_eval(), calls_sloppy_eval(), MustAllocate(), MustAllocateInContext(), PropagateScopeInfo(), RecordEvalCall(), and SetDefaults().

◆ scope_contains_with_

bool v8::internal::Scope::scope_contains_with_

protected

Definition at line 467 of file scopes.h.

Referenced by contains_with(), MustAllocate(), MustAllocateInContext(), RecordWithStatement(), and SetDefaults().

◆ scope_info_

Handle<ScopeInfo> v8::internal::Scope::scope_info_

protected

Definition at line 505 of file scopes.h.

Referenced by GetScopeInfo(), LookupFunctionVar(), LookupLocal(), Scope(), and SetDefaults().

◆ scope_inside_with_

bool v8::internal::Scope::scope_inside_with_

protected

Definition at line 465 of file scopes.h.

Referenced by HasTrivialOuterContext(), Initialize(), inside_with(), and SetDefaults().

◆ scope_name_

const AstRawString* v8::internal::Scope::scope_name_

protected

Definition at line 430 of file scopes.h.

Referenced by SetDefaults(), and SetScopeName().

◆ scope_type_

ScopeType v8::internal::Scope::scope_type_

protected

Definition at line 427 of file scopes.h.

Referenced by is_block_scope(), is_catch_scope(), is_eval_scope(), is_function_scope(), is_global_scope(), is_module_scope(), is_with_scope(), scope_type(), and SetDefaults().

◆ start_position_

int v8::internal::Scope::start_position_

protected

Definition at line 478 of file scopes.h.

Referenced by set_start_position(), SetDefaults(), and start_position().

◆ strict_mode_

StrictMode v8::internal::Scope::strict_mode_

protected

Definition at line 476 of file scopes.h.

Referenced by calls_sloppy_eval(), is_strict_eval_scope(), SetDefaults(), SetStrictMode(), and strict_mode().

◆ temps_

ZoneList<Variable*> v8::internal::Scope::temps_

protected

Definition at line 441 of file scopes.h.

Referenced by AllocateNonParameterLocals(), CollectStackAndContextLocals(), FinalizeBlockScope(), and NewTemporary().

◆ unresolved_

ZoneList<VariableProxy*> v8::internal::Scope::unresolved_

protected

Definition at line 447 of file scopes.h.

Referenced by FinalizeBlockScope(), NewUnresolved(), RemoveUnresolved(), and ResolveVariablesRecursively().

◆ variables_

VariableMap v8::internal::Scope::variables_

protected

Definition at line 437 of file scopes.h.

Referenced by AllocateNonParameterLocals(), CheckConflictingVarDeclarations(), CollectStackAndContextLocals(), DeclareDynamicGlobal(), DeclareLocal(), DeclareParameter(), Initialize(), IsDeclared(), LookupLocal(), and Scope().

◆ zone_

Zone* v8::internal::Scope::zone_

private

Definition at line 624 of file scopes.h.

Referenced by AddInnerScope(), NewUnresolved(), and zone().

The documentation for this class was generated from the following files:

/mnt/V8SourceCode/src/scopes.h
/mnt/V8SourceCode/src/scopes.cc

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ BindingKind

Constructor & Destructor Documentation

◆ Scope() [1/3]

◆ Scope() [2/3]

◆ Scope() [3/3]

Member Function Documentation

◆ AddDeclaration()

◆ AddInnerScope()

◆ AllocateHeapSlot()

◆ AllocateModulesRecursively()

◆ AllocateNonParameterLocal()

◆ AllocateNonParameterLocals()

◆ AllocateParameterLocals()

◆ AllocateStackSlot()

◆ AllocateVariables()

◆ AllocateVariablesRecursively()

◆ AllowsLazyCompilation()

◆ AllowsLazyCompilationWithoutContext()

◆ already_resolved()

◆ Analyze()

◆ arguments()

◆ asm_function()

◆ asm_module()

◆ calls_eval()

◆ calls_sloppy_eval()

◆ CheckConflictingVarDeclarations()

◆ CollectStackAndContextLocals()

◆ contains_with()

◆ ContextChainLength()

◆ ContextLocalCount()

◆ declarations()

◆ DeclarationScope()

◆ DeclareDynamicGlobal()

◆ DeclareFunctionVar()

◆ DeclareLocal()

◆ DeclareParameter()

◆ DeserializeScopeChain()

◆ end_position()

◆ FinalizeBlockScope()

◆ ForceContextAllocation()

◆ ForceEagerCompilation()

◆ function()

◆ GetNestedScopeChain()

◆ GetScopeInfo()

◆ GlobalScope()

◆ has_forced_context_allocation()

◆ HasArgumentsParameter()

◆ HasIllegalRedeclaration()

◆ HasLazyCompilableOuterContext()

◆ HasTrivialContext()

◆ HasTrivialOuterContext()

◆ Initialize()

◆ inner_scopes()

◆ inside_with()

◆ interface()

◆ is_block_scope()

◆ is_catch_scope()

◆ is_declaration_scope()

◆ is_eval_scope()

◆ is_function_scope()

◆ is_global_scope()

◆ is_module_scope()

◆ is_strict_eval_scope()

◆ is_with_scope()

◆ IsDeclared()

◆ Lookup()

◆ LookupFunctionVar()

◆ LookupLocal()

◆ LookupRecursive()

◆ module_var()