dart::ParsedFunction Class Reference

#include <parser.h>

Inheritance diagram for dart::ParsedFunction:

Classes
struct	DynamicClosureCallVars

Public Member Functions
	ParsedFunction (Thread *thread, const Function &function)
const Function &	function () const
const Code &	code () const
LocalScope *	scope () const
void	set_scope (LocalScope *scope)
RegExpCompileData *	regexp_compile_data () const
void	SetRegExpCompileData (RegExpCompileData *regexp_compile_data)
LocalVariable *	function_type_arguments () const
void	set_function_type_arguments (LocalVariable *function_type_arguments)
LocalVariable *	parent_type_arguments () const
void	set_parent_type_arguments (LocalVariable *parent_type_arguments)
LocalVariable *	suspend_state_var () const
void	set_suspend_state_var (LocalVariable *suspend_state_var)
void	set_default_parameter_values (ZoneGrowableArray< const Instance * > *list)
const Instance &	DefaultParameterValueAt (intptr_t i) const
ZoneGrowableArray< const Instance * > *	default_parameter_values () const
LocalVariable *	current_context_var () const
bool	has_arg_desc_var () const
LocalVariable *	arg_desc_var () const
LocalVariable *	receiver_var () const
void	set_receiver_var (LocalVariable *value)
bool	has_receiver_var () const
void	set_receiver_used ()
bool	is_receiver_used () const
LocalVariable *	expression_temp_var () const
void	set_expression_temp_var (LocalVariable *value)
bool	has_expression_temp_var () const
LocalVariable *	entry_points_temp_var () const
void	set_entry_points_temp_var (LocalVariable *value)
bool	has_entry_points_temp_var () const
LocalVariable *	finally_return_temp_var () const
void	set_finally_return_temp_var (LocalVariable *value)
bool	has_finally_return_temp_var () const
void	EnsureFinallyReturnTemp (bool is_async)
LocalVariable *	EnsureExpressionTemp ()
LocalVariable *	EnsureEntryPointsTemp ()
const FieldSet *	guarded_fields () const
VariableIndex	first_parameter_index () const
int	num_stack_locals () const
void	AllocateVariables ()
void	AllocateIrregexpVariables (intptr_t num_stack_locals)
void	record_await ()
bool	have_seen_await () const
bool	is_forwarding_stub () const
const Function *	forwarding_stub_super_target () const
void	MarkForwardingStub (const Function *forwarding_target)
Thread *	thread () const
Isolate *	isolate () const
Zone *	zone () const
void	AddToGuardedFields (const Field *field) const
void	Bailout (const char *origin, const char *reason) const
kernel::ScopeBuildingResult *	EnsureKernelScopes ()
LocalVariable *	RawTypeArgumentsVariable () const
void	SetRawTypeArgumentsVariable (LocalVariable *raw_type_arguments_var)
void	SetRawParameters (ZoneGrowableArray< LocalVariable * > *raw_parameters)
LocalVariable *	RawParameterVariable (intptr_t i) const
LocalVariable *	ParameterVariable (intptr_t i) const
void	SetCovariantParameters (const BitVector *covariant_parameters)
void	SetGenericCovariantImplParameters (const BitVector *generic_covariant_impl_parameters)
bool	HasCovariantParametersInfo () const
bool	IsCovariantParameter (intptr_t i) const
bool	IsGenericCovariantImplParameter (intptr_t i) const
DynamicClosureCallVars *	dynamic_closure_call_vars () const
DynamicClosureCallVars *	EnsureDynamicClosureCallVars ()
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)

Friends
class	Parser

Detailed Description

Definition at line 69 of file parser.h.

Constructor & Destructor Documentation

ParsedFunction()

dart::ParsedFunction::ParsedFunction	(	Thread *	thread,
		const Function &	function
	)

Definition at line 47 of file parser.cc.

    : thread_(thread),
      function_(function),
      code_(Code::Handle(zone(), function.unoptimized_code())),
      scope_(nullptr),
      regexp_compile_data_(nullptr),
      function_type_arguments_(nullptr),
      parent_type_arguments_(nullptr),
      current_context_var_(nullptr),
      arg_desc_var_(nullptr),
      expression_temp_var_(nullptr),
      entry_points_temp_var_(nullptr),
      finally_return_temp_var_(nullptr),
      dynamic_closure_call_vars_(nullptr),
      guarded_fields_(),
      default_parameter_values_(nullptr),
      raw_type_arguments_var_(nullptr),
      first_parameter_index_(),
      num_stack_locals_(0),
      have_seen_await_expr_(false),
      kernel_scopes_(nullptr) {
  DEBUG_ASSERT(function.IsNotTemporaryScopedHandle());
  // Every function has a local variable for the current context.
  LocalVariable* temp = new (zone())
      LocalVariable(function.token_pos(), function.token_pos(),
                    Symbols::CurrentContextVar(), Object::dynamic_type());
  current_context_var_ = temp;
 
  if (function.PrologueNeedsArgumentsDescriptor()) {
    arg_desc_var_ = new (zone())
        LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                      Symbols::ArgDescVar(), Object::dynamic_type());
  }
 
  // The code generated by the prologue builder for loading optional arguments
  // requires the expression temporary variable.
  if (function.HasOptionalParameters()) {
    EnsureExpressionTemp();
  }
}

Member Function Documentation

AddToGuardedFields()

void dart::ParsedFunction::AddToGuardedFields

(

const Field *

field

)

const

Definition at line 88 of file parser.cc.

                                                                {
  if ((field->guarded_cid() == kDynamicCid) ||
      (field->guarded_cid() == kIllegalCid)) {
    return;
  }
 
  const Field** other = guarded_fields_.Lookup(field);
  if (other != nullptr) {
    ASSERT(field->Original() == (*other)->Original());
    // Abort background compilation early if the guarded state of this field
    // has changed during compilation. We will not be able to commit
    // the resulting code anyway.
    if (Compiler::IsBackgroundCompilation()) {
      if (!(*other)->IsConsistentWith(*field)) {
        Compiler::AbortBackgroundCompilation(
            DeoptId::kNone, "Field's guarded state changed during compilation");
      }
    }
    return;
  }
 
  // Note: the list of guarded fields must contain copies during optimizing
  // compilation because we will look at their guarded_cid when copying
  // the array of guarded fields from callee into the caller during
  // inlining.
  ASSERT(field->IsOriginal() ==
         !CompilerState::Current().should_clone_fields());
  guarded_fields_.Insert(&Field::ZoneHandle(Z, field->ptr()));
}

AllocateIrregexpVariables()

void dart::ParsedFunction::AllocateIrregexpVariables

(

intptr_t

num_stack_locals

)

Definition at line 295 of file parser.cc.

                                                                        {
  ASSERT(function().IsIrregexpFunction());
  ASSERT(function().NumOptionalParameters() == 0);
  const intptr_t num_params = function().num_fixed_parameters();
  ASSERT(num_params == RegExpMacroAssembler::kParamCount);
  // Compute start indices to parameters and locals, and the number of
  // parameters to copy.
  first_parameter_index_ = VariableIndex(num_params);
 
  // Frame indices are relative to the frame pointer and are decreasing.
  num_stack_locals_ = num_stack_locals;
}

AllocateVariables()

void dart::ParsedFunction::AllocateVariables

(

)

Definition at line 180 of file parser.cc.

                                       {
  ASSERT(!function().IsIrregexpFunction());
  LocalScope* scope = this->scope();
  const intptr_t num_fixed_params = function().num_fixed_parameters();
  const intptr_t num_opt_params = function().NumOptionalParameters();
  const intptr_t num_params = num_fixed_params + num_opt_params;
  const bool copy_parameters = function().MakesCopyOfParameters();
 
  // Before we start allocating indices to variables, we'll setup the
  // parameters array, which can be used to access the raw parameters (i.e. not
  // the potentially variables which are in the context)
 
  raw_parameters_ = new (Z) ZoneGrowableArray<LocalVariable*>(Z, num_params);
  for (intptr_t param = 0; param < num_params; ++param) {
    LocalVariable* variable = ParameterVariable(param);
    LocalVariable* raw_parameter = variable;
    if (variable->is_captured()) {
      String& tmp = String::ZoneHandle(Z);
      tmp = Symbols::FromConcat(T, Symbols::OriginalParam(), variable->name());
 
      RELEASE_ASSERT(scope->LocalLookupVariable(
                         tmp, variable->kernel_offset()) == nullptr);
      raw_parameter = new LocalVariable(
          variable->declaration_token_pos(), variable->token_pos(), tmp,
          variable->static_type(), variable->kernel_offset(),
          variable->inferred_type(), variable->inferred_arg_type(),
          variable->inferred_arg_value());
      raw_parameter->set_annotations_offset(variable->annotations_offset());
      if (variable->is_explicit_covariant_parameter()) {
        raw_parameter->set_is_explicit_covariant_parameter();
      }
      if (variable->needs_covariant_check_in_method()) {
        raw_parameter->set_needs_covariant_check_in_method();
      }
      raw_parameter->set_type_check_mode(variable->type_check_mode());
      if (copy_parameters) {
        bool ok = scope->AddVariable(raw_parameter);
        ASSERT(ok);
 
        // Currently our optimizer cannot prove liveness of variables properly
        // when a function has try/catch.  It therefore makes the conservative
        // estimate that all [LocalVariable]s in the frame are live and spills
        // them before call sites (in some shape or form).
        //
        // Since we are guaranteed to not need that, we tell the try/catch
        // sync moves mechanism not to care about this variable.
        //
        // Receiver (this variable) is an exception from this rule because
        // it is immutable and we don't reload captured it from the context but
        // instead use raw_parameter to access it. This means we must still
        // consider it when emitting the catch entry moves.
        const bool is_receiver_var =
            function().HasThisParameter() && receiver_var_ == variable;
        if (!is_receiver_var) {
          raw_parameter->set_is_captured_parameter(true);
        }
 
      } else {
        raw_parameter->set_index(
            VariableIndex(function().NumParameters() - param));
      }
    }
    raw_parameters_->Add(raw_parameter);
  }
  if (function_type_arguments_ != nullptr) {
    LocalVariable* raw_type_args_parameter = function_type_arguments_;
    if (function_type_arguments_->is_captured()) {
      String& tmp = String::ZoneHandle(Z);
      tmp = Symbols::FromConcat(T, Symbols::OriginalParam(),
                                function_type_arguments_->name());
 
      ASSERT(scope->LocalLookupVariable(
                 tmp, function_type_arguments_->kernel_offset()) == nullptr);
      raw_type_args_parameter =
          new LocalVariable(function_type_arguments_->declaration_token_pos(),
                            function_type_arguments_->token_pos(), tmp,
                            function_type_arguments_->static_type(),
                            function_type_arguments_->kernel_offset());
      bool ok = scope->AddVariable(raw_type_args_parameter);
      ASSERT(ok);
    }
    raw_type_arguments_var_ = raw_type_args_parameter;
  }
 
  // The copy parameters implementation will still write to local variables
  // which we assign indices as with the old CopyParams implementation.
  VariableIndex first_local_index;
  {
    // Compute start indices to parameters and locals, and the number of
    // parameters to copy.
    if (!copy_parameters) {
      ASSERT(suspend_state_var() == nullptr);
      first_parameter_index_ = VariableIndex(num_params);
      first_local_index = VariableIndex(0);
    } else {
      // :suspend_state variable is inserted at the fixed slot
      // before the copied parameters.
      const intptr_t reserved_var_slot_count =
          (suspend_state_var() != nullptr) ? 1 : 0;
      first_parameter_index_ = VariableIndex(-reserved_var_slot_count);
      first_local_index =
          VariableIndex(first_parameter_index_.value() - num_params);
    }
  }
 
  // Allocate parameters and local variables, either in the local frame or
  // in the context(s).
  bool found_captured_variables = false;
  VariableIndex next_free_index = scope->AllocateVariables(
      function(), first_parameter_index_, num_params, first_local_index,
      nullptr, &found_captured_variables);
 
  num_stack_locals_ = -next_free_index.value();
}

arg_desc_var()

LocalVariable * dart::ParsedFunction::arg_desc_var ( ) const

inline

Definition at line 131 of file parser.h.

{ return arg_desc_var_; }

Bailout()

void dart::ParsedFunction::Bailout	(	const char *	origin,
		const char *	reason
	)		const

Definition at line 118 of file parser.cc.

                                                                         {
  Report::MessageF(Report::kBailout, Script::Handle(function_.script()),
                   function_.token_pos(), Report::AtLocation,
                   "%s Bailout in %s: %s", origin,
                   String::Handle(function_.name()).ToCString(), reason);
  UNREACHABLE();
}

code()

const Code & dart::ParsedFunction::code ( ) const

inline

Definition at line 74 of file parser.h.

{ return code_; }

current_context_var()

LocalVariable * dart::ParsedFunction::current_context_var ( ) const

inline

Definition at line 128 of file parser.h.

{ return current_context_var_; }

default_parameter_values()

ZoneGrowableArray< const Instance * > * dart::ParsedFunction::default_parameter_values ( ) const

inline

Definition at line 124 of file parser.h.

                                                                       {
    return default_parameter_values_;
  }

DefaultParameterValueAt()

const Instance & dart::ParsedFunction::DefaultParameterValueAt ( intptr_t  i ) const

inline

Definition at line 119 of file parser.h.

                                                            {
    ASSERT(default_parameter_values_ != nullptr);
    return *default_parameter_values_->At(i);
  }

dynamic_closure_call_vars()

DynamicClosureCallVars * dart::ParsedFunction::dynamic_closure_call_vars ( ) const

inline

Definition at line 289 of file parser.h.

                                                            {
    return dynamic_closure_call_vars_;
  }

EnsureDynamicClosureCallVars()

ParsedFunction::DynamicClosureCallVars * dart::ParsedFunction::EnsureDynamicClosureCallVars

(

)

Definition at line 336 of file parser.cc.

                                             {
  ASSERT(function().IsDynamicClosureCallDispatcher(thread()));
  if (dynamic_closure_call_vars_ != nullptr) return dynamic_closure_call_vars_;
  const auto& saved_args_desc =
      Array::Handle(zone(), function().saved_args_desc());
  const ArgumentsDescriptor descriptor(saved_args_desc);
 
  dynamic_closure_call_vars_ =
      new (zone()) DynamicClosureCallVars(zone(), descriptor.NamedCount());
 
  auto const pos = function().token_pos();
  const auto& type_Dynamic = Object::dynamic_type();
  const auto& type_Function =
      Type::ZoneHandle(zone(), Type::DartFunctionType());
  const auto& type_Smi = Type::ZoneHandle(zone(), Type::SmiType());
#define INIT_FIELD(Name, TypeName, Symbol)                                     \
  dynamic_closure_call_vars_->Name = new (zone()) LocalVariable(               \
      pos, pos, Symbols::DynamicCall##Symbol##Var(), type_##TypeName);
  FOR_EACH_DYNAMIC_CLOSURE_CALL_VARIABLE(INIT_FIELD);
#undef INIT_FIELD
 
  for (intptr_t i = 0; i < descriptor.NamedCount(); i++) {
    auto const name = OS::SCreate(
        zone(), ":dyn_call_named_argument_%" Pd "_parameter_index", i);
    auto const var = new (zone()) LocalVariable(
        pos, pos, String::ZoneHandle(zone(), Symbols::New(thread(), name)),
        type_Smi);
    dynamic_closure_call_vars_->named_argument_parameter_indices.Add(var);
  }
 
  return dynamic_closure_call_vars_;
}

EnsureEntryPointsTemp()

LocalVariable * dart::ParsedFunction::EnsureEntryPointsTemp

(

)

Definition at line 146 of file parser.cc.

                                                     {
  if (!has_entry_points_temp_var()) {
    LocalVariable* temp = new (Z)
        LocalVariable(function_.token_pos(), function_.token_pos(),
                      Symbols::EntryPointsTemp(), Object::dynamic_type());
    ASSERT(temp != nullptr);
    set_entry_points_temp_var(temp);
  }
  ASSERT(has_entry_points_temp_var());
  return entry_points_temp_var();
}

EnsureExpressionTemp()

LocalVariable * dart::ParsedFunction::EnsureExpressionTemp

(

)

Definition at line 134 of file parser.cc.

                                                    {
  if (!has_expression_temp_var()) {
    LocalVariable* temp =
        new (Z) LocalVariable(function_.token_pos(), function_.token_pos(),
                              Symbols::ExprTemp(), Object::dynamic_type());
    ASSERT(temp != nullptr);
    set_expression_temp_var(temp);
  }
  ASSERT(has_expression_temp_var());
  return expression_temp_var();
}

EnsureFinallyReturnTemp()

void dart::ParsedFunction::EnsureFinallyReturnTemp

(

bool

is_async

)

Definition at line 158 of file parser.cc.

                                                          {
  if (!has_finally_return_temp_var()) {
    LocalVariable* temp =
        new (Z) LocalVariable(function_.token_pos(), function_.token_pos(),
                              Symbols::FinallyRetVal(), Object::dynamic_type());
    ASSERT(temp != nullptr);
    temp->set_is_final();
    if (is_async) {
      temp->set_is_captured();
    }
    set_finally_return_temp_var(temp);
  }
  ASSERT(has_finally_return_temp_var());
}

EnsureKernelScopes()

kernel::ScopeBuildingResult * dart::ParsedFunction::EnsureKernelScopes

(

)

Definition at line 126 of file parser.cc.

                                                              {
  if (kernel_scopes_ == nullptr) {
    kernel::ScopeBuilder builder(this);
    kernel_scopes_ = builder.BuildScopes();
  }
  return kernel_scopes_;
}

entry_points_temp_var()

LocalVariable * dart::ParsedFunction::entry_points_temp_var ( ) const

inline

Definition at line 163 of file parser.h.

                                               {
    ASSERT(has_entry_points_temp_var());
    return entry_points_temp_var_;
  }

expression_temp_var()

LocalVariable * dart::ParsedFunction::expression_temp_var ( ) const

inline

Definition at line 151 of file parser.h.

                                             {
    ASSERT(has_expression_temp_var());
    return expression_temp_var_;
  }

finally_return_temp_var()

LocalVariable * dart::ParsedFunction::finally_return_temp_var ( ) const

inline

Definition at line 175 of file parser.h.

                                                 {
    ASSERT(has_finally_return_temp_var());
    return finally_return_temp_var_;
  }

first_parameter_index()

VariableIndex dart::ParsedFunction::first_parameter_index ( ) const

inline

Definition at line 193 of file parser.h.

{ return first_parameter_index_; }

forwarding_stub_super_target()

const Function * dart::ParsedFunction::forwarding_stub_super_target ( ) const

inline

Definition at line 204 of file parser.h.

                                                       {
    return forwarding_stub_super_target_;
  }

function()

const Function & dart::ParsedFunction::function ( ) const

inline

Definition at line 73 of file parser.h.

{ return function_; }

function_type_arguments()

LocalVariable * dart::ParsedFunction::function_type_arguments ( ) const

inline

Definition at line 88 of file parser.h.

                                                 {
    return function_type_arguments_;
  }

guarded_fields()

const FieldSet * dart::ParsedFunction::guarded_fields ( ) const

inline

Definition at line 191 of file parser.h.

{ return &guarded_fields_; }

has_arg_desc_var()

bool dart::ParsedFunction::has_arg_desc_var ( ) const

inline

Definition at line 130 of file parser.h.

{ return arg_desc_var_ != nullptr; }

has_entry_points_temp_var()

bool dart::ParsedFunction::has_entry_points_temp_var ( ) const

inline

Definition at line 171 of file parser.h.

                                         {
    return entry_points_temp_var_ != nullptr;
  }

has_expression_temp_var()

bool dart::ParsedFunction::has_expression_temp_var ( ) const

inline

Definition at line 159 of file parser.h.

                                       {
    return expression_temp_var_ != nullptr;
  }

has_finally_return_temp_var()

bool dart::ParsedFunction::has_finally_return_temp_var ( ) const

inline

Definition at line 183 of file parser.h.

                                           {
    return finally_return_temp_var_ != nullptr;
  }

has_receiver_var()

bool dart::ParsedFunction::has_receiver_var ( ) const

inline

Definition at line 142 of file parser.h.

{ return receiver_var_ != nullptr; }

HasCovariantParametersInfo()

bool dart::ParsedFunction::HasCovariantParametersInfo ( ) const

inline

Definition at line 254 of file parser.h.

                                          {
    return covariant_parameters_ != nullptr;
  }

have_seen_await()

bool dart::ParsedFunction::have_seen_await ( ) const

inline

Definition at line 200 of file parser.h.

{ return have_seen_await_expr_; }

is_forwarding_stub()

bool dart::ParsedFunction::is_forwarding_stub ( ) const

inline

Definition at line 201 of file parser.h.

                                  {
    return forwarding_stub_super_target_ != nullptr;
  }

is_receiver_used()

bool dart::ParsedFunction::is_receiver_used ( ) const

inline

Definition at line 145 of file parser.h.

                                {
    ASSERT(kernel_scopes_ != nullptr);
    ASSERT(!receiver_used_ || receiver_var() != nullptr);
    return receiver_used_;
  }

IsCovariantParameter()

bool dart::ParsedFunction::IsCovariantParameter

(

intptr_t

i

)

const

Definition at line 323 of file parser.cc.

                                                          {
  ASSERT(covariant_parameters_ != nullptr);
  ASSERT((i >= 0) && (i < function_.NumParameters()));
  return covariant_parameters_->Contains(i);
}

IsGenericCovariantImplParameter()

bool dart::ParsedFunction::IsGenericCovariantImplParameter

(

intptr_t

i

)

const

Definition at line 329 of file parser.cc.

                                                                     {
  ASSERT(generic_covariant_impl_parameters_ != nullptr);
  ASSERT((i >= 0) && (i < function_.NumParameters()));
  return generic_covariant_impl_parameters_->Contains(i);
}

isolate()

Isolate * dart::ParsedFunction::isolate ( ) const

inline

Definition at line 212 of file parser.h.

{ return thread_->isolate(); }

MarkForwardingStub()

void dart::ParsedFunction::MarkForwardingStub ( const Function *  forwarding_target )

inline

Definition at line 207 of file parser.h.

                                                             {
    forwarding_stub_super_target_ = forwarding_target;
  }

num_stack_locals()

int dart::ParsedFunction::num_stack_locals ( ) const

inline

Definition at line 194 of file parser.h.

{ return num_stack_locals_; }

ParameterVariable()

LocalVariable * dart::ParsedFunction::ParameterVariable ( intptr_t  i ) const

inline

Definition at line 239 of file parser.h.

                                                     {
    ASSERT((i >= 0) && (i < function_.NumParameters()));
    ASSERT(scope() != nullptr);
    return scope()->VariableAt(i);
  }

parent_type_arguments()

LocalVariable * dart::ParsedFunction::parent_type_arguments ( ) const

inline

Definition at line 95 of file parser.h.

                                               {
    return parent_type_arguments_;
  }

RawParameterVariable()

LocalVariable * dart::ParsedFunction::RawParameterVariable ( intptr_t  i ) const

inline

Definition at line 235 of file parser.h.

                                                        {
    return raw_parameters_->At(i);
  }

RawTypeArgumentsVariable()

LocalVariable * dart::ParsedFunction::RawTypeArgumentsVariable ( ) const

inline

Definition at line 223 of file parser.h.

                                                  {
    return raw_type_arguments_var_;
  }

receiver_var()

LocalVariable * dart::ParsedFunction::receiver_var ( ) const

inline

Definition at line 133 of file parser.h.

                                      {
    ASSERT(receiver_var_ != nullptr);
    return receiver_var_;
  }

record_await()

void dart::ParsedFunction::record_await ( )

inline

Definition at line 199 of file parser.h.

{ have_seen_await_expr_ = true; }

regexp_compile_data()

RegExpCompileData * dart::ParsedFunction::regexp_compile_data ( ) const

inline

Definition at line 83 of file parser.h.

                                                 {
    return regexp_compile_data_;
  }

scope()

LocalScope * dart::ParsedFunction::scope ( ) const

inline

Definition at line 76 of file parser.h.

{ return scope_; }

set_default_parameter_values()

void dart::ParsedFunction::set_default_parameter_values ( ZoneGrowableArray< const Instance * > *  list )

inline

Definition at line 109 of file parser.h.

                                                                              {
    default_parameter_values_ = list;
#if defined(DEBUG)
    if (list == nullptr) return;
    for (intptr_t i = 0; i < list->length(); i++) {
      DEBUG_ASSERT(list->At(i)->IsNotTemporaryScopedHandle());
    }
#endif
  }

set_entry_points_temp_var()

void dart::ParsedFunction::set_entry_points_temp_var ( LocalVariable *  value )

inline

Definition at line 167 of file parser.h.

                                                       {
    ASSERT(!has_entry_points_temp_var());
    entry_points_temp_var_ = value;
  }

set_expression_temp_var()

void dart::ParsedFunction::set_expression_temp_var ( LocalVariable *  value )

inline

Definition at line 155 of file parser.h.

                                                     {
    ASSERT(!has_expression_temp_var());
    expression_temp_var_ = value;
  }

set_finally_return_temp_var()

void dart::ParsedFunction::set_finally_return_temp_var ( LocalVariable *  value )

inline

Definition at line 179 of file parser.h.

                                                         {
    ASSERT(!has_finally_return_temp_var());
    finally_return_temp_var_ = value;
  }

set_function_type_arguments()

void dart::ParsedFunction::set_function_type_arguments ( LocalVariable *  function_type_arguments )

inline

Definition at line 91 of file parser.h.

                                                                           {
    ASSERT(function_type_arguments != nullptr);
    function_type_arguments_ = function_type_arguments;
  }

set_parent_type_arguments()

void dart::ParsedFunction::set_parent_type_arguments ( LocalVariable *  parent_type_arguments )

inline

Definition at line 98 of file parser.h.

                                                                       {
    ASSERT(parent_type_arguments != nullptr);
    parent_type_arguments_ = parent_type_arguments;
  }

set_receiver_used()

void dart::ParsedFunction::set_receiver_used ( )

inline

Definition at line 144 of file parser.h.

{ receiver_used_ = true; }

set_receiver_var()

void dart::ParsedFunction::set_receiver_var ( LocalVariable *  value )

inline

Definition at line 137 of file parser.h.

                                              {
    ASSERT(receiver_var_ == nullptr);
    ASSERT(value != nullptr);
    receiver_var_ = value;
  }

set_scope()

void dart::ParsedFunction::set_scope ( LocalScope *  scope )

inline

Definition at line 77 of file parser.h.

                                    {
    ASSERT(scope_ == nullptr);
    ASSERT(scope != nullptr);
    scope_ = scope;
  }

set_suspend_state_var()

void dart::ParsedFunction::set_suspend_state_var ( LocalVariable *  suspend_state_var )

inline

Definition at line 104 of file parser.h.

                                                               {
    ASSERT(suspend_state_var != nullptr);
    suspend_state_var_ = suspend_state_var;
  }

SetCovariantParameters()

void dart::ParsedFunction::SetCovariantParameters

(

const BitVector *

covariant_parameters

)

Definition at line 308 of file parser.cc.

                                           {
  ASSERT(covariant_parameters_ == nullptr);
  ASSERT(covariant_parameters->length() == function_.NumParameters());
  covariant_parameters_ = covariant_parameters;
}

SetGenericCovariantImplParameters()

void dart::ParsedFunction::SetGenericCovariantImplParameters

(

const BitVector *

generic_covariant_impl_parameters

)

Definition at line 315 of file parser.cc.

                                                        {
  ASSERT(generic_covariant_impl_parameters_ == nullptr);
  ASSERT(generic_covariant_impl_parameters->length() ==
         function_.NumParameters());
  generic_covariant_impl_parameters_ = generic_covariant_impl_parameters;
}

SetRawParameters()

void dart::ParsedFunction::SetRawParameters ( ZoneGrowableArray< LocalVariable * > *  raw_parameters )

inline

Definition at line 231 of file parser.h.

                                                                           {
    raw_parameters_ = raw_parameters;
  }

SetRawTypeArgumentsVariable()

void dart::ParsedFunction::SetRawTypeArgumentsVariable ( LocalVariable *  raw_type_arguments_var )

inline

Definition at line 227 of file parser.h.

                                                                          {
    raw_type_arguments_var_ = raw_type_arguments_var;
  }

SetRegExpCompileData()

void dart::ParsedFunction::SetRegExpCompileData

(

RegExpCompileData *

regexp_compile_data

)

Definition at line 173 of file parser.cc.

                                            {
  ASSERT(regexp_compile_data_ == nullptr);
  ASSERT(regexp_compile_data != nullptr);
  regexp_compile_data_ = regexp_compile_data;
}

suspend_state_var()

LocalVariable * dart::ParsedFunction::suspend_state_var ( ) const

inline

Definition at line 103 of file parser.h.

{ return suspend_state_var_; }

thread()

Thread * dart::ParsedFunction::thread ( ) const

inline

Definition at line 211 of file parser.h.

{ return thread_; }

zone()

Zone * dart::ParsedFunction::zone ( ) const

inline

Definition at line 213 of file parser.h.

{ return thread_->zone(); }

Friends And Related Symbol Documentation

Parser

friend class Parser

friend

Definition at line 327 of file parser.h.

---

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

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