Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(324)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: runtime/vm/parser.cc

Issue 306483005: - Use isolate where it is appropriate. (Closed) Base URL: http://dart.googlecode.com/svn/branches/bleeding_edge/dart/
Patch Set: Created 6 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « runtime/vm/native_entry.cc ('k') | runtime/vm/runtime_entry_arm.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: runtime/vm/parser.cc
===================================================================
--- runtime/vm/parser.cc (revision 36643)
+++ runtime/vm/parser.cc (working copy)
@@ -305,7 +305,7 @@
literal_token_(LiteralToken::Handle(isolate_)),
current_class_(Class::Handle(isolate_,
parsed_function->function().Owner())),
- library_(Library::Handle(Class::Handle(
+ library_(Library::Handle(isolate_, Class::Handle(
Cutch 2014/05/27 10:00:02 Should this use isolate() instead of isolate_?
Ivan Posva 2014/05/27 10:15:53 This is in the constructor, so I use isolate_ like
isolate_,
parsed_function->function().origin()).library())),
try_blocks_list_(NULL),
@@ -334,7 +334,8 @@
void Parser::SetScript(const Script& script, intptr_t token_pos) {
script_ = script.raw();
- tokens_iterator_.SetStream(TokenStream::Handle(script.tokens()), token_pos);
+ tokens_iterator_.SetStream(
+ TokenStream::Handle(isolate(), script.tokens()), token_pos);
token_kind_ = Token::kILLEGAL;
}
@@ -425,7 +426,7 @@
ASSERT(literal_token_.kind() == Token::kINTEGER);
RawInteger* ri = Integer::RawCast(literal_token_.value());
if (FLAG_throw_on_javascript_int_overflow) {
- const Integer& i = Integer::Handle(ri);
+ const Integer& i = Integer::Handle(isolate(), ri);
if (i.CheckJavascriptIntegerOverflow()) {
ErrorMsg(TokenPos(),
"Integer literal does not fit in a Javascript integer: %s.",
@@ -882,8 +883,8 @@
StackZone zone(isolate);
LongJumpScope jump;
if (setjmp(*jump.Set()) == 0) {
- const Script& script = Script::Handle(cls.script());
- const Library& lib = Library::Handle(cls.library());
+ const Script& script = Script::Handle(isolate, cls.script());
Cutch 2014/05/27 10:00:02 You can use: isolate() right?
Ivan Posva 2014/05/27 10:15:53 No, as this is a static method.
+ const Library& lib = Library::Handle(isolate, cls.library());
Parser parser(script, lib, token_pos);
parser.set_current_class(cls);
parser.set_parsing_metadata(true);
@@ -891,7 +892,7 @@
RawObject* metadata = parser.EvaluateMetadata();
return metadata;
} else {
- Error& error = Error::Handle();
+ Error& error = Error::Handle(isolate);
error = isolate->object_store()->sticky_error();
isolate->object_store()->clear_sticky_error();
return error.raw();
@@ -904,7 +905,7 @@
RawArray* Parser::EvaluateMetadata() {
CheckToken(Token::kAT, "Metadata character '@' expected");
GrowableObjectArray& meta_values =
- GrowableObjectArray::Handle(GrowableObjectArray::New());
+ GrowableObjectArray::Handle(isolate(), GrowableObjectArray::New());
while (CurrentToken() == Token::kAT) {
ConsumeToken();
intptr_t expr_pos = TokenPos();
@@ -912,7 +913,8 @@
ExpectIdentifier("identifier expected");
}
// Reject expressions with deferred library prefix eagerly.
- Object& obj = Object::Handle(library_.LookupLocalObject(*CurrentLiteral()));
+ Object& obj = Object::Handle(isolate(),
+ library_.LookupLocalObject(*CurrentLiteral()));
if (!obj.IsNull() && obj.IsLibraryPrefix()) {
if (LibraryPrefix::Cast(obj).is_deferred_load()) {
ErrorMsg("Metadata must be compile-time constant");
@@ -929,7 +931,7 @@
} else {
// Can be x, C.x, or L.C.x.
expr = ParsePrimary(); // Consumes x, C or L.C.
- Class& cls = Class::Handle();
+ Class& cls = Class::Handle(isolate());
if (expr->IsPrimaryNode()) {
PrimaryNode* primary_node = expr->AsPrimaryNode();
if (primary_node->primary().IsClass()) {
@@ -950,7 +952,8 @@
ConsumeToken();
const intptr_t ident_pos = TokenPos();
String* ident = ExpectIdentifier("identifier expected");
- const Field& field = Field::Handle(cls.LookupStaticField(*ident));
+ const Field& field = Field::Handle(isolate(),
+ cls.LookupStaticField(*ident));
if (field.IsNull()) {
ErrorMsg(ident_pos,
"Class '%s' has no field '%s'",
@@ -981,7 +984,7 @@
ParamList params;
ASSERT(func.num_fixed_parameters() == 0); // static.
ASSERT(!func.HasOptionalParameters());
- ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+ ASSERT(AbstractType::Handle(isolate(), func.result_type()).IsResolved());
// Build local scope for function and populate with the formal parameters.
OpenFunctionBlock(func);
@@ -989,7 +992,7 @@
intptr_t ident_pos = TokenPos();
const String& field_name = *ExpectIdentifier("field name expected");
- const Class& field_class = Class::Handle(func.Owner());
+ const Class& field_class = Class::Handle(isolate(), func.Owner());
const Field& field =
Field::ZoneHandle(field_class.LookupStaticField(field_name));
@@ -1061,9 +1064,9 @@
ident_pos,
field,
new LiteralNode(ident_pos, Object::transition_sentinel())));
- const String& init_name = String::Handle(
- Symbols::New(String::Handle(String::Concat(
- Symbols::InitPrefix(), String::Handle(field.name())))));
+ const String& init_name = String::Handle(isolate(), Symbols::New(
+ String::Handle(isolate(), String::Concat(
+ Symbols::InitPrefix(), String::Handle(isolate(), field.name())))));
const Function& init_function = Function::ZoneHandle(
field_class.LookupStaticFunction(init_name));
ASSERT(!init_function.IsNull());
@@ -1091,7 +1094,7 @@
ParamList params;
ASSERT(func.num_fixed_parameters() == 0); // static.
ASSERT(!func.HasOptionalParameters());
- ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+ ASSERT(AbstractType::Handle(isolate(), func.result_type()).IsResolved());
// Build local scope for function and populate with the formal parameters.
OpenFunctionBlock(func);
@@ -1198,7 +1201,7 @@
params.AddReceiver(ReceiverType(current_class()), ident_pos);
ASSERT(func.num_fixed_parameters() == 1); // receiver.
ASSERT(!func.HasOptionalParameters());
- ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+ ASSERT(AbstractType::Handle(isolate(), func.result_type()).IsResolved());
// Build local scope for function and populate with the formal parameters.
OpenFunctionBlock(func);
@@ -1209,7 +1212,7 @@
LoadLocalNode* load_receiver = new LoadLocalNode(ident_pos, receiver);
ASSERT(IsIdentifier());
const String& field_name = *CurrentLiteral();
- const Class& field_class = Class::Handle(func.Owner());
+ const Class& field_class = Class::Handle(isolate(), func.Owner());
const Field& field =
Field::ZoneHandle(field_class.LookupInstanceField(field_name));
@@ -1246,7 +1249,7 @@
&field_type);
ASSERT(func.num_fixed_parameters() == 2); // receiver, value.
ASSERT(!func.HasOptionalParameters());
- ASSERT(AbstractType::Handle(func.result_type()).IsVoidType());
+ ASSERT(AbstractType::Handle(isolate(), func.result_type()).IsVoidType());
// Build local scope for function and populate with the formal parameters.
OpenFunctionBlock(func);
@@ -1346,7 +1349,7 @@
ASSERT(func.token_pos() == 0);
ASSERT(current_class().raw() == func.Owner());
- ArgumentsDescriptor desc(Array::Handle(func.saved_args_desc()));
+ ArgumentsDescriptor desc(Array::Handle(isolate(), func.saved_args_desc()));
ASSERT(desc.Count() > 0);
// Set up scope for this function.
@@ -1362,7 +1365,7 @@
if (desc.NamedCount() > 0) {
const Array& arg_names = Array::ZoneHandle(Array::New(desc.NamedCount()));
for (intptr_t i = 0; i < arg_names.Length(); ++i) {
- arg_names.SetAt(i, String::Handle(desc.NameAt(i)));
+ arg_names.SetAt(i, String::Handle(isolate(), desc.NameAt(i)));
}
func_args->set_names(arg_names);
}
@@ -1371,8 +1374,8 @@
ArgumentListNode* arguments = BuildNoSuchMethodArguments(
token_pos, func_name, *func_args, NULL, false);
const Function& no_such_method = Function::ZoneHandle(
- Resolver::ResolveDynamicAnyArgs(Class::Handle(func.Owner()),
- Symbols::NoSuchMethod()));
+ Resolver::ResolveDynamicAnyArgs(Class::Handle(
+ isolate(), func.Owner()), Symbols::NoSuchMethod()));
StaticCallNode* call =
new StaticCallNode(token_pos, no_such_method, arguments);
@@ -1391,7 +1394,7 @@
ASSERT(func.token_pos() == 0);
ASSERT(current_class().raw() == func.Owner());
- const Array& args_desc = Array::Handle(func.saved_args_desc());
+ const Array& args_desc = Array::Handle(isolate(), func.saved_args_desc());
ArgumentsDescriptor desc(args_desc);
ASSERT(desc.Count() > 0);
@@ -1403,17 +1406,16 @@
ArgumentListNode* no_args = new ArgumentListNode(token_pos);
LoadLocalNode* receiver = new LoadLocalNode(token_pos, scope->VariableAt(0));
- const String& name = String::Handle(func.name());
- const String& getter_name =
- String::ZoneHandle(Symbols::New(String::Handle(Field::GetterName(name))));
- InstanceCallNode* getter_call = new InstanceCallNode(token_pos,
- receiver,
- getter_name,
- no_args);
+ const String& name = String::Handle(isolate(), func.name());
+ const String& getter_name = String::ZoneHandle(
srdjan 2014/05/27 10:00:53 pass isolate to ZoneHandle as well
Ivan Posva 2014/05/27 10:15:53 This change only dealt with Handle, even though th
+ Symbols::New(String::Handle(isolate(), Field::GetterName(name))));
+ InstanceCallNode* getter_call = new(isolate()) InstanceCallNode(
+ token_pos, receiver, getter_name, no_args);
// Pass arguments 1..n to the closure call.
ArgumentListNode* args = new ArgumentListNode(token_pos);
- const Array& names = Array::Handle(Array::New(desc.NamedCount(), Heap::kOld));
+ const Array& names = Array::Handle(
+ isolate(), Array::New(desc.NamedCount(), Heap::kOld));
// Positional parameters.
intptr_t i = 1;
for (; i < desc.PositionalCount(); ++i) {
@@ -1423,11 +1425,11 @@
for (; i < desc.Count(); i++) {
args->Add(new LoadLocalNode(token_pos, scope->VariableAt(i)));
intptr_t index = i - desc.PositionalCount();
- names.SetAt(index, String::Handle(desc.NameAt(index)));
+ names.SetAt(index, String::Handle(isolate(), desc.NameAt(index)));
}
args->set_names(names);
- const Class& owner = Class::Handle(func.Owner());
+ const Class& owner = Class::Handle(isolate(), func.Owner());
ASSERT(!owner.IsNull());
AstNode* result = NULL;
if (owner.IsSignatureClass() && name.Equals(Symbols::Call())) {
@@ -1602,7 +1604,7 @@
if (!var_seen && !parameter.is_final) {
// The parsed parameter type is actually the function result type.
const AbstractType& result_type =
- AbstractType::Handle(parameter.type->raw());
+ AbstractType::Handle(isolate(), parameter.type->raw());
// Finish parsing the function type parameter.
ParamList func_params;
@@ -1617,7 +1619,7 @@
ParseFormalParameterList(no_explicit_default_values, false, &func_params);
// The field 'is_static' has no meaning for signature functions.
- const Function& signature_function = Function::Handle(
+ const Function& signature_function = Function::Handle(isolate(),
Function::New(*parameter.name,
RawFunction::kSignatureFunction,
/* is_static = */ false,
@@ -1629,7 +1631,8 @@
parameter.name_pos));
signature_function.set_result_type(result_type);
AddFormalParamsToFunction(&func_params, signature_function);
- const String& signature = String::Handle(signature_function.Signature());
+ const String& signature = String::Handle(isolate(),
+ signature_function.Signature());
// Lookup the signature class, i.e. the class whose name is the signature.
// We only lookup in the current library, but not in its imports, and only
// create a new canonical signature class if it does not exist yet.
@@ -1789,12 +1792,13 @@
ArgumentListNode* arguments,
bool resolve_getter,
bool* is_no_such_method) {
- const Class& super_class = Class::Handle(current_class().SuperClass());
+ const Class& super_class = Class::Handle(
+ isolate(), current_class().SuperClass());
if (super_class.IsNull()) {
ErrorMsg(token_pos, "class '%s' does not have a superclass",
- String::Handle(current_class().Name()).ToCString());
+ String::Handle(isolate(), current_class().Name()).ToCString());
}
- Function& super_func = Function::Handle(
+ Function& super_func = Function::Handle(isolate(),
Resolver::ResolveDynamicAnyArgs(super_class, name));
if (!super_func.IsNull() &&
!super_func.AreValidArguments(arguments->length(),
@@ -2036,7 +2040,7 @@
// parameterized class, make sure that the receiver is captured as
// instantiator.
if (current_block_->scope->function_level() > 0) {
- const Class& signature_class = Class::Handle(
+ const Class& signature_class = Class::Handle(isolate(),
implicit_closure_function.signature_class());
if (signature_class.NumTypeParameters() > 0) {
CaptureInstantiator();
@@ -2053,7 +2057,7 @@
const Class& super_class = Class::ZoneHandle(current_class().SuperClass());
if (super_class.IsNull()) {
ErrorMsg("class '%s' does not have a superclass",
- String::Handle(current_class().Name()).ToCString());
+ String::Handle(isolate(), current_class().Name()).ToCString());
}
AstNode* implicit_argument = LoadReceiver(field_pos);
@@ -2093,16 +2097,16 @@
intptr_t supercall_pos,
LocalVariable* receiver,
ArgumentListNode* forwarding_args) {
- const Class& super_class = Class::Handle(cls.SuperClass());
+ const Class& super_class = Class::Handle(isolate(), cls.SuperClass());
// Omit the implicit super() if there is no super class (i.e.
// we're not compiling class Object), or if the super class is an
// artificially generated "wrapper class" that has no constructor.
if (super_class.IsNull() ||
(super_class.num_native_fields() > 0 &&
- Class::Handle(super_class.SuperClass()).IsObjectClass())) {
+ Class::Handle(isolate(), super_class.SuperClass()).IsObjectClass())) {
return;
}
- String& super_ctor_name = String::Handle(super_class.Name());
+ String& super_ctor_name = String::Handle(isolate(), super_class.Name());
super_ctor_name = String::Concat(super_ctor_name, Symbols::Dot());
ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
@@ -2122,8 +2126,8 @@
for (int i = 0; i < forwarding_args->length(); i++) {
arguments->Add(forwarding_args->NodeAt(i));
}
- String& ctor_name = String::Handle(current_function().name());
- String& class_name = String::Handle(cls.Name());
+ String& ctor_name = String::Handle(isolate(), current_function().name());
+ String& class_name = String::Handle(isolate(), cls.Name());
if (ctor_name.Length() > class_name.Length() + 1) {
// Generating a forwarding call to a named constructor 'C.n'.
// Add the constructor name 'n' to the super constructor.
@@ -2138,19 +2142,19 @@
if (super_ctor.IsNull()) {
ErrorMsg(supercall_pos,
"unresolved implicit call to super constructor '%s()'",
- String::Handle(super_class.Name()).ToCString());
+ String::Handle(isolate(), super_class.Name()).ToCString());
}
if (current_function().is_const() && !super_ctor.is_const()) {
ErrorMsg(supercall_pos, "implicit call to non-const super constructor");
}
- String& error_message = String::Handle();
+ String& error_message = String::Handle(isolate());
if (!super_ctor.AreValidArguments(arguments->length(),
arguments->names(),
&error_message)) {
ErrorMsg(supercall_pos,
"invalid arguments passed to super constructor '%s()': %s",
- String::Handle(super_class.Name()).ToCString(),
+ String::Handle(isolate(), super_class.Name()).ToCString(),
error_message.ToCString());
}
current_block_->statements->Add(
@@ -2164,9 +2168,9 @@
ASSERT(CurrentToken() == Token::kSUPER);
const intptr_t supercall_pos = TokenPos();
ConsumeToken();
- const Class& super_class = Class::Handle(cls.SuperClass());
+ const Class& super_class = Class::Handle(isolate(), cls.SuperClass());
ASSERT(!super_class.IsNull());
- String& ctor_name = String::Handle(super_class.Name());
+ String& ctor_name = String::Handle(isolate(), super_class.Name());
ctor_name = String::Concat(ctor_name, Symbols::Dot());
if (CurrentToken() == Token::kPERIOD) {
ConsumeToken();
@@ -2203,7 +2207,7 @@
if (current_function().is_const() && !super_ctor.is_const()) {
ErrorMsg(supercall_pos, "super constructor must be const");
}
- String& error_message = String::Handle();
+ String& error_message = String::Handle(isolate());
if (!super_ctor.AreValidArguments(arguments->length(),
arguments->names(),
&error_message)) {
@@ -2254,8 +2258,8 @@
void Parser::CheckFieldsInitialized(const Class& cls) {
- const Array& fields = Array::Handle(cls.fields());
- Field& field = Field::Handle();
+ const Array& fields = Array::Handle(isolate(), cls.fields());
+ Field& field = Field::Handle(isolate());
SequenceNode* initializers = current_block_->statements;
for (int field_num = 0; field_num < fields.Length(); field_num++) {
field ^= fields.At(field_num);
@@ -2278,7 +2282,7 @@
if (found) continue;
- field.UpdateGuardedCidAndLength(Object::Handle());
+ field.UpdateGuardedCidAndLength(Object::Handle(isolate()));
}
}
@@ -2288,14 +2292,15 @@
// from a different class. We need to save and restore current
// class, library, and token stream (script).
ASSERT(current_class().raw() != field.origin());
- const Class& saved_class = Class::Handle(current_class().raw());
- const Library& saved_library = Library::Handle(library().raw());
- const Script& saved_script = Script::Handle(script().raw());
+ const Class& saved_class = Class::Handle(isolate(), current_class().raw());
+ const Library& saved_library = Library::Handle(isolate(), library().raw());
+ const Script& saved_script = Script::Handle(isolate(), script().raw());
const intptr_t saved_token_pos = TokenPos();
- set_current_class(Class::Handle(field.origin()));
- set_library(Library::Handle(current_class().library()));
- SetScript(Script::Handle(current_class().script()), field.token_pos());
+ set_current_class(Class::Handle(isolate(), field.origin()));
+ set_library(Library::Handle(isolate(), current_class().library()));
+ SetScript(Script::Handle(isolate(), current_class().script()),
+ field.token_pos());
ASSERT(IsIdentifier());
ConsumeToken();
@@ -2323,8 +2328,8 @@
LocalVariable* receiver,
GrowableArray<Field*>* initialized_fields) {
TRACE_PARSER("ParseInitializedInstanceFields");
- const Array& fields = Array::Handle(cls.fields());
- Field& f = Field::Handle();
+ const Array& fields = Array::Handle(isolate(), cls.fields());
+ Field& f = Field::Handle(isolate());
const intptr_t saved_pos = TokenPos();
for (int i = 0; i < fields.Length(); i++) {
f ^= fields.At(i);
@@ -2380,7 +2385,7 @@
if (initialized_field->raw() == field->raw()) {
ErrorMsg(init_pos,
"duplicate initialization for field %s",
- String::Handle(field->name()).ToCString());
+ String::Handle(isolate(), field->name()).ToCString());
}
}
initialized_fields->Add(field);
@@ -2424,7 +2429,7 @@
ASSERT(CurrentToken() == Token::kTHIS);
const intptr_t call_pos = TokenPos();
ConsumeToken();
- String& ctor_name = String::Handle(cls.Name());
+ String& ctor_name = String::Handle(isolate(), cls.Name());
ctor_name = String::Concat(ctor_name, Symbols::Dot());
if (CurrentToken() == Token::kPERIOD) {
@@ -2452,7 +2457,7 @@
if (redirect_ctor.IsNull()) {
ErrorMsg(call_pos, "constructor '%s' not found", ctor_name.ToCString());
}
- String& error_message = String::Handle();
+ String& error_message = String::Handle(isolate());
if (!redirect_ctor.AreValidArguments(arguments->length(),
arguments->names(),
&error_message)) {
@@ -2541,12 +2546,12 @@
void Parser::CheckRecursiveInvocation() {
const GrowableObjectArray& pending_functions =
- GrowableObjectArray::Handle(
+ GrowableObjectArray::Handle(isolate(),
isolate()->object_store()->pending_functions());
for (int i = 0; i < pending_functions.Length(); i++) {
if (pending_functions.At(i) == current_function().raw()) {
const String& fname =
- String::Handle(current_function().UserVisibleName());
+ String::Handle(isolate(), current_function().UserVisibleName());
ErrorMsg("circular dependency for function %s", fname.ToCString());
}
}
@@ -2565,7 +2570,7 @@
ASSERT(!func.IsFactory());
ASSERT(!func.is_static());
ASSERT(!func.IsLocalFunction());
- const Class& cls = Class::Handle(func.Owner());
+ const Class& cls = Class::Handle(isolate(), func.Owner());
ASSERT(!cls.IsNull());
CheckRecursiveInvocation();
@@ -2602,7 +2607,7 @@
ParseFormalParameterList(allow_explicit_default_values, false, &params);
SetupDefaultsForOptionalParams(&params, default_parameter_values);
- ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+ ASSERT(AbstractType::Handle(isolate(), func.result_type()).IsResolved());
ASSERT(func.NumParameters() == params.parameters->length());
// Now populate function scope with the formal parameters.
@@ -2854,7 +2859,7 @@
Array* default_parameter_values) {
TRACE_PARSER("ParseFunc");
Function& saved_innermost_function =
- Function::Handle(innermost_function().raw());
+ Function::Handle(isolate(), innermost_function().raw());
innermost_function_ = func.raw();
// Save current try index. Try index starts at zero for each function.
@@ -2910,7 +2915,7 @@
AddFormalParamsToFunction(&params, func);
}
SetupDefaultsForOptionalParams(&params, default_parameter_values);
- ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+ ASSERT(AbstractType::Handle(isolate(), func.result_type()).IsResolved());
ASSERT(func.NumParameters() == params.parameters->length());
// Check whether the function has any field initializer formal parameters,
@@ -2945,8 +2950,9 @@
intptr_t end_token_pos = 0;
if (CurrentToken() == Token::kLBRACE) {
ConsumeToken();
- if (String::Handle(func.name()).Equals(Symbols::EqualOperator())) {
- const Class& owner = Class::Handle(func.Owner());
+ if (String::Handle(isolate(), func.name()).Equals(
+ Symbols::EqualOperator())) {
+ const Class& owner = Class::Handle(isolate(), func.Owner());
if (!owner.IsObjectClass()) {
AddEqualityNullCheck();
}
@@ -2956,8 +2962,9 @@
ExpectToken(Token::kRBRACE);
} else if (CurrentToken() == Token::kARROW) {
ConsumeToken();
- if (String::Handle(func.name()).Equals(Symbols::EqualOperator())) {
- const Class& owner = Class::Handle(func.Owner());
+ if (String::Handle(isolate(), func.name()).Equals(
+ Symbols::EqualOperator())) {
+ const Class& owner = Class::Handle(isolate(), func.Owner());
if (!owner.IsObjectClass()) {
AddEqualityNullCheck();
}
@@ -2968,8 +2975,9 @@
current_block_->statements->Add(new ReturnNode(expr_pos, expr));
end_token_pos = TokenPos();
} else if (IsLiteral("native")) {
- if (String::Handle(func.name()).Equals(Symbols::EqualOperator())) {
- const Class& owner = Class::Handle(func.Owner());
+ if (String::Handle(isolate(), func.name()).Equals(
+ Symbols::EqualOperator())) {
+ const Class& owner = Class::Handle(isolate(), func.Owner());
if (!owner.IsObjectClass()) {
AddEqualityNullCheck();
}
@@ -3101,7 +3109,8 @@
} else {
// TODO(hausner): Should we resolve the prefix via the library scope
// rather than via the class?
- Class& cls = Class::Handle(parsed_function()->function().origin());
+ Class& cls = Class::Handle(isolate(),
+ parsed_function()->function().origin());
lib_prefix = cls.LookupLibraryPrefix(*(qual_ident->ident));
}
if (!lib_prefix.IsNull()) {
@@ -3218,8 +3227,8 @@
}
// Parse redirecting factory constructor.
- Type& redirection_type = Type::Handle();
- String& redirection_identifier = String::Handle();
+ Type& redirection_type = Type::Handle(isolate());
+ String& redirection_identifier = String::Handle(isolate());
bool is_redirecting = false;
if (method->IsFactory() && (CurrentToken() == Token::kASSIGN)) {
// Default parameter values are disallowed in redirecting factories.
@@ -3231,17 +3240,17 @@
ConsumeToken();
const intptr_t type_pos = TokenPos();
is_redirecting = true;
- const AbstractType& type = AbstractType::Handle(
+ const AbstractType& type = AbstractType::Handle(isolate(),
ParseType(ClassFinalizer::kResolveTypeParameters));
if (!type.IsMalformed() && type.IsTypeParameter()) {
// Replace the type with a malformed type and compile a throw when called.
redirection_type = ClassFinalizer::NewFinalizedMalformedType(
- Error::Handle(), // No previous error.
+ Error::Handle(isolate()), // No previous error.
script_,
type_pos,
"factory '%s' may not redirect to type parameter '%s'",
method->name->ToCString(),
- String::Handle(type.UserVisibleName()).ToCString());
+ String::Handle(isolate(), type.UserVisibleName()).ToCString());
} else {
// We handle malformed and malbounded redirection type at run time.
redirection_type ^= type.raw();
@@ -3387,7 +3396,7 @@
} else {
function_kind = RawFunction::kRegularFunction;
}
- Function& func = Function::Handle(
+ Function& func = Function::Handle(isolate(),
Function::New(*method->name,
function_kind,
method->has_static,
@@ -3453,10 +3462,10 @@
if (!field->has_static && field->has_const) {
ErrorMsg(field->name_pos, "instance field may not be 'const'");
}
- Function& getter = Function::Handle();
- Function& setter = Function::Handle();
+ Function& getter = Function::Handle(isolate());
+ Function& setter = Function::Handle(isolate());
Field& class_field = Field::ZoneHandle();
- Instance& init_value = Instance::Handle();
+ Instance& init_value = Instance::Handle(isolate());
while (true) {
bool has_initializer = CurrentToken() == Token::kASSIGN;
bool has_simple_literal = false;
@@ -3510,7 +3519,8 @@
if (field->has_static && has_initializer) {
class_field.set_value(init_value);
if (!has_simple_literal) {
- String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
+ String& getter_name = String::Handle(isolate(),
+ Field::GetterSymbol(*field->name));
getter = Function::New(getter_name,
RawFunction::kImplicitStaticFinalGetter,
field->has_static,
@@ -3534,7 +3544,8 @@
// For instance fields, we create implicit getter and setter methods.
if (!field->has_static) {
- String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
+ String& getter_name = String::Handle(isolate(),
+ Field::GetterSymbol(*field->name));
getter = Function::New(getter_name, RawFunction::kImplicitGetter,
field->has_static,
field->has_final,
@@ -3551,7 +3562,8 @@
members->AddFunction(getter);
if (!field->has_final) {
// Build a setter accessor for non-const fields.
- String& setter_name = String::Handle(Field::SetterSymbol(*field->name));
+ String& setter_name = String::Handle(isolate(),
+ Field::SetterSymbol(*field->name));
setter = Function::New(setter_name, RawFunction::kImplicitSetter,
field->has_static,
field->has_final,
@@ -3566,7 +3578,7 @@
params.AddFinalParameter(TokenPos(),
&Symbols::Value(),
field->type);
- setter.set_result_type(Type::Handle(Type::VoidType()));
+ setter.set_result_type(Type::Handle(isolate(), Type::VoidType()));
AddFormalParamsToFunction(&params, setter);
members->AddFunction(setter);
}
@@ -3730,8 +3742,8 @@
}
// Do not bypass class resolution by using current_class() directly, since
// it may be a patch class.
- const Object& result_type_class = Object::Handle(
- UnresolvedClass::New(LibraryPrefix::Handle(),
+ const Object& result_type_class = Object::Handle(isolate(),
+ UnresolvedClass::New(LibraryPrefix::Handle(isolate()),
*member.name,
member.name_pos));
// The type arguments of the result type are the type parameters of the
@@ -3739,7 +3751,7 @@
// from the class being patched.
member.type = &Type::ZoneHandle(Type::New(
result_type_class,
- TypeArguments::Handle(current_class().type_parameters()),
+ TypeArguments::Handle(isolate(), current_class().type_parameters()),
member.name_pos));
// We must be dealing with a constructor or named constructor.
@@ -3862,9 +3874,10 @@
if (FLAG_trace_parser) {
OS::Print("TopLevel parsing class '%s'\n", class_name.ToCString());
}
- Class& cls = Class::Handle();
- TypeArguments& orig_type_parameters = TypeArguments::Handle();
- Object& obj = Object::Handle(library_.LookupLocalObject(class_name));
+ Class& cls = Class::Handle(isolate());
+ TypeArguments& orig_type_parameters = TypeArguments::Handle(isolate());
+ Object& obj = Object::Handle(isolate(),
+ library_.LookupLocalObject(class_name));
if (obj.IsNull()) {
if (is_patch) {
ErrorMsg(classname_pos, "missing class '%s' cannot be patched",
@@ -3908,7 +3921,7 @@
if (is_patch) {
// Check that the new type parameters are identical to the original ones.
const TypeArguments& new_type_parameters =
- TypeArguments::Handle(cls.type_parameters());
+ TypeArguments::Handle(isolate(), cls.type_parameters());
const int new_type_params_count =
new_type_parameters.IsNull() ? 0 : new_type_parameters.Length();
const int orig_type_params_count =
@@ -3918,10 +3931,10 @@
"class '%s' must be patched with identical type parameters",
class_name.ToCString());
}
- TypeParameter& new_type_param = TypeParameter::Handle();
- TypeParameter& orig_type_param = TypeParameter::Handle();
- String& new_name = String::Handle();
- String& orig_name = String::Handle();
+ TypeParameter& new_type_param = TypeParameter::Handle(isolate());
+ TypeParameter& orig_type_param = TypeParameter::Handle(isolate());
+ String& new_name = String::Handle(isolate());
+ String& orig_name = String::Handle(isolate());
for (int i = 0; i < new_type_params_count; i++) {
new_type_param ^= new_type_parameters.TypeAt(i);
orig_type_param ^= orig_type_parameters.TypeAt(i);
@@ -3955,13 +3968,13 @@
class_name.ToCString());
}
- AbstractType& super_type = Type::Handle();
+ AbstractType& super_type = Type::Handle(isolate());
if ((CurrentToken() == Token::kEXTENDS) || is_mixin_declaration) {
ConsumeToken(); // extends or =
const intptr_t type_pos = TokenPos();
super_type = ParseType(ClassFinalizer::kResolveTypeParameters);
if (super_type.IsMalformedOrMalbounded()) {
- ErrorMsg(Error::Handle(super_type.error()));
+ ErrorMsg(Error::Handle(isolate(), super_type.error()));
}
if (super_type.IsDynamicType()) {
// Unlikely here, since super type is not resolved yet.
@@ -3973,7 +3986,8 @@
ErrorMsg(type_pos,
"class '%s' may not extend type parameter '%s'",
class_name.ToCString(),
- String::Handle(super_type.UserVisibleName()).ToCString());
+ String::Handle(isolate(),
+ super_type.UserVisibleName()).ToCString());
}
// The class finalizer will check whether the super type is malbounded.
if (is_mixin_declaration) {
@@ -4025,7 +4039,7 @@
CompilerStats::num_classes_compiled++;
set_current_class(cls);
is_top_level_ = true;
- String& class_name = String::Handle(cls.Name());
+ String& class_name = String::Handle(isolate(), cls.Name());
const intptr_t class_pos = TokenPos();
ClassDesc members(cls, class_name, false, class_pos);
while (CurrentToken() != Token::kLBRACE) {
@@ -4048,7 +4062,8 @@
cls.AddFields(members.fields());
// Creating a new array for functions marks the class as parsed.
- const Array& array = Array::Handle(Array::MakeArray(members.functions()));
+ const Array& array = Array::Handle(isolate(),
+ Array::MakeArray(members.functions()));
cls.SetFunctions(array);
// Add an implicit constructor if no explicit constructor is present.
@@ -4059,11 +4074,12 @@
if (cls.is_patch()) {
// Apply the changes to the patched class looked up above.
- Object& obj = Object::Handle(library_.LookupLocalObject(class_name));
+ Object& obj = Object::Handle(isolate(),
+ library_.LookupLocalObject(class_name));
// The patched class must not be finalized yet.
const Class& orig_class = Class::Cast(obj);
ASSERT(!orig_class.is_finalized());
- Error& error = Error::Handle();
+ Error& error = Error::Handle(isolate());
if (!orig_class.ApplyPatch(cls, &error)) {
AppendErrorMsg(error, class_pos, "applying patch failed");
}
@@ -4080,7 +4096,7 @@
// To indicate that this is an implicit constructor, we set the
// token position and end token position of the function
// to the token position of the class.
- Function& ctor = Function::Handle(
+ Function& ctor = Function::Handle(isolate(),
Function::New(ctor_name,
RawFunction::kConstructor,
/* is_static = */ false,
@@ -4154,13 +4170,14 @@
OS::Print("toplevel parsing mixin application alias class '%s'\n",
class_name.ToCString());
}
- const Object& obj = Object::Handle(library_.LookupLocalObject(class_name));
+ const Object& obj = Object::Handle(isolate(),
+ library_.LookupLocalObject(class_name));
if (!obj.IsNull()) {
ErrorMsg(classname_pos, "'%s' is already defined",
class_name.ToCString());
}
const Class& mixin_application =
- Class::Handle(Class::New(class_name, script_, classname_pos));
+ Class::Handle(isolate(), Class::New(class_name, script_, classname_pos));
mixin_application.set_is_mixin_app_alias();
library_.AddClass(mixin_application);
set_current_class(mixin_application);
@@ -4175,12 +4192,13 @@
const intptr_t type_pos = TokenPos();
AbstractType& type =
- AbstractType::Handle(ParseType(ClassFinalizer::kResolveTypeParameters));
+ AbstractType::Handle(isolate(),
+ ParseType(ClassFinalizer::kResolveTypeParameters));
if (type.IsTypeParameter()) {
ErrorMsg(type_pos,
"class '%s' may not extend type parameter '%s'",
class_name.ToCString(),
- String::Handle(type.UserVisibleName()).ToCString());
+ String::Handle(isolate(), type.UserVisibleName()).ToCString());
}
CheckToken(Token::kWITH, "mixin application 'with Type' expected");
@@ -4258,7 +4276,7 @@
}
// Parse the result type of the function type.
- AbstractType& result_type = Type::Handle(Type::DynamicType());
+ AbstractType& result_type = Type::Handle(isolate(), Type::DynamicType());
if (CurrentToken() == Token::kVOID) {
ConsumeToken();
result_type = Type::VoidType();
@@ -4274,7 +4292,8 @@
// Lookup alias name and report an error if it is already defined in
// the library scope.
- const Object& obj = Object::Handle(library_.LookupLocalObject(*alias_name));
+ const Object& obj = Object::Handle(isolate(),
+ library_.LookupLocalObject(*alias_name));
if (!obj.IsNull()) {
ErrorMsg(alias_name_pos,
"'%s' is already defined", alias_name->ToCString());
@@ -4284,9 +4303,9 @@
// signature function after it has been parsed. The type parameters, in order
// to be properly finalized, need to be associated to this signature class as
// they are parsed.
- const Class& function_type_alias = Class::Handle(
+ const Class& function_type_alias = Class::Handle(isolate(),
Class::NewSignatureClass(*alias_name,
- Function::Handle(),
+ Function::Handle(isolate()),
script_,
alias_name_pos));
library_.AddClass(function_type_alias);
@@ -4314,7 +4333,7 @@
ParseFormalParameterList(no_explicit_default_values, false, &func_params);
ExpectSemicolon();
// The field 'is_static' has no meaning for signature functions.
- Function& signature_function = Function::Handle(
+ Function& signature_function = Function::Handle(isolate(),
Function::New(*alias_name,
RawFunction::kSignatureFunction,
/* is_static = */ false,
@@ -4330,7 +4349,8 @@
// Patch the signature function in the signature class.
function_type_alias.PatchSignatureFunction(signature_function);
- const String& signature = String::Handle(signature_function.Signature());
+ const String& signature = String::Handle(isolate(),
+ signature_function.Signature());
if (FLAG_trace_parser) {
OS::Print("TopLevel parsing function type alias '%s'\n",
signature.ToCString());
@@ -4443,12 +4463,12 @@
TRACE_PARSER("ParseTypeParameters");
if (CurrentToken() == Token::kLT) {
const GrowableObjectArray& type_parameters_array =
- GrowableObjectArray::Handle(GrowableObjectArray::New());
+ GrowableObjectArray::Handle(isolate(), GrowableObjectArray::New());
intptr_t index = 0;
- TypeParameter& type_parameter = TypeParameter::Handle();
- TypeParameter& existing_type_parameter = TypeParameter::Handle();
- String& existing_type_parameter_name = String::Handle();
- AbstractType& type_parameter_bound = Type::Handle();
+ TypeParameter& type_parameter = TypeParameter::Handle(isolate());
+ TypeParameter& existing_type_parameter = TypeParameter::Handle(isolate());
+ String& existing_type_parameter_name = String::Handle(isolate());
+ AbstractType& type_parameter_bound = Type::Handle(isolate());
do {
ConsumeToken();
const intptr_t metadata_pos = SkipMetadata();
@@ -4492,7 +4512,8 @@
ErrorMsg("right angle bracket expected");
}
const TypeArguments& type_parameters =
- TypeArguments::Handle(NewTypeArguments(type_parameters_array));
+ TypeArguments::Handle(isolate(),
+ NewTypeArguments(type_parameters_array));
cls.set_type_parameters(type_parameters);
// Try to resolve the upper bounds, which will at least resolve the
// referenced type parameters.
@@ -4514,8 +4535,8 @@
TRACE_PARSER("ParseTypeArguments");
if (CurrentToken() == Token::kLT) {
const GrowableObjectArray& types =
- GrowableObjectArray::Handle(GrowableObjectArray::New());
- AbstractType& type = AbstractType::Handle();
+ GrowableObjectArray::Handle(isolate(), GrowableObjectArray::New());
+ AbstractType& type = AbstractType::Handle(isolate());
do {
ConsumeToken();
type = ParseType(finalization);
@@ -4544,10 +4565,10 @@
TRACE_PARSER("ParseInterfaceList");
ASSERT(CurrentToken() == Token::kIMPLEMENTS);
const GrowableObjectArray& all_interfaces =
- GrowableObjectArray::Handle(GrowableObjectArray::New());
- AbstractType& interface = AbstractType::Handle();
+ GrowableObjectArray::Handle(isolate(), GrowableObjectArray::New());
+ AbstractType& interface = AbstractType::Handle(isolate());
// First get all the interfaces already implemented by class.
- Array& cls_interfaces = Array::Handle(cls.interfaces());
+ Array& cls_interfaces = Array::Handle(isolate(), cls.interfaces());
for (intptr_t i = 0; i < cls_interfaces.Length(); i++) {
interface ^= cls_interfaces.At(i);
all_interfaces.Add(interface);
@@ -4560,7 +4581,8 @@
if (interface.IsTypeParameter()) {
ErrorMsg(interface_pos,
"type parameter '%s' may not be used in interface list",
- String::Handle(interface.UserVisibleName()).ToCString());
+ String::Handle(isolate(),
+ interface.UserVisibleName()).ToCString());
}
all_interfaces.Add(interface);
} while (CurrentToken() == Token::kCOMMA);
@@ -4573,8 +4595,8 @@
TRACE_PARSER("ParseMixins");
ASSERT(CurrentToken() == Token::kWITH);
const GrowableObjectArray& mixin_types =
- GrowableObjectArray::Handle(GrowableObjectArray::New());
- AbstractType& mixin_type = AbstractType::Handle();
+ GrowableObjectArray::Handle(isolate(), GrowableObjectArray::New());
+ AbstractType& mixin_type = AbstractType::Handle(isolate());
do {
ConsumeToken();
mixin_type = ParseType(ClassFinalizer::kResolveTypeParameters);
@@ -4586,12 +4608,13 @@
if (mixin_type.IsTypeParameter()) {
ErrorMsg(mixin_type.token_pos(),
"mixin type '%s' may not be a type parameter",
- String::Handle(mixin_type.UserVisibleName()).ToCString());
+ String::Handle(isolate(),
+ mixin_type.UserVisibleName()).ToCString());
}
mixin_types.Add(mixin_type);
} while (CurrentToken() == Token::kCOMMA);
return MixinAppType::New(super_type,
- Array::Handle(Array::MakeArray(mixin_types)));
+ Array::Handle(isolate(), Array::MakeArray(mixin_types)));
}
@@ -4604,8 +4627,8 @@
const bool is_static = true;
const AbstractType& type = AbstractType::ZoneHandle(ParseConstFinalVarOrType(
ClassFinalizer::kResolveTypeParameters));
- Field& field = Field::Handle();
- Function& getter = Function::Handle();
+ Field& field = Field::Handle(isolate());
+ Function& getter = Function::Handle(isolate());
while (true) {
const intptr_t name_pos = TokenPos();
String& var_name = *ExpectIdentifier("variable name expected");
@@ -4618,7 +4641,8 @@
// or final field implies a setter which throws a NoSuchMethodError,
// thus we need to check for conflicts with existing setters and
// getters.
- String& accessor_name = String::Handle(Field::GetterName(var_name));
+ String& accessor_name = String::Handle(isolate(),
+ Field::GetterName(var_name));
if (library_.LookupLocalObject(accessor_name) != Object::null()) {
ErrorMsg(name_pos, "getter for '%s' is already defined",
var_name.ToCString());
@@ -4632,7 +4656,7 @@
field = Field::New(var_name, is_static, is_final, is_const,
current_class(), name_pos);
field.set_type(type);
- field.set_value(Instance::Handle(Instance::null()));
+ field.set_value(Instance::Handle(isolate(), Instance::null()));
top_level->fields.Add(field);
library_.AddObject(field, var_name);
if (metadata_pos >= 0) {
@@ -4640,7 +4664,8 @@
}
if (CurrentToken() == Token::kASSIGN) {
ConsumeToken();
- Instance& field_value = Instance::Handle(Object::sentinel().raw());
+ Instance& field_value = Instance::Handle(isolate(),
+ Object::sentinel().raw());
bool has_simple_literal = false;
if (LookaheadToken(1) == Token::kSEMICOLON) {
has_simple_literal = IsSimpleLiteral(type, &field_value);
@@ -4649,7 +4674,8 @@
field.set_value(field_value);
if (!has_simple_literal) {
// Create a static final getter.
- String& getter_name = String::Handle(Field::GetterSymbol(var_name));
+ String& getter_name = String::Handle(isolate(),
+ Field::GetterSymbol(var_name));
getter = Function::New(getter_name,
RawFunction::kImplicitStaticFinalGetter,
is_static,
@@ -4689,7 +4715,7 @@
intptr_t metadata_pos) {
TRACE_PARSER("ParseTopLevelFunction");
const intptr_t decl_begin_pos = TokenPos();
- AbstractType& result_type = Type::Handle(Type::DynamicType());
+ AbstractType& result_type = Type::Handle(isolate(), Type::DynamicType());
const bool is_static = true;
bool is_external = false;
bool is_patch = false;
@@ -4722,7 +4748,8 @@
} else if (!found && is_patch) {
ErrorMsg(name_pos, "missing '%s' cannot be patched", func_name.ToCString());
}
- String& accessor_name = String::Handle(Field::GetterName(func_name));
+ String& accessor_name = String::Handle(isolate(),
+ Field::GetterName(func_name));
if (library_.LookupLocalObject(accessor_name) != Object::null()) {
ErrorMsg(name_pos, "'%s' is already defined as getter",
func_name.ToCString());
@@ -4758,7 +4785,7 @@
} else {
ErrorMsg("function block expected");
}
- Function& func = Function::Handle(
+ Function& func = Function::Handle(isolate(),
Function::New(func_name,
RawFunction::kRegularFunction,
is_static,
@@ -4793,7 +4820,7 @@
const bool is_static = true;
bool is_external = false;
bool is_patch = false;
- AbstractType& result_type = AbstractType::Handle();
+ AbstractType& result_type = AbstractType::Handle(isolate());
if (is_patch_source() &&
(CurrentToken() == Token::kIDENT) &&
CurrentLiteral()->Equals("patch")) {
@@ -4894,7 +4921,7 @@
} else {
ErrorMsg("function block expected");
}
- Function& func = Function::Handle(
+ Function& func = Function::Handle(isolate(),
Function::New(accessor_name,
is_getter ? RawFunction::kGetterFunction :
RawFunction::kSetterFunction,
@@ -4948,7 +4975,7 @@
if (Dart_IsError(result)) {
// In case of an error we append an explanatory error message to the
// error obtained from the library tag handler.
- Error& prev_error = Error::Handle();
+ Error& prev_error = Error::Handle(isolate());
prev_error ^= Api::UnwrapHandle(result);
AppendErrorMsg(prev_error, token_pos, "library handler failed");
}
@@ -5014,7 +5041,7 @@
ConsumeToken();
CheckToken(Token::kAS, "'as' expected");
}
- String& prefix = String::Handle();
+ String& prefix = String::Handle(isolate());
intptr_t prefix_pos = 0;
if (is_import && (CurrentToken() == Token::kAS)) {
ConsumeToken();
@@ -5022,13 +5049,13 @@
prefix = ExpectIdentifier("prefix identifier expected")->raw();
}
- Array& show_names = Array::Handle();
- Array& hide_names = Array::Handle();
+ Array& show_names = Array::Handle(isolate());
+ Array& hide_names = Array::Handle(isolate());
if (is_deferred_import || IsLiteral("show") || IsLiteral("hide")) {
GrowableObjectArray& show_list =
- GrowableObjectArray::Handle(GrowableObjectArray::New());
+ GrowableObjectArray::Handle(isolate(), GrowableObjectArray::New());
GrowableObjectArray& hide_list =
- GrowableObjectArray::Handle(GrowableObjectArray::New());
+ GrowableObjectArray::Handle(isolate(), GrowableObjectArray::New());
// Libraries imported through deferred import automatically hide
// the name 'loadLibrary'.
if (is_deferred_import) {
@@ -5058,7 +5085,8 @@
const String& canon_url = String::CheckedHandle(
CallLibraryTagHandler(Dart_kCanonicalizeUrl, import_pos, url));
// Lookup the library URL.
- Library& library = Library::Handle(Library::LookupLibrary(canon_url));
+ Library& library = Library::Handle(isolate(),
+ Library::LookupLibrary(canon_url));
if (library.IsNull()) {
// Create an empty library to mark that we have initiated loading of this
// library.
@@ -5069,8 +5097,8 @@
CallLibraryTagHandler(Dart_kImportTag, import_pos, canon_url);
}
- Namespace& ns =
- Namespace::Handle(Namespace::New(library, show_names, hide_names));
+ Namespace& ns = Namespace::Handle(isolate(),
+ Namespace::New(library, show_names, hide_names));
if (metadata_pos >= 0) {
ns.AddMetadata(metadata_pos, current_class());
}
@@ -5078,7 +5106,7 @@
if (is_import) {
// Ensure that private dart:_ libraries are only imported into dart:
// libraries.
- const String& lib_url = String::Handle(library_.url());
+ const String& lib_url = String::Handle(isolate(), library_.url());
if (canon_url.StartsWith(Symbols::DartSchemePrivate()) &&
!lib_url.StartsWith(Symbols::DartScheme())) {
ErrorMsg(import_pos, "private library is not accessible");
@@ -5087,7 +5115,7 @@
ASSERT(!is_deferred_import);
library_.AddImport(ns);
} else {
- LibraryPrefix& library_prefix = LibraryPrefix::Handle();
+ LibraryPrefix& library_prefix = LibraryPrefix::Handle(isolate());
library_prefix = library_.LookupLocalLibraryPrefix(prefix);
if (!library_prefix.IsNull()) {
// Check that prefix names of deferred import clauses are
@@ -5165,9 +5193,9 @@
// Core lib has not been explicitly imported, so we implicitly
// import it here.
if (!library_.ImportsCorelib()) {
- Library& core_lib = Library::Handle(Library::CoreLibrary());
+ Library& core_lib = Library::Handle(isolate(), Library::CoreLibrary());
ASSERT(!core_lib.IsNull());
- const Namespace& core_ns = Namespace::Handle(
+ const Namespace& core_ns = Namespace::Handle(isolate(),
Namespace::New(core_lib, Object::null_array(), Object::null_array()));
library_.AddImport(core_ns);
}
@@ -5210,7 +5238,7 @@
SetPosition(0);
is_top_level_ = true;
TopLevel top_level;
- Class& toplevel_class = Class::Handle(
+ Class& toplevel_class = Class::Handle(isolate(),
Class::New(Symbols::TopLevel(), script_, TokenPos()));
toplevel_class.set_library(library_);
@@ -5255,7 +5283,8 @@
if ((top_level.fields.Length() > 0) || (top_level.functions.Length() > 0)) {
toplevel_class.AddFields(top_level.fields);
- const Array& array = Array::Handle(Array::MakeArray(top_level.functions));
+ const Array& array = Array::Handle(isolate(),
+ Array::MakeArray(top_level.functions));
toplevel_class.SetFunctions(array);
library_.AddAnonymousClass(toplevel_class);
@@ -5265,9 +5294,10 @@
void Parser::ChainNewBlock(LocalScope* outer_scope) {
- Block* block = new Block(current_block_,
- outer_scope,
- new SequenceNode(TokenPos(), outer_scope));
+ Block* block = new(isolate()) Block(
+ current_block_,
+ outer_scope,
+ new(isolate()) SequenceNode(TokenPos(), outer_scope));
current_block_ = block;
}
@@ -5275,18 +5305,18 @@
void Parser::OpenBlock() {
ASSERT(current_block_ != NULL);
LocalScope* outer_scope = current_block_->scope;
- ChainNewBlock(new LocalScope(outer_scope,
- outer_scope->function_level(),
- outer_scope->loop_level()));
+ ChainNewBlock(new(isolate()) LocalScope(
+ outer_scope, outer_scope->function_level(), outer_scope->loop_level()));
}
void Parser::OpenLoopBlock() {
ASSERT(current_block_ != NULL);
LocalScope* outer_scope = current_block_->scope;
- ChainNewBlock(new LocalScope(outer_scope,
- outer_scope->function_level(),
- outer_scope->loop_level() + 1));
+ ChainNewBlock(new(isolate()) LocalScope(
+ outer_scope,
+ outer_scope->function_level(),
+ outer_scope->loop_level() + 1));
}
@@ -5390,7 +5420,7 @@
ParamDesc& param_desc = (*params->parameters)[i];
ASSERT(!is_top_level_ || param_desc.type->IsResolved());
const String* name = param_desc.name;
- LocalVariable* parameter = new LocalVariable(
+ LocalVariable* parameter = new(isolate()) LocalVariable(
param_desc.name_pos, *name, *param_desc.type);
if (!scope->InsertParameterAt(i, parameter)) {
ErrorMsg(param_desc.name_pos,
@@ -5413,8 +5443,8 @@
const Function& func) {
ASSERT(func.is_native());
TRACE_PARSER("ParseNativeFunctionBlock");
- const Class& cls = Class::Handle(func.Owner());
- const Library& library = Library::Handle(cls.library());
+ const Class& cls = Class::Handle(isolate(), func.Owner());
+ const Library& library = Library::Handle(isolate(), cls.library());
ASSERT(func.NumParameters() == params->parameters->length());
// Parse the function name out.
@@ -5436,14 +5466,14 @@
// Now add the NativeBodyNode and return statement.
Dart_NativeEntryResolver resolver = library.native_entry_resolver();
bool is_bootstrap_native = Bootstrap::IsBootstapResolver(resolver);
- current_block_->statements->Add(
- new ReturnNode(TokenPos(),
- new NativeBodyNode(TokenPos(),
- Function::ZoneHandle(func.raw()),
- native_name,
- native_function,
- current_block_->scope,
- is_bootstrap_native)));
+ current_block_->statements->Add(new(isolate()) ReturnNode(
+ TokenPos(), new(isolate()) NativeBodyNode(
+ TokenPos(),
+ Function::ZoneHandle(func.raw()),
+ native_name,
+ native_function,
+ current_block_->scope,
+ is_bootstrap_native)));
}
@@ -5489,7 +5519,7 @@
if (receiver == NULL) {
ErrorMsg(token_pos, "illegal implicit access to receiver 'this'");
}
- return new LoadLocalNode(TokenPos(), receiver);
+ return new(isolate()) LoadLocalNode(TokenPos(), receiver);
}
@@ -5501,14 +5531,14 @@
LocalVariable* param = LookupTypeArgumentsParameter(current_block_->scope,
kTestOnly);
ASSERT(param != NULL);
- return new LoadLocalNode(TokenPos(), param);
+ return new(isolate()) LoadLocalNode(TokenPos(), param);
}
AstNode* Parser::CallGetter(intptr_t token_pos,
AstNode* object,
const String& name) {
- return new InstanceGetterNode(token_pos, object, name);
+ return new(isolate()) InstanceGetterNode(token_pos, object, name);
}
@@ -5520,7 +5550,8 @@
ASSERT(IsIdentifier());
const intptr_t ident_pos = TokenPos();
const String& ident = *CurrentLiteral();
- LocalVariable* variable = new LocalVariable(ident_pos, ident, type);
+ LocalVariable* variable = new(isolate()) LocalVariable(
+ ident_pos, ident, type);
ConsumeToken(); // Variable identifier.
AstNode* initialization = NULL;
if (CurrentToken() == Token::kASSIGN) {
@@ -5528,7 +5559,8 @@
const intptr_t assign_pos = TokenPos();
ConsumeToken();
AstNode* expr = ParseExpr(is_const, kConsumeCascades);
- initialization = new StoreLocalNode(assign_pos, variable, expr);
+ initialization = new(isolate()) StoreLocalNode(
+ assign_pos, variable, expr);
if (is_const) {
ASSERT(expr->IsLiteralNode());
variable->SetConstValue(expr->AsLiteralNode()->literal());
@@ -5538,8 +5570,10 @@
"missing initialization of 'final' or 'const' variable");
} else {
// Initialize variable with null.
- AstNode* null_expr = new LiteralNode(ident_pos, Instance::ZoneHandle());
- initialization = new StoreLocalNode(ident_pos, variable, null_expr);
+ AstNode* null_expr = new(isolate()) LiteralNode(
+ ident_pos, Instance::ZoneHandle());
+ initialization = new(isolate()) StoreLocalNode(
+ ident_pos, variable, null_expr);
}
ASSERT(current_block_ != NULL);
@@ -5658,7 +5692,7 @@
AstNode* Parser::ParseFunctionStatement(bool is_literal) {
TRACE_PARSER("ParseFunctionStatement");
- AbstractType& result_type = AbstractType::Handle();
+ AbstractType& result_type = AbstractType::Handle(isolate());
const String* variable_name = NULL;
const String* function_name = NULL;
@@ -5732,15 +5766,15 @@
// function is parsed. Therefore, we set the function type to a new
// parameterized type to be patched after the actual type is known.
// We temporarily use the class of the Function interface.
- const Class& unknown_signature_class = Class::Handle(
- Type::Handle(Type::Function()).type_class());
- function_type = Type::New(
- unknown_signature_class, TypeArguments::Handle(), function_pos);
+ const Class& unknown_signature_class = Class::Handle(isolate(),
+ Type::Handle(isolate(), Type::Function()).type_class());
+ function_type = Type::New(unknown_signature_class,
+ TypeArguments::Handle(isolate()), function_pos);
function_type.SetIsFinalized(); // No finalization needed.
// Add the function variable to the scope before parsing the function in
// order to allow self reference from inside the function.
- function_variable = new LocalVariable(function_pos,
+ function_variable = new(isolate()) LocalVariable(function_pos,
*variable_name,
function_type);
function_variable->set_is_final();
@@ -5763,14 +5797,14 @@
}
// Parse the local function.
- Array& default_parameter_values = Array::Handle();
+ Array& default_parameter_values = Array::Handle(isolate());
SequenceNode* statements = Parser::ParseFunc(function,
&default_parameter_values);
// Now that the local function has formal parameters, lookup the signature
// class in the current library (but not in its imports) and only create a new
// canonical signature class if it does not exist yet.
- const String& signature = String::Handle(function.Signature());
+ const String& signature = String::Handle(isolate(), function.Signature());
Class& signature_class = Class::ZoneHandle();
if (!is_new_closure) {
signature_class = function.signature_class();
@@ -5806,9 +5840,10 @@
// Since the signature type is cached by the signature class, it may have
// been finalized already.
- Type& signature_type = Type::Handle(signature_class.SignatureType());
- TypeArguments& signature_type_arguments =
- TypeArguments::Handle(signature_type.arguments());
+ Type& signature_type = Type::Handle(isolate(),
+ signature_class.SignatureType());
+ TypeArguments& signature_type_arguments = TypeArguments::Handle(isolate(),
+ signature_type.arguments());
if (!signature_type.IsFinalized()) {
signature_type ^= ClassFinalizer::FinalizeType(
@@ -5863,15 +5898,15 @@
// variables are not relevant for the compilation of the enclosing function.
// This pruning is done by omitting to hook the local scope in its parent
// scope in the constructor of LocalScope.
- AstNode* closure =
- new ClosureNode(function_pos, function, NULL, statements->scope());
+ AstNode* closure = new(isolate()) ClosureNode(
+ function_pos, function, NULL, statements->scope());
if (function_variable == NULL) {
ASSERT(is_literal);
return closure;
} else {
- AstNode* initialization =
- new StoreLocalNode(function_pos, function_variable, closure);
+ AstNode* initialization = new(isolate()) StoreLocalNode(
+ function_pos, function_variable, closure);
return initialization;
}
}
@@ -6256,7 +6291,8 @@
ConsumeToken();
false_branch = ParseNestedStatement(parsing_loop_body, NULL);
}
- AstNode* if_node = new IfNode(if_pos, cond_expr, true_branch, false_branch);
+ AstNode* if_node = new(isolate()) IfNode(
+ if_pos, cond_expr, true_branch, false_branch);
if (label != NULL) {
current_block_->statements->Add(if_node);
SequenceNode* sequence = CloseBlock();
@@ -6323,9 +6359,9 @@
}
}
if (first_value.IsInteger()) {
- return Type::Handle(Type::IntType()).type_class();
+ return Type::Handle(isolate(), Type::IntType()).type_class();
} else if (first_value.IsString()) {
- return Type::Handle(Type::StringType()).type_class();
+ return Type::Handle(isolate(), Type::StringType()).type_class();
}
return first_value.clazz();
}
@@ -6338,7 +6374,7 @@
bool default_seen = false;
const intptr_t case_pos = TokenPos();
// The case expressions node sequence does not own the enclosing scope.
- SequenceNode* case_expressions = new SequenceNode(case_pos, NULL);
+ SequenceNode* case_expressions = new(isolate()) SequenceNode(case_pos, NULL);
while (CurrentToken() == Token::kCASE || CurrentToken() == Token::kDEFAULT) {
if (CurrentToken() == Token::kCASE) {
if (default_seen) {
@@ -6350,12 +6386,10 @@
ASSERT(expr->IsLiteralNode());
case_expr_values->Add(expr->AsLiteralNode());
- AstNode* switch_expr_load = new LoadLocalNode(case_pos,
- switch_expr_value);
- AstNode* case_comparison = new ComparisonNode(expr_pos,
- Token::kEQ,
- expr,
- switch_expr_load);
+ AstNode* switch_expr_load = new(isolate()) LoadLocalNode(
+ case_pos, switch_expr_value);
+ AstNode* case_comparison = new(isolate()) ComparisonNode(
+ expr_pos, Token::kEQ, expr, switch_expr_load);
case_expressions->Add(case_comparison);
} else {
if (default_seen) {
@@ -6388,8 +6422,9 @@
// End of this case clause. If there is a possible fall-through to
// the next case clause, throw an implicit FallThroughError.
if (!abrupt_completing_seen) {
- ArgumentListNode* arguments = new ArgumentListNode(TokenPos());
- arguments->Add(new LiteralNode(
+ ArgumentListNode* arguments = new(isolate()) ArgumentListNode(
+ TokenPos());
+ arguments->Add(new(isolate()) LiteralNode(
TokenPos(), Integer::ZoneHandle(Integer::New(TokenPos()))));
current_block_->statements->Add(
MakeStaticCall(Symbols::FallThroughError(),
@@ -6406,7 +6441,7 @@
}
}
SequenceNode* statements = CloseBlock();
- return new CaseNode(case_pos, case_label,
+ return new(isolate()) CaseNode(case_pos, case_label,
case_expressions, default_seen, switch_expr_value, statements);
}
@@ -6431,16 +6466,16 @@
// type of the case clause expressions. Therefore, we have to allocate
// a new type representing dynamic and can't reuse the canonical
// type object for dynamic.
- const Type& temp_var_type =
- Type::ZoneHandle(Type::New(Class::Handle(Object::dynamic_class()),
- TypeArguments::Handle(),
- expr_pos));
+ const Type& temp_var_type = Type::ZoneHandle(isolate(),
+ Type::New(Class::Handle(isolate(), Object::dynamic_class()),
+ TypeArguments::Handle(isolate()),
+ expr_pos));
temp_var_type.SetIsFinalized();
- LocalVariable* temp_variable =
- new LocalVariable(expr_pos, Symbols::SwitchExpr(), temp_var_type);
+ LocalVariable* temp_variable = new(isolate()) LocalVariable(
+ expr_pos, Symbols::SwitchExpr(), temp_var_type);
current_block_->scope->AddVariable(temp_variable);
- AstNode* save_switch_expr =
- new StoreLocalNode(expr_pos, temp_variable, switch_expr);
+ AstNode* save_switch_expr = new(isolate()) StoreLocalNode(
+ expr_pos, temp_variable, switch_expr);
current_block_->statements->Add(save_switch_expr);
// Parse case clauses
@@ -6458,8 +6493,8 @@
case_label = current_block_->scope->LocalLookupLabel(*label_name);
if (case_label == NULL) {
// Label does not exist yet. Add it to scope of switch statement.
- case_label =
- new SourceLabel(label_pos, *label_name, SourceLabel::kCase);
+ case_label = new(isolate()) SourceLabel(
+ label_pos, *label_name, SourceLabel::kCase);
current_block_->scope->AddLabel(case_label);
} else if (case_label->kind() == SourceLabel::kForward) {
// We have seen a 'continue' with this label name. Resolve
@@ -6494,7 +6529,7 @@
// variable holding the switch expression to match the type of the
// case clause constants.
temp_var_type.set_type_class(
- Class::Handle(CheckCaseExpressions(case_expr_values)));
+ Class::Handle(isolate(), CheckCaseExpressions(case_expr_values)));
// Check for unresolved label references.
SourceLabel* unresolved_label =
@@ -6506,7 +6541,7 @@
SequenceNode* switch_body = CloseBlock();
ExpectToken(Token::kRBRACE);
- return new SwitchNode(switch_pos, label, switch_body);
+ return new(isolate()) SwitchNode(switch_pos, label, switch_body);
}
@@ -6521,7 +6556,7 @@
ExpectToken(Token::kRPAREN);
const bool parsing_loop_body = true;
SequenceNode* while_body = ParseNestedStatement(parsing_loop_body, label);
- return new WhileNode(while_pos, label, cond_expr, while_body);
+ return new(isolate()) WhileNode(while_pos, label, cond_expr, while_body);
}
@@ -6538,7 +6573,7 @@
AstNode* cond_expr = ParseExpr(kAllowConst, kConsumeCascades);
ExpectToken(Token::kRPAREN);
ExpectSemicolon();
- return new DoWhileNode(do_pos, label, cond_expr, dowhile_body);
+ return new(isolate()) DoWhileNode(do_pos, label, cond_expr, dowhile_body);
}
@@ -6563,7 +6598,7 @@
ClassFinalizer::kIgnore));
loop_var_pos = TokenPos();
loop_var_name = ExpectIdentifier("variable name expected");
- loop_var = new LocalVariable(loop_var_pos, *loop_var_name, type);
+ loop_var = new(isolate()) LocalVariable(loop_var_pos, *loop_var_name, type);
if (is_final) {
loop_var->set_is_final();
}
@@ -6582,22 +6617,22 @@
// It is better to leave the iterator untyped and postpone the type error
// until the loop variable is assigned to.
const AbstractType& iterator_type = Type::ZoneHandle(Type::DynamicType());
- LocalVariable* iterator_var =
- new LocalVariable(collection_pos, Symbols::ForInIter(), iterator_type);
+ LocalVariable* iterator_var = new(isolate()) LocalVariable(
+ collection_pos, Symbols::ForInIter(), iterator_type);
current_block_->scope->AddVariable(iterator_var);
// Generate initialization of iterator variable.
- ArgumentListNode* no_args = new ArgumentListNode(collection_pos);
- AstNode* get_iterator = new InstanceGetterNode(
+ ArgumentListNode* no_args = new(isolate()) ArgumentListNode(collection_pos);
+ AstNode* get_iterator = new(isolate()) InstanceGetterNode(
collection_pos, collection_expr, Symbols::GetIterator());
AstNode* iterator_init =
- new StoreLocalNode(collection_pos, iterator_var, get_iterator);
+ new(isolate()) StoreLocalNode(collection_pos, iterator_var, get_iterator);
current_block_->statements->Add(iterator_init);
// Generate while loop condition.
- AstNode* iterator_moveNext = new InstanceCallNode(
+ AstNode* iterator_moveNext = new(isolate()) InstanceCallNode(
collection_pos,
- new LoadLocalNode(collection_pos, iterator_var),
+ new(isolate()) LoadLocalNode(collection_pos, iterator_var),
Symbols::MoveNext(),
no_args);
@@ -6608,9 +6643,9 @@
OpenLoopBlock();
current_block_->scope->AddLabel(label);
- AstNode* iterator_current = new InstanceGetterNode(
+ AstNode* iterator_current = new(isolate()) InstanceGetterNode(
collection_pos,
- new LoadLocalNode(collection_pos, iterator_var),
+ new(isolate()) LoadLocalNode(collection_pos, iterator_var),
Symbols::Current());
// Generate assignment of next iterator value to loop variable.
@@ -6619,7 +6654,7 @@
// The for loop declares a new variable. Add it to the loop body scope.
current_block_->scope->AddVariable(loop_var);
loop_var_assignment =
- new StoreLocalNode(loop_var_pos, loop_var, iterator_current);
+ new(isolate()) StoreLocalNode(loop_var_pos, loop_var, iterator_current);
} else {
AstNode* loop_var_primary =
ResolveIdent(loop_var_pos, *loop_var_name, false);
@@ -6644,8 +6679,8 @@
SequenceNode* for_loop_statement = CloseBlock();
- AstNode* while_statement =
- new WhileNode(forin_pos, label, iterator_moveNext, for_loop_statement);
+ AstNode* while_statement = new(isolate()) WhileNode(
+ forin_pos, label, iterator_moveNext, for_loop_statement);
current_block_->statements->Add(while_statement);
return CloseBlock(); // Implicit block around while loop.
@@ -6696,8 +6731,8 @@
for (int i = 0; i < init_scope->num_variables(); i++) {
if (init_scope->VariableAt(i)->is_captured() &&
(init_scope->VariableAt(i)->owner() == init_scope)) {
- SequenceNode* incr_sequence = new SequenceNode(incr_pos, NULL);
- incr_sequence->Add(new CloneContextNode(for_pos));
+ SequenceNode* incr_sequence = new(isolate()) SequenceNode(incr_pos, NULL);
+ incr_sequence->Add(new(isolate()) CloneContextNode(for_pos));
if (increment != NULL) {
incr_sequence->Add(increment);
}
@@ -6706,7 +6741,7 @@
}
}
AstNode* for_node =
- new ForNode(for_pos,
+ new(isolate()) ForNode(for_pos,
label,
NodeAsSequenceNode(init_pos, initializer, NULL),
condition,
@@ -6721,7 +6756,8 @@
AstNode* Parser::MakeStaticCall(const String& cls_name,
const String& func_name,
ArgumentListNode* arguments) {
- const Class& cls = Class::Handle(Library::LookupCoreClass(cls_name));
+ const Class& cls = Class::Handle(isolate(),
+ Library::LookupCoreClass(cls_name));
ASSERT(!cls.IsNull());
const Function& func = Function::ZoneHandle(
Resolver::ResolveStatic(cls,
@@ -6729,15 +6765,15 @@
arguments->length(),
arguments->names()));
ASSERT(!func.IsNull());
- return new StaticCallNode(arguments->token_pos(), func, arguments);
+ return new(isolate()) StaticCallNode(arguments->token_pos(), func, arguments);
}
AstNode* Parser::MakeAssertCall(intptr_t begin, intptr_t end) {
- ArgumentListNode* arguments = new ArgumentListNode(begin);
- arguments->Add(new LiteralNode(begin,
+ ArgumentListNode* arguments = new(isolate()) ArgumentListNode(begin);
+ arguments->Add(new(isolate()) LiteralNode(begin,
Integer::ZoneHandle(Integer::New(begin))));
- arguments->Add(new LiteralNode(end,
+ arguments->Add(new(isolate()) LiteralNode(end,
Integer::ZoneHandle(Integer::New(end))));
return MakeStaticCall(Symbols::AssertionError(),
Library::PrivateCoreLibName(Symbols::ThrowNew()),
@@ -6751,7 +6787,9 @@
condition->AsStoreLocalNode()->value()->IsClosureNode())) {
// Function literal in assert implies a call.
const intptr_t pos = condition->token_pos();
- condition = BuildClosureCall(pos, condition, new ArgumentListNode(pos));
+ condition = BuildClosureCall(pos,
+ condition,
+ new(isolate()) ArgumentListNode(pos));
} else if (condition->IsConditionalExprNode()) {
ConditionalExprNode* cond_expr = condition->AsConditionalExprNode();
cond_expr->set_true_expr(InsertClosureCallNodes(cond_expr->true_expr()));
@@ -6775,12 +6813,13 @@
const intptr_t condition_end = TokenPos();
ExpectToken(Token::kRPAREN);
condition = InsertClosureCallNodes(condition);
- condition = new UnaryOpNode(condition_pos, Token::kNOT, condition);
+ condition = new(isolate()) UnaryOpNode(condition_pos, Token::kNOT, condition);
AstNode* assert_throw = MakeAssertCall(condition_pos, condition_end);
- return new IfNode(condition_pos,
- condition,
- NodeAsSequenceNode(condition_pos, assert_throw, NULL),
- NULL);
+ return new(isolate()) IfNode(
+ condition_pos,
+ condition,
+ NodeAsSequenceNode(condition_pos, assert_throw, NULL),
+ NULL);
}
@@ -6799,18 +6838,20 @@
CatchParamDesc* stack_trace_param,
LocalScope* scope) {
if (exception_param->name != NULL) {
- LocalVariable* var = new LocalVariable(exception_param->token_pos,
- *exception_param->name,
- *exception_param->type);
+ LocalVariable* var = new(isolate()) LocalVariable(
+ exception_param->token_pos,
+ *exception_param->name,
+ *exception_param->type);
var->set_is_final();
bool added_to_scope = scope->AddVariable(var);
ASSERT(added_to_scope);
exception_param->var = var;
}
if (stack_trace_param->name != NULL) {
- LocalVariable* var = new LocalVariable(stack_trace_param->token_pos,
- *stack_trace_param->name,
- *stack_trace_param->type);
+ LocalVariable* var = new(isolate()) LocalVariable(
+ stack_trace_param->token_pos,
+ *stack_trace_param->name,
+ *stack_trace_param->type);
var->set_is_final();
bool added_to_scope = scope->AddVariable(var);
if (!added_to_scope) {
@@ -6836,7 +6877,8 @@
void Parser::PushTryBlock(Block* try_block) {
intptr_t try_index = AllocateTryIndex();
- TryBlocks* block = new TryBlocks(try_block, try_blocks_list_, try_index);
+ TryBlocks* block = new(isolate()) TryBlocks(
+ try_block, try_blocks_list_, try_index);
try_blocks_list_ = block;
}
@@ -6951,26 +6993,25 @@
// Generate code to load the exception object (:exception_var) into
// the exception variable specified in this block.
ASSERT(exception_var != NULL);
- current_block_->statements->Add(
- new StoreLocalNode(catch_pos, exception_param.var,
- new LoadLocalNode(catch_pos, exception_var)));
+ current_block_->statements->Add(new(isolate()) StoreLocalNode(
+ catch_pos, exception_param.var, new(isolate()) LoadLocalNode(
+ catch_pos, exception_var)));
}
if (stack_trace_param.var != NULL) {
// A stack trace variable is specified in this block, so generate code
// to load the stack trace object (:stack_trace_var) into the stack
// trace variable specified in this block.
*needs_stack_trace = true;
- ArgumentListNode* no_args = new ArgumentListNode(catch_pos);
+ ArgumentListNode* no_args = new(isolate()) ArgumentListNode(catch_pos);
ASSERT(stack_trace_var != NULL);
- current_block_->statements->Add(
- new StoreLocalNode(catch_pos, stack_trace_param.var,
- new LoadLocalNode(catch_pos, stack_trace_var)));
- current_block_->statements->Add(
- new InstanceCallNode(
- catch_pos,
- new LoadLocalNode(catch_pos, stack_trace_param.var),
- Library::PrivateCoreLibName(Symbols::_setupFullStackTrace()),
- no_args));
+ current_block_->statements->Add(new(isolate()) StoreLocalNode(
+ catch_pos, stack_trace_param.var, new(isolate()) LoadLocalNode(
+ catch_pos, stack_trace_var)));
+ current_block_->statements->Add(new(isolate()) InstanceCallNode(
+ catch_pos,
+ new(isolate()) LoadLocalNode(catch_pos, stack_trace_param.var),
+ Library::PrivateCoreLibName(Symbols::_setupFullStackTrace()),
+ no_args));
}
// Add nested block with user-defined code. This blocks allows
@@ -6987,10 +7028,10 @@
// In the first case, unconditionally execute the catch body. In the
// second case, unconditionally throw.
generic_catch_seen = true;
- type_tests.Add(new LiteralNode(catch_pos, Bool::True()));
+ type_tests.Add(new(isolate()) LiteralNode(catch_pos, Bool::True()));
if (is_bad_type) {
// Replace the body with one that throws.
- SequenceNode* block = new SequenceNode(catch_pos, NULL);
+ SequenceNode* block = new(isolate()) SequenceNode(catch_pos, NULL);
block->Add(ThrowTypeError(catch_pos, *exception_param.type));
catch_blocks.Last() = block;
}
@@ -7006,13 +7047,15 @@
// Make sure that the instantiator is captured.
CaptureInstantiator();
}
- TypeNode* exception_type = new TypeNode(catch_pos, *exception_param.type);
- AstNode* exception_value = new LoadLocalNode(catch_pos, exception_var);
+ TypeNode* exception_type = new(isolate()) TypeNode(
+ catch_pos, *exception_param.type);
+ AstNode* exception_value = new(isolate()) LoadLocalNode(
+ catch_pos, exception_var);
if (!exception_type->type().IsInstantiated()) {
EnsureExpressionTemp();
}
- type_tests.Add(new ComparisonNode(catch_pos, Token::kIS, exception_value,
- exception_type));
+ type_tests.Add(new(isolate()) ComparisonNode(
+ catch_pos, Token::kIS, exception_value, exception_type));
// Do not add uninstantiated types (e.g. type parameter T or generic
// type List<T>), since the debugger won't be able to instantiate it
@@ -7039,11 +7082,11 @@
// There isn't a generic catch clause so create a clause body that
// rethrows the exception. This includes the case that there were no
// catch clauses.
- current = new SequenceNode(handler_pos, NULL);
- current->Add(
- new ThrowNode(handler_pos,
- new LoadLocalNode(handler_pos, exception_var),
- new LoadLocalNode(handler_pos, stack_trace_var)));
+ current = new(isolate()) SequenceNode(handler_pos, NULL);
+ current->Add(new(isolate()) ThrowNode(
+ handler_pos,
+ new(isolate()) LoadLocalNode(handler_pos, exception_var),
+ new(isolate()) LoadLocalNode(handler_pos, stack_trace_var)));
} else if (type_tests.Last()->IsLiteralNode()) {
ASSERT(type_tests.Last()->AsLiteralNode()->literal().raw() ==
Bool::True().raw());
@@ -7061,8 +7104,8 @@
while (!type_tests.is_empty()) {
AstNode* type_test = type_tests.RemoveLast();
SequenceNode* catch_block = catch_blocks.RemoveLast();
- current_block_->statements->Add(
- new IfNode(type_test->token_pos(), type_test, catch_block, current));
+ current_block_->statements->Add(new(isolate()) IfNode(
+ type_test->token_pos(), type_test, catch_block, current));
current = CloseBlock();
}
return current;
@@ -7088,25 +7131,28 @@
LocalVariable* context_var =
current_block_->scope->LocalLookupVariable(Symbols::SavedTryContextVar());
if (context_var == NULL) {
- context_var = new LocalVariable(TokenPos(),
- Symbols::SavedTryContextVar(),
- Type::ZoneHandle(Type::DynamicType()));
+ context_var = new(isolate()) LocalVariable(
+ TokenPos(),
+ Symbols::SavedTryContextVar(),
+ Type::ZoneHandle(Type::DynamicType()));
current_block_->scope->AddVariable(context_var);
}
LocalVariable* exception_var =
current_block_->scope->LocalLookupVariable(Symbols::ExceptionVar());
if (exception_var == NULL) {
- exception_var = new LocalVariable(TokenPos(),
- Symbols::ExceptionVar(),
- Type::ZoneHandle(Type::DynamicType()));
+ exception_var = new(isolate()) LocalVariable(
+ TokenPos(),
+ Symbols::ExceptionVar(),
+ Type::ZoneHandle(Type::DynamicType()));
current_block_->scope->AddVariable(exception_var);
}
LocalVariable* stack_trace_var =
current_block_->scope->LocalLookupVariable(Symbols::StackTraceVar());
if (stack_trace_var == NULL) {
- stack_trace_var = new LocalVariable(TokenPos(),
- Symbols::StackTraceVar(),
- Type::ZoneHandle(Type::DynamicType()));
+ stack_trace_var = new(isolate()) LocalVariable(
+ TokenPos(),
+ Symbols::StackTraceVar(),
+ Type::ZoneHandle(Type::DynamicType()));
current_block_->scope->AddVariable(stack_trace_var);
}
@@ -7137,7 +7183,7 @@
try_blocks_list_->enter_catch();
const intptr_t handler_pos = TokenPos();
const GrowableObjectArray& handler_types =
- GrowableObjectArray::Handle(GrowableObjectArray::New());
+ GrowableObjectArray::Handle(isolate(), GrowableObjectArray::New());
bool needs_stack_trace = false;
SequenceNode* catch_handler_list =
ParseCatchClauses(handler_pos, exception_var, stack_trace_var,
@@ -7161,7 +7207,7 @@
inner_try_block->GetNodeToInlineFinally(node_index);
while (node_to_inline != NULL) {
finally_block = ParseFinallyBlock();
- InlinedFinallyNode* node = new InlinedFinallyNode(finally_pos,
+ InlinedFinallyNode* node = new(isolate()) InlinedFinallyNode(finally_pos,
finally_block,
context_var,
outer_try_index);
@@ -7173,24 +7219,22 @@
finally_block = ParseFinallyBlock();
}
- CatchClauseNode* catch_clause =
- new CatchClauseNode(handler_pos,
- catch_handler_list,
- Array::ZoneHandle(Array::MakeArray(handler_types)),
- context_var,
- exception_var,
- stack_trace_var,
- (finally_block != NULL)
- ? AllocateTryIndex()
- : CatchClauseNode::kInvalidTryIndex,
- needs_stack_trace);
+ CatchClauseNode* catch_clause = new(isolate()) CatchClauseNode(
+ handler_pos,
+ catch_handler_list,
+ Array::ZoneHandle(Array::MakeArray(handler_types)),
+ context_var,
+ exception_var,
+ stack_trace_var,
+ (finally_block != NULL) ?
+ AllocateTryIndex() : CatchClauseNode::kInvalidTryIndex,
+ needs_stack_trace);
// Now create the try/catch ast node and return it. If there is a label
// on the try/catch, close the block that's embedding the try statement
// and attach the label to it.
- AstNode* try_catch_node =
- new TryCatchNode(try_pos, try_block, context_var, catch_clause,
- finally_block, try_index);
+ AstNode* try_catch_node = new(isolate()) TryCatchNode(
+ try_pos, try_block, context_var, catch_clause, finally_block, try_index);
if (try_label != NULL) {
current_block_->statements->Add(try_catch_node);
@@ -7231,7 +7275,7 @@
LocalScope* switch_scope = current_block_->scope->LookupSwitchScope();
if (switch_scope != NULL) {
// We found a switch scope. Enter a forward reference to the label.
- target = new SourceLabel(
+ target = new(isolate()) SourceLabel(
TokenPos(), target_name, SourceLabel::kForward);
switch_scope->AddLabel(target);
}
@@ -7261,7 +7305,7 @@
ErrorMsg(jump_pos, "'%s' target must be in same function context",
Token::Str(jump_kind));
}
- return new JumpNode(jump_pos, jump_kind, target);
+ return new(isolate()) JumpNode(jump_pos, jump_kind, target);
}
@@ -7301,9 +7345,9 @@
ErrorMsg(return_pos, "return of a value not allowed in constructors");
}
AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
- statement = new ReturnNode(statement_pos, expr);
+ statement = new(isolate()) ReturnNode(statement_pos, expr);
} else {
- statement = new ReturnNode(statement_pos);
+ statement = new(isolate()) ReturnNode(statement_pos);
}
AddNodeForFinallyInlining(statement);
ExpectSemicolon();
@@ -7360,9 +7404,10 @@
LocalVariable* trace_var =
scope->LocalLookupVariable(Symbols::StackTraceVar());
ASSERT(trace_var != NULL);
- statement = new ThrowNode(statement_pos,
- new LoadLocalNode(statement_pos, excp_var),
- new LoadLocalNode(statement_pos, trace_var));
+ statement = new(isolate()) ThrowNode(
+ statement_pos,
+ new(isolate()) LoadLocalNode(statement_pos, excp_var),
+ new(isolate()) LoadLocalNode(statement_pos, trace_var));
} else {
statement = ParseExpr(kAllowConst, kConsumeCascades);
ExpectSemicolon();
@@ -7374,8 +7419,8 @@
void Parser::ErrorMsg(intptr_t token_pos, const char* format, ...) const {
va_list args;
va_start(args, format);
- const Error& error = Error::Handle(LanguageError::NewFormattedV(
- Error::Handle(), script_, token_pos,
+ const Error& error = Error::Handle(isolate(), LanguageError::NewFormattedV(
+ Error::Handle(isolate()), script_, token_pos,
LanguageError::kError, Heap::kNew, format, args));
va_end(args);
isolate()->long_jump_base()->Jump(1, error);
@@ -7386,8 +7431,8 @@
void Parser::ErrorMsg(const char* format, ...) {
va_list args;
va_start(args, format);
- const Error& error = Error::Handle(LanguageError::NewFormattedV(
- Error::Handle(), script_, TokenPos(),
+ const Error& error = Error::Handle(isolate(), LanguageError::NewFormattedV(
+ Error::Handle(isolate()), script_, TokenPos(),
LanguageError::kError, Heap::kNew, format, args));
va_end(args);
isolate()->long_jump_base()->Jump(1, error);
@@ -7405,11 +7450,10 @@
const Error& prev_error, intptr_t token_pos, const char* format, ...) {
va_list args;
va_start(args, format);
- const Error& error = Error::Handle(
- LanguageError::NewFormattedV(
- prev_error, script_, token_pos,
- LanguageError::kError, Heap::kNew,
- format, args));
+ const Error& error = Error::Handle(isolate(), LanguageError::NewFormattedV(
+ prev_error, script_, token_pos,
+ LanguageError::kError, Heap::kNew,
+ format, args));
va_end(args);
isolate()->long_jump_base()->Jump(1, error);
UNREACHABLE();
@@ -7420,11 +7464,10 @@
if (FLAG_silent_warnings) return;
va_list args;
va_start(args, format);
- const Error& error = Error::Handle(
- LanguageError::NewFormattedV(
- Error::Handle(), script_, token_pos,
- LanguageError::kWarning, Heap::kNew,
- format, args));
+ const Error& error = Error::Handle(isolate(), LanguageError::NewFormattedV(
+ Error::Handle(isolate()), script_, token_pos,
+ LanguageError::kWarning, Heap::kNew,
+ format, args));
va_end(args);
if (FLAG_warning_as_error) {
isolate()->long_jump_base()->Jump(1, error);
@@ -7439,11 +7482,10 @@
if (FLAG_silent_warnings) return;
va_list args;
va_start(args, format);
- const Error& error = Error::Handle(
- LanguageError::NewFormattedV(
- Error::Handle(), script_, TokenPos(),
- LanguageError::kWarning, Heap::kNew,
- format, args));
+ const Error& error = Error::Handle(isolate(), LanguageError::NewFormattedV(
+ Error::Handle(isolate()), script_, TokenPos(),
+ LanguageError::kWarning, Heap::kNew,
+ format, args));
va_end(args);
if (FLAG_warning_as_error) {
isolate()->long_jump_base()->Jump(1, error);
@@ -7549,20 +7591,20 @@
AstNode* Parser::ThrowTypeError(intptr_t type_pos, const AbstractType& type) {
- ArgumentListNode* arguments = new ArgumentListNode(type_pos);
+ ArgumentListNode* arguments = new(isolate()) ArgumentListNode(type_pos);
// Location argument.
- arguments->Add(new LiteralNode(
+ arguments->Add(new(isolate()) LiteralNode(
type_pos, Integer::ZoneHandle(Integer::New(type_pos))));
// Src value argument.
- arguments->Add(new LiteralNode(type_pos, Instance::ZoneHandle()));
+ arguments->Add(new(isolate()) LiteralNode(type_pos, Instance::ZoneHandle()));
// Dst type name argument.
- arguments->Add(new LiteralNode(type_pos, Symbols::Malformed()));
+ arguments->Add(new(isolate()) LiteralNode(type_pos, Symbols::Malformed()));
// Dst name argument.
- arguments->Add(new LiteralNode(type_pos, Symbols::Empty()));
+ arguments->Add(new(isolate()) LiteralNode(type_pos, Symbols::Empty()));
// Malformed type error or malbounded type error.
- const Error& error = Error::Handle(type.error());
+ const Error& error = Error::Handle(isolate(), type.error());
ASSERT(!error.IsNull());
- arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
+ arguments->Add(new(isolate()) LiteralNode(type_pos, String::ZoneHandle(
Symbols::New(error.ToErrorCString()))));
return MakeStaticCall(Symbols::TypeError(),
Library::PrivateCoreLibName(Symbols::ThrowNew()),
@@ -7577,17 +7619,17 @@
InvocationMirror::Call im_call,
InvocationMirror::Type im_type,
Function* func) {
- ArgumentListNode* arguments = new ArgumentListNode(call_pos);
+ ArgumentListNode* arguments = new(isolate()) ArgumentListNode(call_pos);
// Object receiver.
// TODO(regis): For now, we pass a class literal of the unresolved
// method's owner, but this is not specified and will probably change.
Type& type = Type::ZoneHandle(
- Type::New(cls, TypeArguments::Handle(), call_pos, Heap::kOld));
+ Type::New(cls, TypeArguments::Handle(isolate()), call_pos, Heap::kOld));
type ^= ClassFinalizer::FinalizeType(
current_class(), type, ClassFinalizer::kCanonicalize);
- arguments->Add(new LiteralNode(call_pos, type));
+ arguments->Add(new(isolate()) LiteralNode(call_pos, type));
// String memberName.
- arguments->Add(new LiteralNode(
+ arguments->Add(new(isolate()) LiteralNode(
call_pos, String::ZoneHandle(Symbols::New(function_name))));
// Smi invocation_type.
if (cls.IsTopLevel()) {
@@ -7595,22 +7637,24 @@
im_call == InvocationMirror::kTopLevel);
im_call = InvocationMirror::kTopLevel;
}
- arguments->Add(new LiteralNode(call_pos, Smi::ZoneHandle(
+ arguments->Add(new(isolate()) LiteralNode(call_pos, Smi::ZoneHandle(
Smi::New(InvocationMirror::EncodeType(im_call, im_type)))));
// List arguments.
if (function_arguments == NULL) {
- arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
+ arguments->Add(new(isolate()) LiteralNode(call_pos, Array::ZoneHandle()));
} else {
- ArrayNode* array = new ArrayNode(call_pos,
- Type::ZoneHandle(Type::ArrayType()),
- function_arguments->nodes());
+ ArrayNode* array = new(isolate()) ArrayNode(
+ call_pos,
+ Type::ZoneHandle(Type::ArrayType()),
+ function_arguments->nodes());
arguments->Add(array);
}
// List argumentNames.
if (function_arguments == NULL) {
- arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
+ arguments->Add(new(isolate()) LiteralNode(call_pos, Array::ZoneHandle()));
} else {
- arguments->Add(new LiteralNode(call_pos, function_arguments->names()));
+ arguments->Add(new(isolate()) LiteralNode(
+ call_pos, function_arguments->names()));
}
// List existingArgumentNames.
@@ -7618,7 +7662,7 @@
// has done the lookup already. If there is a function with the same
// name but incompatible parameters, inform the NoSuchMethodError what the
// expected parameters are.
- Function& function = Function::Handle();
+ Function& function = Function::Handle(isolate());
if (func != NULL) {
function = func->raw();
} else {
@@ -7639,9 +7683,10 @@
// between dart2js and VM. Update the constructor to accept a string
// describing the formal parameters of an incompatible call target.
array = Array::New(1, Heap::kOld);
- array.SetAt(0, String::Handle(function.UserVisibleFormalParameters()));
+ array.SetAt(0, String::Handle(isolate(),
+ function.UserVisibleFormalParameters()));
}
- arguments->Add(new LiteralNode(call_pos, array));
+ arguments->Add(new(isolate()) LiteralNode(call_pos, array));
return MakeStaticCall(Symbols::NoSuchMethodError(),
Library::PrivateCoreLibName(Symbols::ThrowNew()),
@@ -7680,7 +7725,7 @@
// Make sure that the instantiator is captured.
CaptureInstantiator();
}
- right_operand = new TypeNode(type_pos, type);
+ right_operand = new(isolate()) TypeNode(type_pos, type);
// In production mode, the type may be malformed.
// In checked mode, the type may be malformed or malbounded.
if (((op_kind == Token::kIS) || (op_kind == Token::kISNOT) ||
@@ -7690,7 +7735,7 @@
// a type cast even if the tested value is null.
// We need to evaluate the left operand for potential
// side effects.
- LetNode* let = new LetNode(left_operand->token_pos());
+ LetNode* let = new(isolate()) LetNode(left_operand->token_pos());
let->AddNode(left_operand);
let->AddNode(ThrowTypeError(type_pos, type));
left_operand = let;
@@ -7707,7 +7752,7 @@
EnsureExpressionTemp();
}
}
- left_operand = new ComparisonNode(
+ left_operand = new(isolate()) ComparisonNode(
op_pos, op_kind, left_operand, right_operand);
break; // Equality and relational operators cannot be chained.
} else {
@@ -7726,7 +7771,7 @@
AstNode* expressions = ParseExpr(kAllowConst, kConsumeCascades);
if (CurrentToken() == Token::kCOMMA) {
// Collect comma-separated expressions in a non scope owning sequence node.
- SequenceNode* list = new SequenceNode(TokenPos(), NULL);
+ SequenceNode* list = new(isolate()) SequenceNode(TokenPos(), NULL);
list->Add(expressions);
while (CurrentToken() == Token::kCOMMA) {
ConsumeToken();
@@ -7748,10 +7793,10 @@
void Parser::EnsureSavedCurrentContext() {
// Used later by the flow_graph_builder to save current context.
if (!parsed_function()->has_saved_current_context_var()) {
- LocalVariable* temp =
- new LocalVariable(current_function().token_pos(),
- Symbols::SavedCurrentContextVar(),
- Type::ZoneHandle(Type::DynamicType()));
+ LocalVariable* temp = new(isolate()) LocalVariable(
+ current_function().token_pos(),
+ Symbols::SavedCurrentContextVar(),
+ Type::ZoneHandle(Type::DynamicType()));
ASSERT(temp != NULL);
parsed_function()->set_saved_current_context_var(temp);
}
@@ -7762,10 +7807,10 @@
const char* s) {
char name[64];
OS::SNPrint(name, 64, ":%s%" Pd, s, token_pos);
- LocalVariable* temp =
- new LocalVariable(token_pos,
- String::ZoneHandle(Symbols::New(name)),
- Type::ZoneHandle(Type::DynamicType()));
+ LocalVariable* temp = new(isolate()) LocalVariable(
+ token_pos,
+ String::ZoneHandle(Symbols::New(name)),
+ Type::ZoneHandle(Type::DynamicType()));
temp->set_is_final();
current_block_->scope->AddVariable(temp);
return temp;
@@ -7787,7 +7832,7 @@
if (binary_op == Token::kDIV) {
const Double& dbl_obj = Double::ZoneHandle(
Double::NewCanonical((left_double / right_double)));
- return new LiteralNode(op_pos, dbl_obj);
+ return new(isolate()) LiteralNode(op_pos, dbl_obj);
}
}
}
@@ -7810,14 +7855,14 @@
(lhs->AsBinaryOpNode()->kind() == Token::kSHL)) {
// Merge SHL and BIT_AND into one "SHL with mask" node.
BinaryOpNode* old = lhs->AsBinaryOpNode();
- BinaryOpWithMask32Node* binop = new BinaryOpWithMask32Node(
+ BinaryOpWithMask32Node* binop = new(isolate()) BinaryOpWithMask32Node(
old->token_pos(), old->kind(), old->left(), old->right(), val);
return binop;
}
}
}
}
- return new BinaryOpNode(op_pos, binary_op, lhs, rhs);
+ return new(isolate()) BinaryOpNode(op_pos, binary_op, lhs, rhs);
}
@@ -7830,27 +7875,27 @@
case Token::kASSIGN:
return rhs;
case Token::kASSIGN_ADD:
- return new BinaryOpNode(op_pos, Token::kADD, lhs, rhs);
+ return new(isolate()) BinaryOpNode(op_pos, Token::kADD, lhs, rhs);
case Token::kASSIGN_SUB:
- return new BinaryOpNode(op_pos, Token::kSUB, lhs, rhs);
+ return new(isolate()) BinaryOpNode(op_pos, Token::kSUB, lhs, rhs);
case Token::kASSIGN_MUL:
- return new BinaryOpNode(op_pos, Token::kMUL, lhs, rhs);
+ return new(isolate()) BinaryOpNode(op_pos, Token::kMUL, lhs, rhs);
case Token::kASSIGN_TRUNCDIV:
- return new BinaryOpNode(op_pos, Token::kTRUNCDIV, lhs, rhs);
+ return new(isolate()) BinaryOpNode(op_pos, Token::kTRUNCDIV, lhs, rhs);
case Token::kASSIGN_DIV:
- return new BinaryOpNode(op_pos, Token::kDIV, lhs, rhs);
+ return new(isolate()) BinaryOpNode(op_pos, Token::kDIV, lhs, rhs);
case Token::kASSIGN_MOD:
- return new BinaryOpNode(op_pos, Token::kMOD, lhs, rhs);
+ return new(isolate()) BinaryOpNode(op_pos, Token::kMOD, lhs, rhs);
case Token::kASSIGN_SHR:
- return new BinaryOpNode(op_pos, Token::kSHR, lhs, rhs);
+ return new(isolate()) BinaryOpNode(op_pos, Token::kSHR, lhs, rhs);
case Token::kASSIGN_SHL:
- return new BinaryOpNode(op_pos, Token::kSHL, lhs, rhs);
+ return new(isolate()) BinaryOpNode(op_pos, Token::kSHL, lhs, rhs);
case Token::kASSIGN_OR:
- return new BinaryOpNode(op_pos, Token::kBIT_OR, lhs, rhs);
+ return new(isolate()) BinaryOpNode(op_pos, Token::kBIT_OR, lhs, rhs);
case Token::kASSIGN_AND:
- return new BinaryOpNode(op_pos, Token::kBIT_AND, lhs, rhs);
+ return new(isolate()) BinaryOpNode(op_pos, Token::kBIT_AND, lhs, rhs);
case Token::kASSIGN_XOR:
- return new BinaryOpNode(op_pos, Token::kBIT_XOR, lhs, rhs);
+ return new(isolate()) BinaryOpNode(op_pos, Token::kBIT_XOR, lhs, rhs);
default:
ErrorMsg(op_pos, "internal error: ExpandAssignableOp '%s' unimplemented",
Token::Name(assignment_op));
@@ -7869,28 +7914,29 @@
if (expr->EvalConstExpr() == NULL) {
ErrorMsg(expr_pos, "expression is not a valid compile-time constant");
}
- return new LiteralNode(expr_pos, EvaluateConstExpr(expr_pos, expr));
+ return new(isolate()) LiteralNode(
+ expr_pos, EvaluateConstExpr(expr_pos, expr));
}
LetNode* Parser::PrepareCompoundAssignmentNodes(AstNode** expr) {
AstNode* node = *expr;
intptr_t token_pos = node->token_pos();
- LetNode* result = new LetNode(token_pos);
+ LetNode* result = new(isolate()) LetNode(token_pos);
if (node->IsLoadIndexedNode()) {
LoadIndexedNode* load_indexed = node->AsLoadIndexedNode();
AstNode* array = load_indexed->array();
AstNode* index = load_indexed->index_expr();
if (!IsSimpleLocalOrLiteralNode(load_indexed->array())) {
LocalVariable* t0 = result->AddInitializer(load_indexed->array());
- array = new LoadLocalNode(token_pos, t0);
+ array = new(isolate()) LoadLocalNode(token_pos, t0);
}
if (!IsSimpleLocalOrLiteralNode(load_indexed->index_expr())) {
LocalVariable* t1 = result->AddInitializer(
load_indexed->index_expr());
- index = new LoadLocalNode(token_pos, t1);
+ index = new(isolate()) LoadLocalNode(token_pos, t1);
}
- *expr = new LoadIndexedNode(token_pos,
+ *expr = new(isolate()) LoadIndexedNode(token_pos,
array,
index,
load_indexed->super_class());
@@ -7901,11 +7947,11 @@
AstNode* receiver = getter->receiver();
if (!IsSimpleLocalOrLiteralNode(getter->receiver())) {
LocalVariable* t0 = result->AddInitializer(getter->receiver());
- receiver = new LoadLocalNode(token_pos, t0);
+ receiver = new(isolate()) LoadLocalNode(token_pos, t0);
}
- *expr = new InstanceGetterNode(token_pos,
- receiver,
- getter->field_name());
+ *expr = new(isolate()) InstanceGetterNode(token_pos,
+ receiver,
+ getter->field_name());
return result;
}
return result;
@@ -7946,8 +7992,8 @@
name = Symbols::New(original->AsTypeNode()->TypeName());
} else if (original->IsLoadStaticFieldNode()) {
name = original->AsLoadStaticFieldNode()->field().name();
- target_cls =
- &Class::Handle(original->AsLoadStaticFieldNode()->field().owner());
+ target_cls = &Class::Handle(isolate(),
+ original->AsLoadStaticFieldNode()->field().owner());
} else if ((left_ident != NULL) &&
(original->IsLiteralNode() ||
original->IsLoadLocalNode())) {
@@ -7979,12 +8025,12 @@
AstNode* Parser::ParseCascades(AstNode* expr) {
intptr_t cascade_pos = TokenPos();
- LetNode* cascade = new LetNode(cascade_pos);
+ LetNode* cascade = new(isolate()) LetNode(cascade_pos);
LocalVariable* cascade_receiver_var = cascade->AddInitializer(expr);
while (CurrentToken() == Token::kCASCADE) {
cascade_pos = TokenPos();
LoadLocalNode* load_cascade_receiver =
- new LoadLocalNode(cascade_pos, cascade_receiver_var);
+ new(isolate()) LoadLocalNode(cascade_pos, cascade_receiver_var);
if (Token::IsIdentifier(LookaheadToken(1))) {
// Replace .. with . for ParseSelectors().
token_kind_ = Token::kPERIOD;
@@ -8029,7 +8075,8 @@
}
// The result is an expression with the (side effects of the) cascade
// sequence followed by the (value of the) receiver temp variable load.
- cascade->AddNode(new LoadLocalNode(cascade_pos, cascade_receiver_var));
+ cascade->AddNode(new(isolate()) LoadLocalNode(
+ cascade_pos, cascade_receiver_var));
return cascade;
}
@@ -8062,7 +8109,7 @@
ErrorMsg("expression expected after throw");
}
AstNode* expr = ParseExpr(require_compiletime_const, consume_cascades);
- return new ThrowNode(expr_pos, expr, NULL);
+ return new(isolate()) ThrowNode(expr_pos, expr, NULL);
}
AstNode* expr = ParseConditionalExpr();
if (!Token::IsAssignmentOperator(CurrentToken())) {
@@ -8129,7 +8176,7 @@
AstNode* expr1 = ParseExpr(kAllowConst, kNoCascades);
ExpectToken(Token::kCOLON);
AstNode* expr2 = ParseExpr(kAllowConst, kNoCascades);
- expr = new ConditionalExprNode(expr_pos, expr, expr1, expr2);
+ expr = new(isolate()) ConditionalExprNode(expr_pos, expr, expr1, expr2);
}
return expr;
}
@@ -8165,11 +8212,11 @@
LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
Token::Kind binary_op =
(incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
- BinaryOpNode* add = new BinaryOpNode(
+ BinaryOpNode* add = new(isolate()) BinaryOpNode(
op_pos,
binary_op,
expr,
- new LiteralNode(op_pos, Smi::ZoneHandle(Smi::New(1))));
+ new(isolate()) LiteralNode(op_pos, Smi::ZoneHandle(Smi::New(1))));
AstNode* store = CreateAssignmentNode(expr, add, expr_ident, expr_pos);
ASSERT(store != NULL);
let_expr->AddNode(store);
@@ -8189,15 +8236,15 @@
const bool saved_mode = SetAllowFunctionLiterals(true);
ArgumentListNode* arguments;
if (implicit_arguments == NULL) {
- arguments = new ArgumentListNode(TokenPos());
+ arguments = new(isolate()) ArgumentListNode(TokenPos());
} else {
arguments = implicit_arguments;
}
- const GrowableObjectArray& names =
- GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld));
+ const GrowableObjectArray& names = GrowableObjectArray::Handle(isolate(),
+ GrowableObjectArray::New(Heap::kOld));
bool named_argument_seen = false;
if (LookaheadToken(1) != Token::kRPAREN) {
- String& arg_name = String::Handle();
+ String& arg_name = String::Handle(isolate());
do {
ASSERT((CurrentToken() == Token::kLPAREN) ||
(CurrentToken() == Token::kCOMMA));
@@ -8228,7 +8275,7 @@
ExpectToken(Token::kRPAREN);
SetAllowFunctionLiterals(saved_mode);
if (named_argument_seen) {
- arguments->set_names(Array::Handle(Array::MakeArray(names)));
+ arguments->set_names(Array::Handle(isolate(), Array::MakeArray(names)));
}
return arguments;
}
@@ -8264,11 +8311,11 @@
Object::empty_array());
if (!func.IsNull()) {
ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
- closure = new StaticGetterNode(call_pos,
- NULL,
- false,
- Class::ZoneHandle(cls.raw()),
- func_name);
+ closure = new(isolate()) StaticGetterNode(call_pos,
+ NULL,
+ false,
+ Class::ZoneHandle(cls.raw()),
+ func_name);
return BuildClosureCall(call_pos, closure, arguments);
}
} else {
@@ -8289,12 +8336,12 @@
// This is the predefined toplevel function identical(a,b). Create
// a comparison node instead.
ASSERT(num_arguments == 2);
- return new ComparisonNode(ident_pos,
- Token::kEQ_STRICT,
- arguments->NodeAt(0),
- arguments->NodeAt(1));
+ return new(isolate()) ComparisonNode(ident_pos,
+ Token::kEQ_STRICT,
+ arguments->NodeAt(0),
+ arguments->NodeAt(1));
}
- return new StaticCallNode(call_pos, func, arguments);
+ return new(isolate()) StaticCallNode(call_pos, func, arguments);
}
@@ -8303,7 +8350,8 @@
const intptr_t call_pos = TokenPos();
CheckToken(Token::kLPAREN);
ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
- return new InstanceCallNode(call_pos, receiver, func_name, arguments);
+ return new(isolate()) InstanceCallNode(
+ call_pos, receiver, func_name, arguments);
}
@@ -8330,19 +8378,21 @@
ASSERT(field.is_static());
const Class& field_owner = Class::ZoneHandle(field.owner());
const String& field_name = String::ZoneHandle(field.name());
- const String& getter_name = String::Handle(Field::GetterName(field_name));
- const Function& getter =
- Function::Handle(field_owner.LookupStaticFunction(getter_name));
+ const String& getter_name = String::Handle(isolate(),
+ Field::GetterName(field_name));
+ const Function& getter = Function::Handle(isolate(),
+ field_owner.LookupStaticFunction(getter_name));
// Never load field directly if there is a getter (deterministic AST).
if (getter.IsNull() || field.is_const()) {
- return new LoadStaticFieldNode(ident_pos, Field::ZoneHandle(field.raw()));
+ return new(isolate()) LoadStaticFieldNode(
+ ident_pos, Field::ZoneHandle(field.raw()));
} else {
ASSERT(getter.kind() == RawFunction::kImplicitStaticFinalGetter);
- return new StaticGetterNode(ident_pos,
- NULL, // Receiver.
- false, // is_super_getter.
- field_owner,
- field_name);
+ return new(isolate()) StaticGetterNode(ident_pos,
+ NULL, // Receiver.
+ false, // is_super_getter.
+ field_owner,
+ field_name);
}
}
@@ -8376,19 +8426,13 @@
// Create a getter call, which may later be turned into
// a setter call, or else the backend will generate
// a throw NoSuchMethodError().
- access = new StaticGetterNode(ident_pos,
- NULL,
- false,
- Class::ZoneHandle(cls.raw()),
- field_name);
+ access = new(isolate()) StaticGetterNode(
+ ident_pos, NULL, false, Class::ZoneHandle(cls.raw()), field_name);
}
} else {
ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
- access = new StaticGetterNode(ident_pos,
- NULL,
- false,
- Class::ZoneHandle(cls.raw()),
- field_name);
+ access = new(isolate()) StaticGetterNode(
+ ident_pos, NULL, false, Class::ZoneHandle(cls.raw()), field_name);
}
} else {
access = GenerateStaticFieldLookup(field, ident_pos);
@@ -8420,11 +8464,12 @@
if (current_function().is_static() ||
current_function().IsInFactoryScope()) {
StaticGetterNode* getter =
- new StaticGetterNode(primary->token_pos(),
- NULL, // No receiver.
- false, // Not a super getter.
- Class::ZoneHandle(current_class().raw()),
- name);
+ new(isolate()) StaticGetterNode(
+ primary->token_pos(),
+ NULL, // No receiver.
+ false, // Not a super getter.
+ Class::ZoneHandle(current_class().raw()),
+ name);
getter->set_is_deferred(primary->is_deferred_reference());
return getter;
} else {
@@ -8497,7 +8542,7 @@
TypeParameter::Cast(primary_node->primary()),
ClassFinalizer::kCanonicalize);
ASSERT(!type_parameter.IsMalformed());
- left = new TypeNode(primary->token_pos(), type_parameter);
+ left = new(isolate()) TypeNode(primary->token_pos(), type_parameter);
} else {
// Super field access handled in ParseSuperFieldAccess(),
// super calls handled in ParseSuperCall().
@@ -8519,7 +8564,7 @@
}
} else {
// Field access.
- Class& cls = Class::Handle();
+ Class& cls = Class::Handle(isolate());
if (left->IsPrimaryNode()) {
PrimaryNode* primary_node = left->AsPrimaryNode();
if (primary_node->primary().IsClass()) {
@@ -8557,13 +8602,13 @@
} else if (primary_node->primary().IsClass()) {
const Class& type_class = Class::Cast(primary_node->primary());
AbstractType& type = Type::ZoneHandle(
- Type::New(type_class, TypeArguments::Handle(),
+ Type::New(type_class, TypeArguments::Handle(isolate()),
primary_pos, Heap::kOld));
type ^= ClassFinalizer::FinalizeType(
current_class(), type, ClassFinalizer::kCanonicalize);
// Type may be malbounded, but not malformed.
ASSERT(!type.IsMalformed());
- array = new TypeNode(primary_pos, type);
+ array = new(isolate()) TypeNode(primary_pos, type);
} else if (primary_node->primary().IsTypeParameter()) {
if (current_function().is_static()) {
const String& name = String::ZoneHandle(
@@ -8582,15 +8627,13 @@
TypeParameter::Cast(primary_node->primary()),
ClassFinalizer::kCanonicalize);
ASSERT(!type_parameter.IsMalformed());
- array = new TypeNode(primary_pos, type_parameter);
+ array = new(isolate()) TypeNode(primary_pos, type_parameter);
} else {
UNREACHABLE(); // Internal parser error.
}
}
- selector = new LoadIndexedNode(bracket_pos,
- array,
- index,
- Class::ZoneHandle());
+ selector = new(isolate()) LoadIndexedNode(
+ bracket_pos, array, index, Class::ZoneHandle());
} else if (CurrentToken() == Token::kLPAREN) {
if (left->IsPrimaryNode()) {
PrimaryNode* primary_node = left->AsPrimaryNode();
@@ -8600,7 +8643,7 @@
const String& func_name = String::ZoneHandle(func.name());
if (func.is_static()) {
// Parse static function call.
- Class& cls = Class::Handle(func.Owner());
+ Class& cls = Class::Handle(isolate(), func.Owner());
selector = ParseStaticCall(cls, func_name, primary_pos);
} else {
// Dynamic function call on implicit "this" parameter.
@@ -8646,12 +8689,12 @@
} else if (primary_node->primary().IsClass()) {
const Class& type_class = Class::Cast(primary_node->primary());
AbstractType& type = Type::ZoneHandle(Type::New(
- type_class, TypeArguments::Handle(), primary_pos));
+ type_class, TypeArguments::Handle(isolate()), primary_pos));
type ^= ClassFinalizer::FinalizeType(
current_class(), type, ClassFinalizer::kCanonicalize);
// Type may be malbounded, but not malformed.
ASSERT(!type.IsMalformed());
- selector = new TypeNode(primary_pos, type);
+ selector = new(isolate()) TypeNode(primary_pos, type);
} else {
UNREACHABLE(); // Internal parser error.
}
@@ -8680,12 +8723,12 @@
} else if (primary_node->primary().IsClass()) {
const Class& type_class = Class::Cast(primary_node->primary());
AbstractType& type = Type::ZoneHandle(Type::New(
- type_class, TypeArguments::Handle(), primary_pos));
+ type_class, TypeArguments::Handle(isolate()), primary_pos));
type = ClassFinalizer::FinalizeType(
current_class(), type, ClassFinalizer::kCanonicalize);
// Type may be malbounded, but not malformed.
ASSERT(!type.IsMalformed());
- left = new TypeNode(primary_pos, type);
+ left = new(isolate()) TypeNode(primary_pos, type);
} else if (primary_node->primary().IsTypeParameter()) {
if (current_function().is_static()) {
const String& name = String::ZoneHandle(
@@ -8704,7 +8747,7 @@
TypeParameter::Cast(primary_node->primary()),
ClassFinalizer::kCanonicalize);
ASSERT(!type_parameter.IsMalformed());
- left = new TypeNode(primary_pos, type_parameter);
+ left = new(isolate()) TypeNode(primary_pos, type_parameter);
} else if (primary_node->IsSuper()) {
// Return "super" to handle unary super operator calls,
// or to report illegal use of "super" otherwise.
@@ -8741,17 +8784,17 @@
LocalVariable* temp = let_expr->AddInitializer(expr);
Token::Kind binary_op =
(incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
- BinaryOpNode* add = new BinaryOpNode(
+ BinaryOpNode* add = new(isolate()) BinaryOpNode(
expr_pos,
binary_op,
- new LoadLocalNode(expr_pos, temp),
- new LiteralNode(expr_pos, Smi::ZoneHandle(Smi::New(1))));
+ new(isolate()) LoadLocalNode(expr_pos, temp),
+ new(isolate()) LiteralNode(expr_pos, Smi::ZoneHandle(Smi::New(1))));
AstNode* store = CreateAssignmentNode(expr, add, expr_ident, expr_pos);
ASSERT(store != NULL);
// The result is a pair of the (side effects of the) store followed by
// the (value of the) initial value temp variable load.
let_expr->AddNode(store);
- let_expr->AddNode(new LoadLocalNode(expr_pos, temp));
+ let_expr->AddNode(new(isolate()) LoadLocalNode(expr_pos, temp));
return let_expr;
}
return expr;
@@ -8933,7 +8976,7 @@
}
const char* error_str = NULL;
Instance& result =
- Instance::Handle(instance.CheckAndCanonicalize(&error_str));
+ Instance::Handle(isolate(), instance.CheckAndCanonicalize(&error_str));
if (result.IsNull()) {
ErrorMsg(token_pos, "Invalid const object %s", error_str);
}
@@ -8960,11 +9003,8 @@
field_name.ToCString());
} else {
// The implicit static getter will throw the exception if necessary.
- return new StaticGetterNode(field_ref_pos,
- NULL,
- false,
- field_owner,
- field_name);
+ return new(isolate()) StaticGetterNode(
+ field_ref_pos, NULL, false, field_owner, field_name);
}
} else if (value.raw() == Object::sentinel().raw()) {
// This field has not been referenced yet and thus the value has
@@ -8973,11 +9013,11 @@
if (field.is_const()) {
field.set_value(Object::transition_sentinel());
const int kNumArguments = 0; // no arguments.
- const Function& func = Function::Handle(
- isolate(), Resolver::ResolveStatic(field_owner,
- getter_name,
- kNumArguments,
- Object::empty_array()));
+ const Function& func = Function::Handle(isolate(),
+ Resolver::ResolveStatic(field_owner,
+ getter_name,
+ kNumArguments,
+ Object::empty_array()));
ASSERT(!func.IsNull());
ASSERT(func.kind() == RawFunction::kImplicitStaticFinalGetter);
Object& const_value = Object::Handle(isolate());
@@ -8997,24 +9037,21 @@
// would raise an exception.
AppendErrorMsg(error, field_ref_pos,
"error initializing const field '%s'",
- String::Handle(field.name()).ToCString());
+ String::Handle(isolate(), field.name()).ToCString());
} else {
isolate()->long_jump_base()->Jump(1, error);
UNREACHABLE();
}
}
ASSERT(const_value.IsNull() || const_value.IsInstance());
- Instance& instance = Instance::Handle();
+ Instance& instance = Instance::Handle(isolate());
instance ^= const_value.raw();
instance = TryCanonicalize(instance, field_ref_pos);
field.set_value(instance);
return NULL; // Constant
} else {
- return new StaticGetterNode(field_ref_pos,
- NULL,
- false,
- field_owner,
- field_name);
+ return new(isolate()) StaticGetterNode(
+ field_ref_pos, NULL, false, field_owner, field_name);
}
}
if (getter.IsNull() ||
@@ -9022,11 +9059,8 @@
return NULL;
}
ASSERT(getter.kind() == RawFunction::kImplicitGetter);
- return new StaticGetterNode(field_ref_pos,
- NULL,
- false,
- field_owner,
- field_name);
+ return new(isolate()) StaticGetterNode(
+ field_ref_pos, NULL, false, field_owner, field_name);
}
@@ -9049,10 +9083,11 @@
ErrorMsg("type must be constant in const constructor");
}
instance.SetTypeArguments(
- TypeArguments::Handle(type_arguments.Canonicalize()));
+ TypeArguments::Handle(isolate(), type_arguments.Canonicalize()));
}
arg_values.SetAt(0, instance);
- arg_values.SetAt(1, Smi::Handle(Smi::New(Function::kCtorPhaseAll)));
+ arg_values.SetAt(1, Smi::Handle(isolate(),
+ Smi::New(Function::kCtorPhaseAll)));
} else {
// Prepend type_arguments to list of arguments to factory.
ASSERT(type_arguments.IsZoneHandle());
@@ -9111,7 +9146,7 @@
}
if (local != NULL) {
if (node != NULL) {
- *node = new LoadLocalNode(ident_pos, local);
+ *node = new(isolate()) LoadLocalNode(ident_pos, local);
}
return true;
}
@@ -9149,8 +9184,8 @@
func.IsStaticFunction() ||
func.is_abstract())) {
if (node != NULL) {
- *node = new PrimaryNode(ident_pos,
- Function::ZoneHandle(isolate(), func.raw()));
+ *node = new(isolate()) PrimaryNode(
+ ident_pos, Function::ZoneHandle(isolate(), func.raw()));
}
return true;
}
@@ -9162,13 +9197,15 @@
if (func.IsDynamicFunction() || func.is_abstract()) {
if (node != NULL) {
CheckInstanceFieldAccess(ident_pos, ident);
- ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+ ASSERT(AbstractType::Handle(isolate(),
+ func.result_type()).IsResolved());
*node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
}
return true;
} else if (func.IsStaticFunction()) {
if (node != NULL) {
- ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+ ASSERT(AbstractType::Handle(isolate(),
+ func.result_type()).IsResolved());
// The static getter may later be changed into a dynamically
// resolved instance setter if no static setter can
// be found.
@@ -9183,7 +9220,7 @@
(LookupReceiver(current_block_->scope, kTestOnly) != NULL)) {
receiver = LoadReceiver(ident_pos);
}
- *node = new StaticGetterNode(ident_pos,
+ *node = new(isolate()) StaticGetterNode(ident_pos,
receiver,
false,
Class::ZoneHandle(isolate(), cls.raw()),
@@ -9201,7 +9238,8 @@
// a setter node. If there is no assignment we will get an error
// when we try to invoke the getter.
CheckInstanceFieldAccess(ident_pos, ident);
- ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+ ASSERT(AbstractType::Handle(isolate(),
+ func.result_type()).IsResolved());
*node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
}
return true;
@@ -9211,11 +9249,12 @@
// it could be followed by an assignment which will convert it to
// a setter node. If there is no assignment we will get an error
// when we try to invoke the getter.
- *node = new StaticGetterNode(ident_pos,
- NULL,
- false,
- Class::ZoneHandle(isolate(), cls.raw()),
- ident);
+ *node = new(isolate()) StaticGetterNode(
+ ident_pos,
+ NULL,
+ false,
+ Class::ZoneHandle(isolate(), cls.raw()),
+ ident);
}
return true;
}
@@ -9231,7 +9270,7 @@
RawClass* Parser::ResolveClassInCurrentLibraryScope(const String& name) {
HANDLESCOPE(isolate());
- const Object& obj = Object::Handle(library_.ResolveName(name));
+ const Object& obj = Object::Handle(isolate(), library_.ResolveName(name));
if (obj.IsClass()) {
return Class::Cast(obj).raw();
}
@@ -9246,10 +9285,10 @@
const String& ident) {
TRACE_PARSER("ResolveIdentInCurrentLibraryScope");
HANDLESCOPE(isolate());
- const Object& obj = Object::Handle(library_.ResolveName(ident));
+ const Object& obj = Object::Handle(isolate(), library_.ResolveName(ident));
if (obj.IsClass()) {
const Class& cls = Class::Cast(obj);
- return new PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
+ return new(isolate()) PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
} else if (obj.IsField()) {
const Field& field = Field::Cast(obj);
ASSERT(field.is_static());
@@ -9258,27 +9297,28 @@
const Function& func = Function::Cast(obj);
ASSERT(func.is_static());
if (func.IsGetterFunction() || func.IsSetterFunction()) {
- return new StaticGetterNode(ident_pos,
- /* receiver */ NULL,
- /* is_super_getter */ false,
- Class::ZoneHandle(func.Owner()),
- ident);
+ return new(isolate()) StaticGetterNode(ident_pos,
+ /* receiver */ NULL,
+ /* is_super_getter */ false,
+ Class::ZoneHandle(func.Owner()),
+ ident);
} else {
- return new PrimaryNode(ident_pos, Function::ZoneHandle(func.raw()));
+ return new(isolate()) PrimaryNode(ident_pos,
+ Function::ZoneHandle(func.raw()));
}
} else {
ASSERT(obj.IsNull() || obj.IsLibraryPrefix());
}
// Lexically unresolved primary identifiers are referenced by their name.
- return new PrimaryNode(ident_pos, ident);
+ return new(isolate()) PrimaryNode(ident_pos, ident);
}
RawClass* Parser::ResolveClassInPrefixScope(const LibraryPrefix& prefix,
const String& name) {
HANDLESCOPE(isolate());
- const Object& obj = Object::Handle(prefix.LookupObject(name));
+ const Object& obj = Object::Handle(isolate(), prefix.LookupObject(name));
if (obj.IsClass()) {
return Class::Cast(obj).raw();
}
@@ -9294,7 +9334,7 @@
const String& ident) {
TRACE_PARSER("ResolveIdentInPrefixScope");
HANDLESCOPE(isolate());
- Object& obj = Object::Handle();
+ Object& obj = Object::Handle(isolate());
if (prefix.is_loaded()) {
obj = prefix.LookupObject(ident);
} else {
@@ -9312,7 +9352,7 @@
} else if (obj.IsClass()) {
const Class& cls = Class::Cast(obj);
PrimaryNode* primary =
- new PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
+ new(isolate()) PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
primary->set_is_deferred(is_deferred);
return primary;
} else if (obj.IsField()) {
@@ -9333,16 +9373,16 @@
ASSERT(func.is_static());
if (func.IsGetterFunction() || func.IsSetterFunction()) {
StaticGetterNode* getter =
- new StaticGetterNode(ident_pos,
+ new(isolate()) StaticGetterNode(ident_pos,
/* receiver */ NULL,
/* is_super_getter */ false,
- Class::ZoneHandle(func.Owner()),
+ Class::ZoneHandle(isolate(), func.Owner()),
ident);
getter->set_is_deferred(is_deferred);
return getter;
} else {
- PrimaryNode* primary =
- new PrimaryNode(ident_pos, Function::ZoneHandle(func.raw()));
+ PrimaryNode* primary = new(isolate()) PrimaryNode(
+ ident_pos, Function::ZoneHandle(isolate(), func.raw()));
primary->set_is_deferred(is_deferred);
return primary;
}
@@ -9379,7 +9419,7 @@
type_parameter ^= ClassFinalizer::FinalizeType(
current_class(), type_parameter, ClassFinalizer::kCanonicalize);
ASSERT(!type_parameter.IsMalformed());
- return new TypeNode(ident_pos, type_parameter);
+ return new(isolate()) TypeNode(ident_pos, type_parameter);
}
}
// Not found in the local scope, and the name is not a type parameter.
@@ -9418,12 +9458,12 @@
} else if (primary->primary().IsClass()) {
const Class& type_class = Class::Cast(primary->primary());
AbstractType& type = Type::ZoneHandle(
- Type::New(type_class, TypeArguments::Handle(), primary_pos));
+ Type::New(type_class, TypeArguments::Handle(isolate()), primary_pos));
type ^= ClassFinalizer::FinalizeType(
current_class(), type, ClassFinalizer::kCanonicalize);
// Type may be malbounded, but not malformed.
ASSERT(!type.IsMalformed());
- resolved = new TypeNode(primary_pos, type);
+ resolved = new(isolate()) TypeNode(primary_pos, type);
}
}
return resolved;
@@ -9454,7 +9494,7 @@
// The type is malformed. Skip over its type arguments.
ParseTypeArguments(ClassFinalizer::kIgnore);
return ClassFinalizer::NewFinalizedMalformedType(
- Error::Handle(), // No previous error.
+ Error::Handle(isolate()), // No previous error.
script_,
type_name.ident_pos,
"using '%s' in this context is invalid",
@@ -9465,11 +9505,11 @@
!allow_deferred_type) {
ParseTypeArguments(ClassFinalizer::kIgnore);
return ClassFinalizer::NewFinalizedMalformedType(
- Error::Handle(), // No previous error.
+ Error::Handle(isolate()), // No previous error.
script_,
type_name.ident_pos,
"using deferred type '%s.%s' is invalid",
- String::Handle(type_name.lib_prefix->name()).ToCString(),
+ String::Handle(isolate(), type_name.lib_prefix->name()).ToCString(),
type_name.ident->ToCString());
}
}
@@ -9505,7 +9545,8 @@
intptr_t pos, const Function& constructor,
const TypeArguments& type_arguments) {
if (!type_arguments.IsNull()) {
- const Class& constructor_class = Class::Handle(constructor.Owner());
+ const Class& constructor_class = Class::Handle(isolate(),
+ constructor.Owner());
ASSERT(!constructor_class.IsNull());
ASSERT(constructor_class.is_finalized());
ASSERT(type_arguments.IsCanonical());
@@ -9562,7 +9603,7 @@
}
}
ASSERT(list_type_arguments.IsNull() || (list_type_arguments.Length() == 1));
- const Class& array_class = Class::Handle(
+ const Class& array_class = Class::Handle(isolate(),
isolate()->object_store()->array_class());
Type& type = Type::ZoneHandle(
Type::New(array_class, list_type_arguments, type_pos));
@@ -9579,10 +9620,10 @@
if (FLAG_enable_type_checks &&
!is_const &&
!element_type.IsDynamicType()) {
- element = new AssignableNode(element_pos,
- element,
- element_type,
- Symbols::ListLiteralElement());
+ element = new(isolate()) AssignableNode(element_pos,
+ element,
+ element_type,
+ Symbols::ListLiteralElement());
}
element_list.Add(element);
if (CurrentToken() == Token::kCOMMA) {
@@ -9600,8 +9641,8 @@
Array& const_list =
Array::ZoneHandle(Array::New(element_list.length(), Heap::kOld));
const_list.SetTypeArguments(
- TypeArguments::Handle(list_type_arguments.Canonicalize()));
- Error& malformed_error = Error::Handle();
+ TypeArguments::Handle(isolate(), list_type_arguments.Canonicalize()));
+ Error& malformed_error = Error::Handle(isolate());
for (int i = 0; i < element_list.length(); i++) {
AstNode* elem = element_list[i];
// Arguments have been evaluated to a literal value already.
@@ -9611,7 +9652,9 @@
!element_type.IsDynamicType() &&
(!elem->AsLiteralNode()->literal().IsNull() &&
!elem->AsLiteralNode()->literal().IsInstanceOf(
- element_type, TypeArguments::Handle(), &malformed_error))) {
+ element_type,
+ TypeArguments::Handle(isolate()),
+ &malformed_error))) {
// If the failure is due to a malformed type error, display it instead.
if (!malformed_error.IsNull()) {
ErrorMsg(malformed_error);
@@ -9620,18 +9663,19 @@
"list literal element at index %d must be "
"a constant of type '%s'",
i,
- String::Handle(element_type.UserVisibleName()).ToCString());
+ String::Handle(isolate(),
+ element_type.UserVisibleName()).ToCString());
}
}
const_list.SetAt(i, elem->AsLiteralNode()->literal());
}
const_list ^= TryCanonicalize(const_list, literal_pos);
const_list.MakeImmutable();
- return new LiteralNode(literal_pos, const_list);
+ return new(isolate()) LiteralNode(literal_pos, const_list);
} else {
// Factory call at runtime.
const Class& factory_class =
- Class::Handle(Library::LookupCoreClass(Symbols::List()));
+ Class::Handle(isolate(), Library::LookupCoreClass(Symbols::List()));
ASSERT(!factory_class.IsNull());
const Function& factory_method = Function::ZoneHandle(
factory_class.LookupFactory(
@@ -9649,7 +9693,7 @@
// type argument vector.
if (!factory_type_args.IsNull() && (factory_class.NumTypeArguments() > 1)) {
ASSERT(factory_type_args.Length() == 1);
- Type& factory_type = Type::Handle(Type::New(
+ Type& factory_type = Type::Handle(isolate(), Type::New(
factory_class, factory_type_args, type_pos, Heap::kNew));
factory_type ^= ClassFinalizer::FinalizeType(
current_class(), factory_type, ClassFinalizer::kFinalize);
@@ -9657,15 +9701,17 @@
ASSERT(factory_type_args.Length() == factory_class.NumTypeArguments());
}
factory_type_args = factory_type_args.Canonicalize();
- ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
+ ArgumentListNode* factory_param = new(isolate()) ArgumentListNode(
+ literal_pos);
if (element_list.length() == 0) {
// TODO(srdjan): Use Object::empty_array once issue 9871 has been fixed.
Array& empty_array = Array::ZoneHandle(Object::empty_array().raw());
LiteralNode* empty_array_literal =
- new LiteralNode(TokenPos(), empty_array);
+ new(isolate()) LiteralNode(TokenPos(), empty_array);
factory_param->Add(empty_array_literal);
} else {
- ArrayNode* list = new ArrayNode(TokenPos(), type, element_list);
+ ArrayNode* list = new(isolate()) ArrayNode(
+ TokenPos(), type, element_list);
factory_param->Add(list);
}
return CreateConstructorCallNode(literal_pos,
@@ -9684,10 +9730,8 @@
if (!type_arguments.IsNull() && !type_arguments.IsInstantiated()) {
EnsureExpressionTemp();
}
- return new ConstructorCallNode(token_pos,
- type_arguments,
- constructor,
- arguments);
+ return new(isolate()) ConstructorCallNode(
+ token_pos, type_arguments, constructor, arguments);
}
@@ -9772,10 +9816,8 @@
if (FLAG_enable_type_checks &&
!is_const &&
!key_type.IsDynamicType()) {
- key = new AssignableNode(key_pos,
- key,
- key_type,
- Symbols::ListLiteralElement());
+ key = new(isolate()) AssignableNode(
+ key_pos, key, key_type, Symbols::ListLiteralElement());
}
if (is_const) {
ASSERT(key->IsLiteralNode());
@@ -9796,10 +9838,8 @@
if (FLAG_enable_type_checks &&
!is_const &&
!value_type.IsDynamicType()) {
- value = new AssignableNode(value_pos,
- value,
- value_type,
- Symbols::ListLiteralElement());
+ value = new(isolate()) AssignableNode(
+ value_pos, value, value_type, Symbols::ListLiteralElement());
}
AddKeyValuePair(&kv_pairs_list, is_const, key, value);
@@ -9820,8 +9860,8 @@
// First, create the canonicalized key-value pair array.
Array& key_value_array =
Array::ZoneHandle(Array::New(kv_pairs_list.length(), Heap::kOld));
- AbstractType& arg_type = Type::Handle();
- Error& malformed_error = Error::Handle();
+ AbstractType& arg_type = Type::Handle(isolate());
+ Error& malformed_error = Error::Handle(isolate());
for (int i = 0; i < kv_pairs_list.length(); i++) {
AstNode* arg = kv_pairs_list[i];
// Arguments have been evaluated to a literal value already.
@@ -9850,7 +9890,8 @@
"a constant of type '%s'",
((i % 2) == 0) ? "key" : "value",
i >> 1,
- String::Handle(arg_type.UserVisibleName()).ToCString());
+ String::Handle(isolate(),
+ arg_type.UserVisibleName()).ToCString());
}
}
}
@@ -9860,19 +9901,19 @@
key_value_array.MakeImmutable();
// Construct the map object.
- const Class& immutable_map_class =
- Class::Handle(Library::LookupCoreClass(Symbols::ImmutableMap()));
+ const Class& immutable_map_class = Class::Handle(isolate(),
+ Library::LookupCoreClass(Symbols::ImmutableMap()));
ASSERT(!immutable_map_class.IsNull());
// If the immutable map class extends other parameterized classes, we need
// to adjust the type argument vector. This is currently not the case.
ASSERT(immutable_map_class.NumTypeArguments() == 2);
- ArgumentListNode* constr_args = new ArgumentListNode(TokenPos());
- constr_args->Add(new LiteralNode(literal_pos, key_value_array));
+ ArgumentListNode* constr_args = new(isolate()) ArgumentListNode(TokenPos());
+ constr_args->Add(new(isolate()) LiteralNode(literal_pos, key_value_array));
const Function& map_constr =
Function::ZoneHandle(immutable_map_class.LookupConstructor(
Library::PrivateCoreLibName(Symbols::ImmutableMapConstructor())));
ASSERT(!map_constr.IsNull());
- const Object& constructor_result = Object::Handle(
+ const Object& constructor_result = Object::Handle(isolate(),
EvaluateConstConstructorCall(immutable_map_class,
map_type_arguments,
map_constr,
@@ -9883,13 +9924,13 @@
"error executing const Map constructor");
} else {
const Instance& const_instance = Instance::Cast(constructor_result);
- return new LiteralNode(literal_pos,
- Instance::ZoneHandle(const_instance.raw()));
+ return new(isolate()) LiteralNode(
+ literal_pos, Instance::ZoneHandle(const_instance.raw()));
}
} else {
// Factory call at runtime.
const Class& factory_class =
- Class::Handle(Library::LookupCoreClass(Symbols::Map()));
+ Class::Handle(isolate(), Library::LookupCoreClass(Symbols::Map()));
ASSERT(!factory_class.IsNull());
const Function& factory_method = Function::ZoneHandle(
factory_class.LookupFactory(
@@ -9907,7 +9948,7 @@
// type argument vector.
if (!factory_type_args.IsNull() && (factory_class.NumTypeArguments() > 2)) {
ASSERT(factory_type_args.Length() == 2);
- Type& factory_type = Type::Handle(Type::New(
+ Type& factory_type = Type::Handle(isolate(), Type::New(
factory_class, factory_type_args, type_pos, Heap::kNew));
factory_type ^= ClassFinalizer::FinalizeType(
current_class(), factory_type, ClassFinalizer::kFinalize);
@@ -9915,10 +9956,11 @@
ASSERT(factory_type_args.Length() == factory_class.NumTypeArguments());
}
factory_type_args = factory_type_args.Canonicalize();
- ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
+ ArgumentListNode* factory_param =
+ new(isolate()) ArgumentListNode(literal_pos);
// The kv_pair array is temporary and of element type dynamic. It is passed
// to the factory to initialize a properly typed map.
- ArrayNode* kv_pairs = new ArrayNode(
+ ArrayNode* kv_pairs = new(isolate()) ArrayNode(
TokenPos(),
Type::ZoneHandle(Type::ArrayType()),
kv_pairs_list);
@@ -9941,7 +9983,7 @@
ConsumeToken();
}
const intptr_t type_pos = TokenPos();
- TypeArguments& type_arguments = TypeArguments::Handle(
+ TypeArguments& type_arguments = TypeArguments::Handle(isolate(),
ParseTypeArguments(ClassFinalizer::kCanonicalize));
// Malformed type arguments are mapped to dynamic, so we will not encounter
// them here.
@@ -9964,7 +10006,7 @@
ASSERT(CurrentToken() == Token::kHASH);
ConsumeToken();
intptr_t symbol_pos = TokenPos();
- String& symbol = String::Handle();
+ String& symbol = String::Handle(isolate());
if (IsIdentifier()) {
symbol = CurrentLiteral()->raw();
ConsumeToken();
@@ -9982,18 +10024,19 @@
}
// Lookup class Symbol from internal library and call the
// constructor to create a symbol instance.
- const Library& lib = Library::Handle(Library::InternalLibrary());
- const Class& symbol_class = Class::Handle(lib.LookupClass(Symbols::Symbol()));
+ const Library& lib = Library::Handle(isolate(), Library::InternalLibrary());
+ const Class& symbol_class = Class::Handle(isolate(),
+ lib.LookupClass(Symbols::Symbol()));
ASSERT(!symbol_class.IsNull());
- ArgumentListNode* constr_args = new ArgumentListNode(symbol_pos);
- constr_args->Add(new LiteralNode(
+ ArgumentListNode* constr_args = new(isolate()) ArgumentListNode(symbol_pos);
+ constr_args->Add(new(isolate()) LiteralNode(
symbol_pos, String::ZoneHandle(Symbols::New(symbol))));
const Function& constr = Function::ZoneHandle(
symbol_class.LookupConstructor(Symbols::SymbolCtor()));
ASSERT(!constr.IsNull());
- const Object& result = Object::Handle(
+ const Object& result = Object::Handle(isolate(),
EvaluateConstConstructorCall(symbol_class,
- TypeArguments::Handle(),
+ TypeArguments::Handle(isolate()),
constr,
constr_args));
if (result.IsUnhandledException()) {
@@ -10002,7 +10045,8 @@
"error executing const Symbol constructor");
}
const Instance& instance = Instance::Cast(result);
- return new LiteralNode(symbol_pos, Instance::ZoneHandle(instance.raw()));
+ return new(isolate()) LiteralNode(symbol_pos,
+ Instance::ZoneHandle(instance.raw()));
}
@@ -10032,20 +10076,21 @@
intptr_t type_pos = TokenPos();
// Can't allocate const objects of a deferred type.
const bool allow_deferred_type = !is_const;
- AbstractType& type = AbstractType::Handle(
+ AbstractType& type = AbstractType::Handle(isolate(),
ParseType(ClassFinalizer::kCanonicalizeWellFormed, allow_deferred_type));
// In case the type is malformed, throw a dynamic type error after finishing
// parsing the instance creation expression.
if (!type.IsMalformed() && (type.IsTypeParameter() || type.IsDynamicType())) {
// Replace the type with a malformed type.
type = ClassFinalizer::NewFinalizedMalformedType(
- Error::Handle(), // No previous error.
+ Error::Handle(isolate()), // No previous error.
script_,
type_pos,
"%s'%s' cannot be instantiated",
type.IsTypeParameter() ? "type parameter " : "",
type.IsTypeParameter() ?
- String::Handle(type.UserVisibleName()).ToCString() : "dynamic");
+ String::Handle(isolate(), type.UserVisibleName()).ToCString() :
+ "dynamic");
}
// The grammar allows for an optional ('.' identifier)? after the type, which
@@ -10067,15 +10112,15 @@
// malbounded type or report a compile-time error if the constructor is const.
if (type.IsMalformedOrMalbounded()) {
if (is_const) {
- const Error& error = Error::Handle(type.error());
+ const Error& error = Error::Handle(isolate(), type.error());
ErrorMsg(error);
}
return ThrowTypeError(type_pos, type);
}
// Resolve the type and optional identifier to a constructor or factory.
- Class& type_class = Class::Handle(type.type_class());
- String& type_class_name = String::Handle(type_class.Name());
+ Class& type_class = Class::Handle(isolate(), type.type_class());
+ String& type_class_name = String::Handle(isolate(), type_class.Name());
TypeArguments& type_arguments =
TypeArguments::ZoneHandle(type.arguments());
@@ -10102,13 +10147,13 @@
// compile-time error if the constructor is const.
if (is_const) {
type = ClassFinalizer::NewFinalizedMalformedType(
- Error::Handle(), // No previous error.
+ Error::Handle(isolate()), // No previous error.
script_,
call_pos,
"class '%s' has no constructor or factory named '%s'",
- String::Handle(type_class.Name()).ToCString(),
+ String::Handle(isolate(), type_class.Name()).ToCString(),
external_constructor_name.ToCString());
- ErrorMsg(Error::Handle(type.error()));
+ ErrorMsg(Error::Handle(isolate(), type.error()));
}
return ThrowNoSuchMethodError(call_pos,
type_class,
@@ -10119,12 +10164,13 @@
&constructor);
} else if (constructor.IsRedirectingFactory()) {
ClassFinalizer::ResolveRedirectingFactory(type_class, constructor);
- Type& redirect_type = Type::Handle(constructor.RedirectionType());
+ Type& redirect_type = Type::Handle(isolate(),
+ constructor.RedirectionType());
if (!redirect_type.IsMalformedOrMalbounded() &&
!redirect_type.IsInstantiated()) {
// The type arguments of the redirection type are instantiated from the
// type arguments of the parsed type of the 'new' or 'const' expression.
- Error& error = Error::Handle();
+ Error& error = Error::Handle(isolate());
redirect_type ^= redirect_type.InstantiateFrom(type_arguments, &error);
if (!error.IsNull()) {
redirect_type = ClassFinalizer::NewFinalizedMalformedType(
@@ -10132,12 +10178,13 @@
script_,
call_pos,
"redirecting factory type '%s' cannot be instantiated",
- String::Handle(redirect_type.UserVisibleName()).ToCString());
+ String::Handle(isolate(),
+ redirect_type.UserVisibleName()).ToCString());
}
}
if (redirect_type.IsMalformedOrMalbounded()) {
if (is_const) {
- ErrorMsg(Error::Handle(redirect_type.error()));
+ ErrorMsg(Error::Handle(isolate(), redirect_type.error()));
}
return ThrowTypeError(redirect_type.token_pos(), redirect_type);
}
@@ -10164,14 +10211,15 @@
ASSERT(!constructor.IsNull());
if (type_class.is_abstract() && !constructor.IsFactory()) {
// Evaluate arguments before throwing.
- LetNode* result = new LetNode(call_pos);
+ LetNode* result = new(isolate()) LetNode(call_pos);
for (intptr_t i = 0; i < arguments->length(); ++i) {
result->AddNode(arguments->NodeAt(i));
}
- ArgumentListNode* error_arguments = new ArgumentListNode(type_pos);
- error_arguments->Add(new LiteralNode(
+ ArgumentListNode* error_arguments =
+ new(isolate()) ArgumentListNode(type_pos);
+ error_arguments->Add(new(isolate()) LiteralNode(
TokenPos(), Integer::ZoneHandle(Integer::New(type_pos))));
- error_arguments->Add(new LiteralNode(
+ error_arguments->Add(new(isolate()) LiteralNode(
TokenPos(), String::ZoneHandle(type_class_name.raw())));
result->AddNode(
MakeStaticCall(Symbols::AbstractClassInstantiationError(),
@@ -10179,7 +10227,7 @@
error_arguments));
return result;
}
- String& error_message = String::Handle();
+ String& error_message = String::Handle(isolate());
if (!constructor.AreValidArguments(arguments_length,
arguments->names(),
&error_message)) {
@@ -10190,7 +10238,7 @@
"invalid arguments passed to constructor '%s' "
"for class '%s': %s",
external_constructor_name.ToCString(),
- String::Handle(type_class.Name()).ToCString(),
+ String::Handle(isolate(), type_class.Name()).ToCString(),
error_message.ToCString());
}
return ThrowNoSuchMethodError(call_pos,
@@ -10206,7 +10254,7 @@
// compile-time error if the constructor is const.
if (type.IsMalformedOrMalbounded()) {
if (is_const) {
- ErrorMsg(Error::Handle(type.error()));
+ ErrorMsg(Error::Handle(isolate(), type.error()));
}
return ThrowTypeError(type_pos, type);
}
@@ -10221,7 +10269,7 @@
"const object creation",
external_constructor_name.ToCString());
}
- const Object& constructor_result = Object::Handle(
+ const Object& constructor_result = Object::Handle(isolate(),
EvaluateConstConstructorCall(type_class,
type_arguments,
constructor,
@@ -10235,23 +10283,24 @@
} else {
// Const constructors can return null in the case where a const native
// factory returns a null value. Thus we cannot use a Instance::Cast here.
- Instance& const_instance = Instance::Handle();
+ Instance& const_instance = Instance::Handle(isolate());
const_instance ^= constructor_result.raw();
- new_object = new LiteralNode(new_pos,
+ new_object = new(isolate()) LiteralNode(new_pos,
Instance::ZoneHandle(const_instance.raw()));
if (!type_bound.IsNull()) {
ASSERT(!type_bound.IsMalformed());
- Error& malformed_error = Error::Handle();
+ Error& malformed_error = Error::Handle(isolate());
ASSERT(!is_top_level_); // We cannot check unresolved types.
if (!const_instance.IsInstanceOf(type_bound,
- TypeArguments::Handle(),
+ TypeArguments::Handle(isolate()),
&malformed_error)) {
type_bound = ClassFinalizer::NewFinalizedMalformedType(
malformed_error,
script_,
new_pos,
"const factory result is not an instance of '%s'",
- String::Handle(type_bound.UserVisibleName()).ToCString());
+ String::Handle(isolate(),
+ type_bound.UserVisibleName()).ToCString());
new_object = ThrowTypeError(new_pos, type_bound);
}
type_bound = AbstractType::null();
@@ -10271,10 +10320,8 @@
new_pos, type_arguments, constructor, arguments);
}
if (!type_bound.IsNull()) {
- new_object = new AssignableNode(new_pos,
- new_object,
- type_bound,
- Symbols::FactoryResult());
+ new_object = new(isolate()) AssignableNode(
+ new_pos, new_object, type_bound, Symbols::FactoryResult());
}
return new_object;
}
@@ -10332,7 +10379,7 @@
(l1_token != Token::kINTERPOL_VAR) &&
(l1_token != Token::kINTERPOL_START)) {
// Common case: no interpolation.
- primary = new LiteralNode(literal_start, *CurrentLiteral());
+ primary = new(isolate()) LiteralNode(literal_start, *CurrentLiteral());
ConsumeToken();
return primary;
}
@@ -10344,7 +10391,8 @@
if (CurrentLiteral()->Length() > 0) {
// Only add non-empty string sections to the values list
// that will be concatenated.
- values_list.Add(new LiteralNode(TokenPos(), *CurrentLiteral()));
+ values_list.Add(new(isolate()) LiteralNode(TokenPos(),
+ *CurrentLiteral()));
}
ConsumeToken();
while ((CurrentToken() == Token::kINTERPOL_VAR) ||
@@ -10378,7 +10426,8 @@
const_expr->IsBool() ||
const_expr->IsNull())) {
// Change expr into a literal.
- expr = new LiteralNode(expr_pos, EvaluateConstExpr(expr_pos, expr));
+ expr = new(isolate()) LiteralNode(expr_pos,
+ EvaluateConstExpr(expr_pos, expr));
} else {
is_compiletime_const = false;
}
@@ -10388,9 +10437,11 @@
}
if (is_compiletime_const) {
if (has_interpolation) {
- primary = new LiteralNode(literal_start, Interpolate(values_list));
+ primary = new(isolate()) LiteralNode(
+ literal_start, Interpolate(values_list));
} else {
- const Array& strings = Array::Handle(Array::New(values_list.length()));
+ const Array& strings = Array::Handle(isolate(),
+ Array::New(values_list.length()));
for (int i = 0; i < values_list.length(); i++) {
const Instance& part = values_list[i]->AsLiteralNode()->literal();
ASSERT(part.IsString());
@@ -10398,14 +10449,14 @@
}
String& lit = String::ZoneHandle(String::ConcatAll(strings, Heap::kOld));
lit = Symbols::New(lit);
- primary = new LiteralNode(literal_start, lit);
+ primary = new(isolate()) LiteralNode(literal_start, lit);
}
} else {
- ArrayNode* values = new ArrayNode(
+ ArrayNode* values = new(isolate()) ArrayNode(
TokenPos(),
Type::ZoneHandle(Type::ArrayType()),
values_list);
- primary = new StringInterpolateNode(TokenPos(), values);
+ primary = new(isolate()) StringInterpolateNode(TokenPos(), values);
}
return primary;
}
@@ -10434,7 +10485,7 @@
TypeParameter& type_param = TypeParameter::ZoneHandle(
current_class().LookupTypeParameter(*(qual_ident.ident)));
if (!type_param.IsNull()) {
- return new PrimaryNode(qual_ident.ident_pos, type_param);
+ return new(isolate()) PrimaryNode(qual_ident.ident_pos, type_param);
}
}
// This is a non-local unqualified identifier so resolve the
@@ -10462,7 +10513,8 @@
// let ParseSelectors() handle the loadLibrary call.
SetPosition(qual_ident_pos);
ConsumeToken(); // Prefix name.
- primary = new LiteralNode(qual_ident_pos, *qual_ident.lib_prefix);
+ primary = new(isolate()) LiteralNode(
+ qual_ident_pos, *qual_ident.lib_prefix);
} else {
// TODO(hausner): Ideally we should generate the NoSuchMethodError
// later, when we know more about how the unresolved name is used.
@@ -10498,20 +10550,20 @@
if (local == NULL) {
ErrorMsg("receiver 'this' is not in scope");
}
- primary = new LoadLocalNode(TokenPos(), local);
+ primary = new(isolate()) LoadLocalNode(TokenPos(), local);
ConsumeToken();
} else if (CurrentToken() == Token::kINTEGER) {
const Integer& literal = Integer::ZoneHandle(CurrentIntegerLiteral());
- primary = new LiteralNode(TokenPos(), literal);
+ primary = new(isolate()) LiteralNode(TokenPos(), literal);
ConsumeToken();
} else if (CurrentToken() == Token::kTRUE) {
- primary = new LiteralNode(TokenPos(), Bool::True());
+ primary = new(isolate()) LiteralNode(TokenPos(), Bool::True());
ConsumeToken();
} else if (CurrentToken() == Token::kFALSE) {
- primary = new LiteralNode(TokenPos(), Bool::False());
+ primary = new(isolate()) LiteralNode(TokenPos(), Bool::False());
ConsumeToken();
} else if (CurrentToken() == Token::kNULL) {
- primary = new LiteralNode(TokenPos(), Instance::ZoneHandle());
+ primary = new(isolate()) LiteralNode(TokenPos(), Instance::ZoneHandle());
ConsumeToken();
} else if (CurrentToken() == Token::kLPAREN) {
ConsumeToken();
@@ -10524,7 +10576,7 @@
if (double_value.IsNull()) {
ErrorMsg("invalid double literal");
}
- primary = new LiteralNode(TokenPos(), double_value);
+ primary = new(isolate()) LiteralNode(TokenPos(), double_value);
ConsumeToken();
} else if (CurrentToken() == Token::kSTRING) {
primary = ParseStringLiteral(true);
@@ -10557,13 +10609,13 @@
}
if (current_class().SuperClass() == Class::null()) {
ErrorMsg("class '%s' does not have a superclass",
- String::Handle(current_class().Name()).ToCString());
+ String::Handle(isolate(), current_class().Name()).ToCString());
}
if (current_class().IsMixinApplication()) {
- const Type& mixin_type = Type::Handle(current_class().mixin());
+ const Type& mixin_type = Type::Handle(isolate(), current_class().mixin());
if (mixin_type.type_class() == current_function().origin()) {
ErrorMsg("method of mixin class '%s' may not refer to 'super'",
- String::Handle(Class::Handle(
+ String::Handle(isolate(), Class::Handle(isolate(),
current_function().origin()).Name()).ToCString());
}
}
@@ -10583,7 +10635,7 @@
(CurrentToken() == Token::kNE)) {
primary = ParseSuperOperator();
} else {
- primary = new PrimaryNode(super_pos, Symbols::Super());
+ primary = new(isolate()) PrimaryNode(super_pos, Symbols::Super());
}
} else {
UnexpectedToken();
@@ -10610,14 +10662,15 @@
return Instance::ZoneHandle(field.value());
} else {
ASSERT(expr->EvalConstExpr() != NULL);
- ReturnNode* ret = new ReturnNode(expr->token_pos(), expr);
+ ReturnNode* ret = new(isolate()) ReturnNode(expr->token_pos(), expr);
// Compile time constant expressions cannot reference anything from a
// local scope.
- LocalScope* empty_scope = new LocalScope(NULL, 0, 0);
- SequenceNode* seq = new SequenceNode(expr->token_pos(), empty_scope);
+ LocalScope* empty_scope = new(isolate()) LocalScope(NULL, 0, 0);
+ SequenceNode* seq = new(isolate()) SequenceNode(expr->token_pos(),
+ empty_scope);
seq->Add(ret);
- Object& result = Object::Handle(Compiler::ExecuteOnce(seq));
+ Object& result = Object::Handle(isolate(), Compiler::ExecuteOnce(seq));
if (result.IsError()) {
AppendErrorMsg(Error::Cast(result),
expr_pos,
« no previous file with comments | « runtime/vm/native_entry.cc ('k') | runtime/vm/runtime_entry_arm.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698