virtual ~VariableMap();
- Variable* Declare(Scope* scope,
- Handle<String> name,
- VariableMode mode,
- bool is_valid_lhs,
- Variable::Kind kind,
+ Variable* Declare(Scope* scope, const AstRawString* name, VariableMode mode,
+ bool is_valid_lhs, Variable::Kind kind,
InitializationFlag initialization_flag,
+ MaybeAssignedFlag maybe_assigned_flag = kNotAssigned,
Interface* interface = Interface::NewValue());
- Variable* Lookup(Handle<String> name);
+ Variable* Lookup(const AstRawString* name);
Zone* zone() const { return zone_; }
VariableMap* GetMap(VariableMode mode) {
int index = mode - DYNAMIC;
- ASSERT(index >= 0 && index < 3);
+ DCHECK(index >= 0 && index < 3);
return maps_[index];
}
// ---------------------------------------------------------------------------
// Construction
- Scope(Scope* outer_scope, ScopeType scope_type, Zone* zone);
+ Scope(Scope* outer_scope, ScopeType scope_type,
+ AstValueFactory* value_factory, Zone* zone);
// Compute top scope and allocate variables. For lazy compilation the top
// scope only contains the single lazily compiled function, so this
Zone* zone);
// The scope name is only used for printing/debugging.
- void SetScopeName(Handle<String> scope_name) { scope_name_ = scope_name; }
+ void SetScopeName(const AstRawString* scope_name) {
+ scope_name_ = scope_name;
+ }
void Initialize();
// Declarations
// Lookup a variable in this scope. Returns the variable or NULL if not found.
- Variable* LookupLocal(Handle<String> name);
+ Variable* LookupLocal(const AstRawString* name);
// This lookup corresponds to a lookup in the "intermediate" scope sitting
// between this scope and the outer scope. (ECMA-262, 3rd., requires that
// the name of named function literal is kept in an intermediate scope
// in between this scope and the next outer scope.)
- Variable* LookupFunctionVar(Handle<String> name,
+ Variable* LookupFunctionVar(const AstRawString* name,
AstNodeFactory<AstNullVisitor>* factory);
// Lookup a variable in this scope or outer scopes.
// Returns the variable or NULL if not found.
- Variable* Lookup(Handle<String> name);
+ Variable* Lookup(const AstRawString* name);
// Declare the function variable for a function literal. This variable
// is in an intermediate scope between this function scope and the the
// outer scope. Only possible for function scopes; at most one variable.
void DeclareFunctionVar(VariableDeclaration* declaration) {
- ASSERT(is_function_scope());
+ DCHECK(is_function_scope());
function_ = declaration;
}
// Declare a parameter in this scope. When there are duplicated
// parameters the rightmost one 'wins'. However, the implementation
// expects all parameters to be declared and from left to right.
- void DeclareParameter(Handle<String> name, VariableMode mode);
+ Variable* DeclareParameter(const AstRawString* name, VariableMode mode);
// Declare a local variable in this scope. If the variable has been
// declared before, the previously declared variable is returned.
- Variable* DeclareLocal(Handle<String> name,
- VariableMode mode,
+ Variable* DeclareLocal(const AstRawString* name, VariableMode mode,
InitializationFlag init_flag,
+ MaybeAssignedFlag maybe_assigned_flag = kNotAssigned,
Interface* interface = Interface::NewValue());
// Declare an implicit global variable in this scope which must be a
// global scope. The variable was introduced (possibly from an inner
// scope) by a reference to an unresolved variable with no intervening
// with statements or eval calls.
- Variable* DeclareDynamicGlobal(Handle<String> name);
+ Variable* DeclareDynamicGlobal(const AstRawString* name);
// Create a new unresolved variable.
template<class Visitor>
VariableProxy* NewUnresolved(AstNodeFactory<Visitor>* factory,
- Handle<String> name,
+ const AstRawString* name,
Interface* interface = Interface::NewValue(),
int position = RelocInfo::kNoPosition) {
// Note that we must not share the unresolved variables with
// the same name because they may be removed selectively via
// RemoveUnresolved().
- ASSERT(!already_resolved());
+ DCHECK(!already_resolved());
VariableProxy* proxy =
factory->NewVariableProxy(name, false, interface, position);
unresolved_.Add(proxy, zone_);
// for printing and cannot be used to find the variable. In particular,
// the only way to get hold of the temporary is by keeping the Variable*
// around.
- Variable* NewInternal(Handle<String> name);
+ Variable* NewInternal(const AstRawString* name);
// Creates a new temporary variable in this scope. The name is only used
// for printing and cannot be used to find the variable. In particular,
// the only way to get hold of the temporary is by keeping the Variable*
// around. The name should not clash with a legitimate variable names.
- Variable* NewTemporary(Handle<String> name);
+ Variable* NewTemporary(const AstRawString* name);
// Adds the specific declaration node to the list of declarations in
// this scope. The declarations are processed as part of entering
// In some cases we want to force context allocation for a whole scope.
void ForceContextAllocation() {
- ASSERT(!already_resolved());
+ DCHECK(!already_resolved());
force_context_allocation_ = true;
}
bool has_forced_context_allocation() const {
// The variable holding the function literal for named function
// literals, or NULL. Only valid for function scopes.
VariableDeclaration* function() const {
- ASSERT(is_function_scope());
+ DCHECK(is_function_scope());
return function_;
}
// Parameters. The left-most parameter has index 0.
// Only valid for function scopes.
Variable* parameter(int index) const {
- ASSERT(is_function_scope());
+ DCHECK(is_function_scope());
return params_[index];
}
// ---------------------------------------------------------------------------
// Strict mode support.
- bool IsDeclared(Handle<String> name) {
+ bool IsDeclared(const AstRawString* name) {
// 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
ScopeType scope_type_;
// Debugging support.
- Handle<String> scope_name_;
+ const AstRawString* scope_name_;
// The variables declared in this scope:
//
// Create a non-local variable with a given name.
// These variables are looked up dynamically at runtime.
- Variable* NonLocal(Handle<String> name, VariableMode mode);
+ Variable* NonLocal(const AstRawString* name, VariableMode mode);
// Variable resolution.
// Possible results of a recursive variable lookup telling if and how a
// Lookup a variable reference given by name recursively starting with this
// scope. If the code is executed because of a call to 'eval', the context
// parameter should be set to the calling context of 'eval'.
- Variable* LookupRecursive(Handle<String> name,
+ Variable* LookupRecursive(VariableProxy* proxy,
BindingKind* binding_kind,
AstNodeFactory<AstNullVisitor>* factory);
MUST_USE_RESULT
AstNodeFactory<AstNullVisitor>* factory);
// Scope analysis.
- bool PropagateScopeInfo(bool outer_scope_calls_sloppy_eval);
+ void PropagateScopeInfo(bool outer_scope_calls_sloppy_eval);
bool HasTrivialContext() const;
// Predicates.
private:
// Construct a scope based on the scope info.
Scope(Scope* inner_scope, ScopeType type, Handle<ScopeInfo> scope_info,
- Zone* zone);
+ AstValueFactory* value_factory, Zone* zone);
// Construct a catch scope with a binding for the name.
- Scope(Scope* inner_scope, Handle<String> catch_variable_name, Zone* zone);
+ Scope(Scope* inner_scope,
+ const AstRawString* catch_variable_name,
+ AstValueFactory* value_factory, Zone* zone);
void AddInnerScope(Scope* inner_scope) {
if (inner_scope != NULL) {
Scope* outer_scope,
Handle<ScopeInfo> scope_info);
+ AstValueFactory* ast_value_factory_;
Zone* zone_;
};
projects / platform / framework / web / crosswalk.git / blobdiff