dart::LocalScope Class Reference

#include <scopes.h>

Inheritance diagram for dart::LocalScope:

Public Member Functions
	LocalScope (LocalScope *parent, int function_level, int loop_level)
LocalScope *	parent () const
LocalScope *	child () const
LocalScope *	sibling () const
int	function_level () const
int	loop_level () const
bool	IsNestedWithin (LocalScope *scope) const
bool	HasContextLevel () const
int	context_level () const
void	set_context_level (int context_level)
TokenPosition	begin_token_pos () const
void	set_begin_token_pos (TokenPosition value)
TokenPosition	end_token_pos () const
void	set_end_token_pos (TokenPosition value)
const GrowableArray< LocalVariable * > &	context_variables () const
const ZoneGrowableArray< const Slot * > &	context_slots () const
int	num_context_variables () const
bool	AddVariable (LocalVariable *variable)
void	AddContextVariable (LocalVariable *var)
bool	InsertParameterAt (intptr_t pos, LocalVariable *parameter)
LocalVariable *	LocalLookupVariable (const String &name, intptr_t kernel_offset) const
LocalVariable *	LookupVariable (const String &name, intptr_t kernel_offset, bool test_only)
LocalVariable *	LookupVariableByName (const String &name)
void	CaptureVariable (LocalVariable *variable)
intptr_t	num_variables () const
LocalVariable *	VariableAt (intptr_t index) const
int	NumCapturedVariables () const
VariableIndex	AllocateVariables (const Function &function, VariableIndex first_parameter_index, int num_parameters, VariableIndex first_local_index, LocalScope *context_owner, bool *found_captured_variables)
LocalVarDescriptorsPtr	GetVarDescriptors (const Function &func, ZoneGrowableArray< intptr_t > *context_level_array)
ContextScopePtr	PreserveOuterScope (const Function &function, intptr_t current_context_level) const
void	CaptureLocalVariables (LocalScope *top_scope)
Public Member Functions inherited from dart::ZoneAllocated
	ZoneAllocated ()
void *	operator new (size_t size)
void *	operator new (size_t size, Zone *zone)
void	operator delete (void *pointer)

Static Public Member Functions
static LocalScope *	RestoreOuterScope (const ContextScope &context_scope)
static ContextScopePtr	CreateImplicitClosureScope (const Function &func)

Detailed Description

Definition at line 315 of file scopes.h.

Constructor & Destructor Documentation

LocalScope()

dart::LocalScope::LocalScope	(	LocalScope *	parent,
		int	function_level,
		int	loop_level
	)

Definition at line 24 of file scopes.cc.

    : parent_(parent),
      child_(nullptr),
      sibling_(nullptr),
      function_level_(function_level),
      loop_level_(loop_level),
      context_level_(LocalScope::kUninitializedContextLevel),
      begin_token_pos_(TokenPosition::kNoSource),
      end_token_pos_(TokenPosition::kNoSource),
      variables_(),
      context_variables_(),
      context_slots_(new(Thread::Current()->zone())
                         ZoneGrowableArray<const Slot*>()) {
  // Hook this node into the children of the parent, unless the parent has a
  // different function_level, since the local scope of a nested function can
  // be discarded after it has been parsed.
  if ((parent != nullptr) && (parent->function_level() == function_level)) {
    sibling_ = parent->child_;
    parent->child_ = this;
  }
}

Member Function Documentation

AddContextVariable()

void dart::LocalScope::AddContextVariable

(

LocalVariable *

var

)

Definition at line 126 of file scopes.cc.

                                                           {
  variable->set_index(VariableIndex(context_variables_.length()));
  context_variables_.Add(variable);
  context_slots_->Add(
      &Slot::GetContextVariableSlotFor(Thread::Current(), *variable));
}

AddVariable()

bool dart::LocalScope::AddVariable

(

LocalVariable *

variable

)

Definition at line 57 of file scopes.cc.

                                                    {
  ASSERT(variable != nullptr);
  if (LocalLookupVariable(variable->name(), variable->kernel_offset()) !=
      nullptr) {
    return false;
  }
  variables_.Add(variable);
  if (variable->owner() == nullptr) {
    // Variables must be added to their owner scope first. Subsequent calls
    // to 'add' treat the variable as an alias.
    variable->set_owner(this);
  }
  return true;
}

AllocateVariables()

VariableIndex dart::LocalScope::AllocateVariables	(	const Function &	function,
		VariableIndex	first_parameter_index,
		int	num_parameters,
		VariableIndex	first_local_index,
		LocalScope *	context_owner,
		bool *	found_captured_variables
	)

Definition at line 133 of file scopes.cc.

                                                                            {
  // We should not allocate variables of nested functions while compiling an
  // enclosing function.
  ASSERT(function_level() == 0);
  ASSERT(num_parameters >= 0);
  // Parameters must be listed first and must all appear in the top scope.
  ASSERT(num_parameters <= num_variables());
  int pos = 0;  // Current variable position.
  VariableIndex next_index =
      first_parameter_index;  // Current free frame index.
 
  LocalVariable* suspend_state_var = nullptr;
  for (intptr_t i = 0; i < num_variables(); i++) {
    LocalVariable* variable = VariableAt(i);
    if (variable->owner() == this &&
        variable->name().Equals(Symbols::SuspendStateVar())) {
      ASSERT(!variable->is_captured());
      suspend_state_var = variable;
    }
  }
 
  if (suspend_state_var != nullptr) {
    suspend_state_var->set_index(
        VariableIndex(SuspendState::kSuspendStateVarIndex));
    ASSERT(next_index.value() == SuspendState::kSuspendStateVarIndex - 1);
  }
 
  while (pos < num_parameters) {
    LocalVariable* parameter = VariableAt(pos);
    pos++;
    // Parsing formal parameter default values may add local variable aliases
    // to the local scope before the formal parameters are added. However,
    // the parameters get inserted in front of the aliases, therefore, no
    // aliases can be encountered among the first num_parameters variables.
    ASSERT(parameter->owner() == this);
    if (parameter->is_captured()) {
      // A captured parameter has a slot allocated in the frame and one in the
      // context, where it gets copied to. The parameter index reflects the
      // context allocation index.
      next_index = VariableIndex(next_index.value() - 1);
      AllocateContextVariable(parameter, &context_owner);
      *found_captured_variables = true;
    } else {
      parameter->set_index(next_index);
      next_index = VariableIndex(next_index.value() - 1);
    }
  }
  // No overlapping of parameters and locals.
  ASSERT(next_index.value() >= first_local_index.value());
  next_index = first_local_index;
  for (; pos < num_variables(); pos++) {
    LocalVariable* variable = VariableAt(pos);
    if (variable == suspend_state_var) {
      continue;
    }
 
    if (variable->owner() == this) {
      if (variable->is_captured()) {
        AllocateContextVariable(variable, &context_owner);
        *found_captured_variables = true;
      } else {
        variable->set_index(next_index);
        next_index = VariableIndex(next_index.value() - 1);
      }
    }
  }
  // Allocate variables of all children.
  VariableIndex min_index = next_index;
  LocalScope* child = this->child();
  while (child != nullptr) {
    // Ignored, since no parameters.
    const VariableIndex dummy_parameter_index(0);
 
    // No parameters in children scopes.
    const int num_parameters_in_child = 0;
    VariableIndex child_next_index = child->AllocateVariables(
        function, dummy_parameter_index, num_parameters_in_child, next_index,
        context_owner, found_captured_variables);
    if (child_next_index.value() < min_index.value()) {
      min_index = child_next_index;
    }
    child = child->sibling();
  }
  return min_index;
}

begin_token_pos()

TokenPosition dart::LocalScope::begin_token_pos ( ) const

inline

Definition at line 343 of file scopes.h.

{ return begin_token_pos_; }

CaptureLocalVariables()

void dart::LocalScope::CaptureLocalVariables

(

LocalScope *

top_scope

)

Definition at line 558 of file scopes.cc.

                                                            {
  ASSERT(top_scope->function_level() == function_level());
  LocalScope* scope = this;
  while (scope != top_scope->parent()) {
    for (intptr_t i = 0; i < scope->num_variables(); i++) {
      LocalVariable* variable = scope->VariableAt(i);
      if (variable->is_forced_stack() ||
          (variable->name().ptr() == Symbols::ExceptionVar().ptr()) ||
          (variable->name().ptr() == Symbols::SavedTryContextVar().ptr()) ||
          (variable->name().ptr() == Symbols::ArgDescVar().ptr()) ||
          (variable->name().ptr() ==
           Symbols::FunctionTypeArgumentsVar().ptr())) {
        // Don't capture those variables because the VM expects them to be on
        // the stack.
        continue;
      }
      scope->CaptureVariable(variable);
    }
    scope = scope->parent();
  }
}

CaptureVariable()

void dart::LocalScope::CaptureVariable

(

LocalVariable *

variable

)

Definition at line 383 of file scopes.cc.

                                                        {
  ASSERT(variable != nullptr);
 
  // The variable must exist in an enclosing scope, not necessarily in this one.
  variable->set_is_captured();
  const int variable_function_level = variable->owner()->function_level();
  LocalScope* scope = this;
  while (scope->function_level() != variable_function_level) {
    // Insert an alias of the variable in the top scope of each function
    // level so that the variable is found in the context.
    LocalScope* parent_scope = scope->parent();
    while ((parent_scope != nullptr) &&
           (parent_scope->function_level() == scope->function_level())) {
      scope = parent_scope;
      parent_scope = scope->parent();
    }
    // An alias may already have been added in this scope, and in that case,
    // in parent scopes as needed. If so, we are done.
    if (!scope->AddVariable(variable)) {
      return;
    }
    ASSERT(variable->owner() != scope);  // Item is an alias.
    scope = parent_scope;
  }
}

child()

LocalScope * dart::LocalScope::child ( ) const

inline

Definition at line 320 of file scopes.h.

{ return child_; }

context_level()

int dart::LocalScope::context_level ( ) const

inline

Definition at line 333 of file scopes.h.

                            {
    ASSERT(HasContextLevel());
    return context_level_;
  }

context_slots()

const ZoneGrowableArray< const Slot * > & dart::LocalScope::context_slots ( ) const

inline

Definition at line 355 of file scopes.h.

                                                              {
    return *context_slots_;
  }

context_variables()

const GrowableArray< LocalVariable * > & dart::LocalScope::context_variables ( ) const

inline

Definition at line 351 of file scopes.h.

                                                                 {
    return context_variables_;
  }

CreateImplicitClosureScope()

ContextScopePtr dart::LocalScope::CreateImplicitClosureScope ( const Function &  func )

static

Definition at line 580 of file scopes.cc.

                                                                           {
  const intptr_t kNumCapturedVars = 1;
 
  // Create a ContextScope with space for kNumCapturedVars descriptors.
  const ContextScope& context_scope =
      ContextScope::Handle(ContextScope::New(kNumCapturedVars, true));
 
  // Create a descriptor for 'this' variable.
  context_scope.SetTokenIndexAt(0, func.token_pos());
  context_scope.SetDeclarationTokenIndexAt(0, func.token_pos());
  context_scope.SetNameAt(0, Symbols::This());
  context_scope.ClearFlagsAt(0);
  context_scope.SetIsFinalAt(0, true);
  const AbstractType& type = AbstractType::Handle(func.ParameterTypeAt(0));
  context_scope.SetTypeAt(0, type);
  context_scope.SetCidAt(0, kIllegalCid);
  context_scope.SetContextIndexAt(0, 0);
  context_scope.SetContextLevelAt(0, 0);
  context_scope.SetKernelOffsetAt(0, LocalVariable::kNoKernelOffset);
  ASSERT(context_scope.num_variables() == kNumCapturedVars);  // Verify count.
  return context_scope.ptr();
}

end_token_pos()

TokenPosition dart::LocalScope::end_token_pos ( ) const

inline

Definition at line 346 of file scopes.h.

{ return end_token_pos_; }

function_level()

int dart::LocalScope::function_level ( ) const

inline

Definition at line 322 of file scopes.h.

{ return function_level_; }

GetVarDescriptors()

LocalVarDescriptorsPtr dart::LocalScope::GetVarDescriptors	(	const Function &	func,
		ZoneGrowableArray< intptr_t > *	context_level_array
	)

Definition at line 249 of file scopes.cc.

                                                      {
  LocalVarDescriptorsBuilder vars;
  vars.AddDeoptIdToContextLevelMappings(context_level_array);
 
  // First enter all variables from scopes of outer functions.
  const ContextScope& context_scope =
      ContextScope::Handle(func.context_scope());
  if (!context_scope.IsNull()) {
    ASSERT(func.HasParent());
    for (int i = 0; i < context_scope.num_variables(); i++) {
      if (context_scope.IsInvisibleAt(i)) {
        continue;
      }
      String& name = String::Handle(context_scope.NameAt(i));
      ASSERT(!LocalVariable::IsFilteredIdentifier(name));
 
      LocalVarDescriptorsBuilder::VarDesc desc;
      desc.name = &name;
      desc.info.set_kind(UntaggedLocalVarDescriptors::kContextVar);
      desc.info.scope_id = context_scope.ContextLevelAt(i);
      desc.info.declaration_pos = context_scope.DeclarationTokenIndexAt(i);
      desc.info.begin_pos = begin_token_pos();
      desc.info.end_pos = end_token_pos();
      ASSERT((desc.info.begin_pos.IsReal() != desc.info.end_pos.IsReal()) ||
             (desc.info.begin_pos <= desc.info.end_pos));
      desc.info.set_index(context_scope.ContextIndexAt(i));
      vars.Add(desc);
    }
  }
  // Now collect all variables from local scopes.
  int16_t scope_id = 0;
  CollectLocalVariables(&vars, &scope_id);
 
  return vars.Done();
}

HasContextLevel()

bool dart::LocalScope::HasContextLevel ( ) const

inline

Definition at line 330 of file scopes.h.

                               {
    return context_level_ != kUninitializedContextLevel;
  }

InsertParameterAt()

bool dart::LocalScope::InsertParameterAt	(	intptr_t	pos,
		LocalVariable *	parameter
	)

Definition at line 72 of file scopes.cc.

                                                                         {
  ASSERT(parameter != nullptr);
  if (LocalLookupVariable(parameter->name(), parameter->kernel_offset()) !=
      nullptr) {
    return false;
  }
  variables_.InsertAt(pos, parameter);
  // InsertParameterAt is not used to add aliases of parameters.
  ASSERT(parameter->owner() == nullptr);
  parameter->set_owner(this);
  return true;
}

IsNestedWithin()

bool dart::LocalScope::IsNestedWithin

(

LocalScope *

scope

)

const

Definition at line 46 of file scopes.cc.

                                                       {
  const LocalScope* current_scope = this;
  while (current_scope != nullptr) {
    if (current_scope == scope) {
      return true;
    }
    current_scope = current_scope->parent();
  }
  return false;
}

LocalLookupVariable()

LocalVariable * dart::LocalScope::LocalLookupVariable	(	const String &	name,
		intptr_t	kernel_offset
	)		const

Definition at line 336 of file scopes.cc.

                                                                             {
  ASSERT(name.IsSymbol());
  for (intptr_t i = 0; i < variables_.length(); i++) {
    LocalVariable* var = variables_[i];
    ASSERT(var->name().IsSymbol());
    if ((var->name().ptr() == name.ptr()) &&
        (var->kernel_offset() == kernel_offset)) {
      return var;
    }
  }
  return nullptr;
}

LookupVariable()

LocalVariable * dart::LocalScope::LookupVariable	(	const String &	name,
		intptr_t	kernel_offset,
		bool	test_only
	)

Definition at line 350 of file scopes.cc.

                                                          {
  LocalScope* current_scope = this;
  while (current_scope != nullptr) {
    LocalVariable* var =
        current_scope->LocalLookupVariable(name, kernel_offset);
    // If testing only, return the variable even if invisible.
    if ((var != nullptr) && (!var->is_invisible() || test_only)) {
      if (!test_only && (var->owner()->function_level() != function_level())) {
        CaptureVariable(var);
      }
      return var;
    }
    current_scope = current_scope->parent();
  }
  return nullptr;
}

LookupVariableByName()

LocalVariable * dart::LocalScope::LookupVariableByName

(

const String &

name

)

Definition at line 369 of file scopes.cc.

                                                                  {
  ASSERT(name.IsSymbol());
  for (LocalScope* scope = this; scope != nullptr; scope = scope->parent()) {
    for (intptr_t i = 0, n = scope->variables_.length(); i < n; ++i) {
      LocalVariable* var = scope->variables_[i];
      ASSERT(var->name().IsSymbol());
      if (var->name().ptr() == name.ptr()) {
        return var;
      }
    }
  }
  return nullptr;
}

loop_level()

int dart::LocalScope::loop_level ( ) const

inline

Definition at line 323 of file scopes.h.

{ return loop_level_; }

num_context_variables()

int dart::LocalScope::num_context_variables ( ) const

inline

Definition at line 361 of file scopes.h.

{ return context_variables().length(); }

num_variables()

intptr_t dart::LocalScope::num_variables ( ) const

inline

Definition at line 397 of file scopes.h.

{ return variables_.length(); }

NumCapturedVariables()

int dart::LocalScope::NumCapturedVariables

(

)

const

Definition at line 409 of file scopes.cc.

                                           {
  // It is not necessary to traverse parent scopes, since we are only interested
  // in the captured variables referenced in this scope. If this scope is the
  // top scope at function level 1 and it (or its children scopes) references a
  // captured variable declared in a parent scope at function level 0, it will
  // contain an alias for that variable.
 
  // Since code generation for nested functions is postponed until first
  // invocation, the function level of the closure scope can only be 1.
  ASSERT(function_level() == 1);
 
  int num_captured = 0;
  for (int i = 0; i < num_variables(); i++) {
    LocalVariable* variable = VariableAt(i);
    // Count the aliases of captured variables belonging to outer scopes.
    if (variable->owner()->function_level() != 1) {
      ASSERT(variable->is_captured());
      ASSERT(variable->owner()->function_level() == 0);
      num_captured++;
    }
  }
  return num_captured;
}

parent()

LocalScope * dart::LocalScope::parent ( ) const

inline

Definition at line 319 of file scopes.h.

{ return parent_; }

PreserveOuterScope()

ContextScopePtr dart::LocalScope::PreserveOuterScope	(	const Function &	function,
		intptr_t	current_context_level
	)		const

Definition at line 433 of file scopes.cc.

                                          {
  Zone* zone = Thread::Current()->zone();
  auto& library = Library::Handle(
      zone, function.IsNull()
                ? Library::null()
                : Class::Handle(zone, function.Owner()).library());
  // Since code generation for nested functions is postponed until first
  // invocation, the function level of the closure scope can only be 1.
  ASSERT(function_level() == 1);
 
  // Count the number of referenced captured variables.
  intptr_t num_captured_vars = NumCapturedVariables();
 
  // Create a ContextScope with space for num_captured_vars descriptors.
  const ContextScope& context_scope =
      ContextScope::Handle(ContextScope::New(num_captured_vars, false));
 
  LocalVariable* awaiter_link = nullptr;
 
  // Create a descriptor for each referenced captured variable of enclosing
  // functions to preserve its name and its context allocation information.
  int captured_idx = 0;
  for (int i = 0; i < num_variables(); i++) {
    LocalVariable* variable = VariableAt(i);
    // Preserve the aliases of captured variables belonging to outer scopes.
    if (variable->owner()->function_level() != 1) {
      context_scope.SetTokenIndexAt(captured_idx, variable->token_pos());
      context_scope.SetDeclarationTokenIndexAt(
          captured_idx, variable->declaration_token_pos());
      context_scope.SetNameAt(captured_idx, variable->name());
      context_scope.ClearFlagsAt(captured_idx);
      context_scope.SetIsFinalAt(captured_idx, variable->is_final());
      context_scope.SetIsLateAt(captured_idx, variable->is_late());
      if (variable->is_late()) {
        context_scope.SetLateInitOffsetAt(captured_idx,
                                          variable->late_init_offset());
      }
      CompileType* type = variable->inferred_type();
      context_scope.SetTypeAt(captured_idx, *type->ToAbstractType());
      context_scope.SetCidAt(captured_idx, type->ToNullableCid());
      context_scope.SetIsNullableAt(captured_idx, type->is_nullable());
      context_scope.SetIsInvisibleAt(captured_idx, variable->is_invisible());
      context_scope.SetContextIndexAt(captured_idx, variable->index().value());
      // Adjust the context level relative to the current context level,
      // since the context of the current scope will be at level 0 when
      // compiling the nested function.
      intptr_t adjusted_context_level =
          variable->owner()->context_level() - current_context_level;
      context_scope.SetContextLevelAt(captured_idx, adjusted_context_level);
      context_scope.SetKernelOffsetAt(captured_idx, variable->kernel_offset());
 
      // Handle async frame link.
      const bool is_awaiter_link = variable->ComputeIfIsAwaiterLink(library);
      context_scope.SetIsAwaiterLinkAt(captured_idx, is_awaiter_link);
      if (is_awaiter_link) {
        awaiter_link = variable;
      }
      captured_idx++;
    }
  }
  ASSERT(context_scope.num_variables() == captured_idx);  // Verify count.
 
  if (awaiter_link != nullptr) {
    const intptr_t depth =
        current_context_level - awaiter_link->owner()->context_level();
    const intptr_t index = awaiter_link->index().value();
    if (Utils::IsUint(8, depth) && Utils::IsUint(8, index)) {
      function.set_awaiter_link(
          {static_cast<uint8_t>(depth), static_cast<uint8_t>(index)});
    } else if (FLAG_precompiled_mode) {
      OS::PrintErr(
          "Warning: @pragma('vm:awaiter-link') marked variable %s is visible "
          "from the function %s but the link {%" Pd ", %" Pd
          "} can't be encoded\n",
          awaiter_link->name().ToCString(),
          function.IsNull() ? "<?>" : function.ToFullyQualifiedCString(), depth,
          index);
    }
  }
 
  return context_scope.ptr();
}

RestoreOuterScope()

LocalScope * dart::LocalScope::RestoreOuterScope ( const ContextScope &  context_scope )

static

Definition at line 518 of file scopes.cc.

                                                                           {
  // The function level of the outer scope is one less than the function level
  // of the current function, which is 0.
  LocalScope* outer_scope = new LocalScope(nullptr, -1, 0);
  // Add all variables as aliases to the outer scope.
  for (int i = 0; i < context_scope.num_variables(); i++) {
    const bool is_late = context_scope.IsLateAt(i);
    const auto& static_type = AbstractType::ZoneHandle(context_scope.TypeAt(i));
    CompileType* inferred_type =
        new CompileType(context_scope.IsNullableAt(i), is_late,
                        context_scope.CidAt(i), &static_type);
    LocalVariable* variable = new LocalVariable(
        context_scope.DeclarationTokenIndexAt(i), context_scope.TokenIndexAt(i),
        String::ZoneHandle(context_scope.NameAt(i)), static_type,
        context_scope.KernelOffsetAt(i), inferred_type);
    variable->set_is_awaiter_link(context_scope.IsAwaiterLinkAt(i));
    variable->set_is_captured();
    variable->set_index(VariableIndex(context_scope.ContextIndexAt(i)));
    if (context_scope.IsFinalAt(i)) {
      variable->set_is_final();
    }
    if (is_late) {
      variable->set_is_late();
      variable->set_late_init_offset(context_scope.LateInitOffsetAt(i));
    }
    if (context_scope.IsInvisibleAt(i)) {
      variable->set_invisible(true);
    }
    // Create a fake owner scope describing the index and context level of the
    // variable. Function level and loop level are unused (set to 0), since
    // context level has already been assigned.
    LocalScope* owner_scope = new LocalScope(nullptr, 0, 0);
    owner_scope->set_context_level(context_scope.ContextLevelAt(i));
    owner_scope->AddVariable(variable);
    outer_scope->AddVariable(variable);  // As alias.
    ASSERT(variable->owner() == owner_scope);
  }
  return outer_scope;
}

set_begin_token_pos()

void dart::LocalScope::set_begin_token_pos ( TokenPosition  value )

inline

Definition at line 344 of file scopes.h.

{ begin_token_pos_ = value; }

set_context_level()

void dart::LocalScope::set_context_level ( int  context_level )

inline

Definition at line 337 of file scopes.h.

                                            {
    ASSERT(!HasContextLevel());
    ASSERT(context_level != kUninitializedContextLevel);
    context_level_ = context_level;
  }

set_end_token_pos()

void dart::LocalScope::set_end_token_pos ( TokenPosition  value )

inline

Definition at line 347 of file scopes.h.

{ end_token_pos_ = value; }

sibling()

LocalScope * dart::LocalScope::sibling ( ) const

inline

Definition at line 321 of file scopes.h.

{ return sibling_; }

VariableAt()

LocalVariable * dart::LocalScope::VariableAt ( intptr_t  index ) const

inline

Definition at line 398 of file scopes.h.

                                                  {
    ASSERT((index >= 0) && (index < variables_.length()));
    return variables_[index];
  }

---

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

• third_party/dart-lang/sdk/runtime/vm/scopes.h
• third_party/dart-lang/sdk/runtime/vm/scopes.cc