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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: vm/parser.cc

Issue 10632009: Make the parser agnostic to the TokenStream implementation. This is the first step towards compacti… (Closed) Base URL: http://dart.googlecode.com/svn/branches/bleeding_edge/dart/runtime/
Patch Set: Created 8 years, 6 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 | « vm/parser.h ('k') | vm/raw_object.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: vm/parser.cc
===================================================================
--- vm/parser.cc (revision 9042)
+++ vm/parser.cc (working copy)
@@ -59,13 +59,13 @@
class TraceParser : public ValueObject {
public:
- TraceParser(intptr_t token_index, const Script& script, const char* msg) {
+ TraceParser(intptr_t token_pos, const Script& script, const char* msg) {
if (FLAG_trace_parser) {
intptr_t line, column;
- script.GetTokenLocation(token_index, &line, &column);
+ script.GetTokenLocation(token_pos, &line, &column);
PrintIndent();
OS::Print("%s (line %d, col %d, token %d)\n",
- msg, line, column, token_index);
+ msg, line, column, token_pos);
indent_++;
}
}
@@ -80,7 +80,7 @@
int TraceParser::indent_ = 0;
#define TRACE_PARSER(s) \
- TraceParser __p__(this->token_index_, this->script_, s)
+ TraceParser __p__(this->TokenPos(), this->script_, s)
#else // not DEBUG
#define TRACE_PARSER(s)
@@ -112,8 +112,8 @@
}
-LocalVariable* ParsedFunction::CreateExpressionTempVar(intptr_t token_index) {
- return new LocalVariable(token_index,
+LocalVariable* ParsedFunction::CreateExpressionTempVar(intptr_t token_pos) {
+ return new LocalVariable(token_pos,
String::ZoneHandle(String::NewSymbol(":expr_temp")),
Type::ZoneHandle(Type::DynamicType()));
}
@@ -182,7 +182,7 @@
const String& context_var_name = String::ZoneHandle(
String::NewSymbol(LocalVariable::kSavedContextVarName));
LocalVariable* context_var =
- new LocalVariable(function().token_index(),
+ new LocalVariable(function().token_pos(),
context_var_name,
Type::ZoneHandle(Type::DynamicType()));
context_var->set_index(next_free_frame_index--);
@@ -196,6 +196,31 @@
}
+bool TokenStreamIterator::IsValid() const {
+ return !tokens_.IsNull();
+}
+
+
+Token::Kind TokenStreamIterator::CurrentTokenKind() const {
+ return tokens_.KindAt(token_position_);
+}
+
+
+Token::Kind TokenStreamIterator::LookaheadTokenKind(intptr_t num_tokens) const {
+ return tokens_.KindAt(token_position_ + num_tokens);
+}
+
+
+RawObject* TokenStreamIterator::CurrentToken() const {
+ return tokens_.TokenAt(token_position_);
+}
+
+
+RawString* TokenStreamIterator::CurrentLiteral() const {
+ return tokens_.LiteralAt(token_position_);
+}
+
+
struct Parser::Block : public ZoneAllocated {
Block(Block* outer_block, LocalScope* local_scope, SequenceNode* seq)
: parent(outer_block), scope(local_scope), statements(seq) {
@@ -247,8 +272,8 @@
Parser::Parser(const Script& script,
const Library& library)
: script_(script),
- tokens_(TokenStream::Handle(script.tokens())),
- token_index_(0),
+ tokens_iterator_(TokenStream::Handle(script.tokens()), 0),
+ token_kind_(Token::kILLEGAL),
current_block_(NULL),
is_top_level_(false),
current_member_(NULL),
@@ -258,19 +283,18 @@
library_(library),
try_blocks_list_(NULL),
expression_temp_(NULL) {
- ASSERT(!tokens_.IsNull());
+ ASSERT(tokens_iterator_.IsValid());
ASSERT(!library.IsNull());
- SetPosition(0);
}
// For parsing a function.
Parser::Parser(const Script& script,
const Function& function,
- intptr_t token_index)
+ intptr_t token_position)
: script_(script),
- tokens_(TokenStream::Handle(script.tokens())),
- token_index_(0),
+ tokens_iterator_(TokenStream::Handle(script.tokens()), token_position),
+ token_kind_(Token::kILLEGAL),
current_block_(NULL),
is_top_level_(false),
current_member_(NULL),
@@ -280,9 +304,8 @@
library_(Library::Handle(current_class_.library())),
try_blocks_list_(NULL),
expression_temp_(NULL) {
- ASSERT(!tokens_.IsNull());
+ ASSERT(tokens_iterator_.IsValid());
ASSERT(!function.IsNull());
- SetPosition(token_index);
if (FLAG_enable_type_checks) {
EnsureExpressionTemp();
}
@@ -312,10 +335,10 @@
void Parser::SetPosition(intptr_t position) {
- if (position < token_index_ && position != 0) {
- CompilerStats::num_tokens_rewind += (token_index_ - position);
+ if (position < TokenPos() && position != 0) {
+ CompilerStats::num_tokens_rewind += (TokenPos() - position);
}
- token_index_ = position;
+ tokens_iterator_.SetCurrentPosition(position);
token_kind_ = Token::kILLEGAL;
}
@@ -327,16 +350,16 @@
Parser parser(script, library);
parser.ParseTopLevel();
if (FLAG_compiler_stats) {
- CompilerStats::num_tokens_total += parser.tokens_.Length();
+ CompilerStats::num_tokens_total += parser.tokens_iterator_.NumberOfTokens();
}
}
Token::Kind Parser::CurrentToken() {
if (token_kind_ == Token::kILLEGAL) {
- token_kind_ = tokens_.KindAt(token_index_);
+ token_kind_ = tokens_iterator_.CurrentTokenKind();
if (token_kind_ == Token::kERROR) {
- ErrorMsg(token_index_, CurrentLiteral()->ToCString());
+ ErrorMsg(TokenPos(), CurrentLiteral()->ToCString());
}
}
CompilerStats::num_token_checks++;
@@ -347,20 +370,20 @@
Token::Kind Parser::LookaheadToken(int num_tokens) {
CompilerStats::num_tokens_lookahead++;
CompilerStats::num_token_checks++;
- return tokens_.KindAt(token_index_ + num_tokens);
+ return tokens_iterator_.LookaheadTokenKind(num_tokens);
}
String* Parser::CurrentLiteral() const {
String& result = String::ZoneHandle();
- result ^= tokens_.LiteralAt(token_index_);
+ result ^= tokens_iterator_.CurrentLiteral();
return &result;
}
RawDouble* Parser::CurrentDoubleLiteral() const {
LiteralToken& token = LiteralToken::Handle();
- token ^= tokens_.TokenAt(token_index_);
+ token ^= tokens_iterator_.CurrentToken();
ASSERT(token.kind() == Token::kDOUBLE);
return reinterpret_cast<RawDouble*>(token.value());
}
@@ -368,7 +391,7 @@
RawInteger* Parser::CurrentIntegerLiteral() const {
LiteralToken& token = LiteralToken::Handle();
- token ^= tokens_.TokenAt(token_index_);
+ token ^= tokens_iterator_.CurrentToken();
ASSERT(token.kind() == Token::kINTEGER);
return reinterpret_cast<RawInteger*>(token.value());
}
@@ -676,7 +699,7 @@
const Function& func = parsed_function->function();
const Class& cls = Class::Handle(isolate, func.owner());
const Script& script = Script::Handle(isolate, cls.script());
- Parser parser(script, func, func.token_index());
+ Parser parser(script, func, func.token_pos());
SequenceNode* node_sequence = NULL;
Array& default_parameter_values = Array::Handle(isolate, Array::null());
switch (func.kind()) {
@@ -704,7 +727,7 @@
if (!HasReturnNode(node_sequence)) {
// Add implicit return node.
- node_sequence->Add(new ReturnNode(parser.token_index_));
+ node_sequence->Add(new ReturnNode(parser.TokenPos()));
}
if (parser.expression_temp_ != NULL) {
parsed_function->set_expression_temp_var(parser.expression_temp_);
@@ -726,7 +749,7 @@
if (!parser.current_function().IsLocalFunction() ||
((receiver != NULL) && receiver->is_captured())) {
parsed_function->set_instantiator(
- new LoadLocalNode(node_sequence->token_index(), *receiver));
+ new LoadLocalNode(node_sequence->token_pos(), *receiver));
}
}
@@ -764,14 +787,14 @@
// fragment to evaluate the expression. Instead, we just make sure
// the static const field initializer is a constant expression and
// leave the evaluation to the getter function.
- const intptr_t expr_pos = token_index_;
+ const intptr_t expr_pos = TokenPos();
AstNode* expr = ParseExpr(kAllowConst);
if (field.is_const()) {
// This getter will only be called once at compile time.
if (expr->EvalConstExpr() == NULL) {
ErrorMsg(expr_pos, "initializer must be a compile time constant");
}
- ReturnNode* return_node = new ReturnNode(token_index_, expr);
+ ReturnNode* return_node = new ReturnNode(TokenPos(), expr);
current_block_->statements->Add(return_node);
} else {
// This getter may be called each time the static field is accessed.
@@ -793,55 +816,55 @@
// Generate code checking for circular dependency in field initialization.
AstNode* compare_circular = new ComparisonNode(
- token_index_,
+ TokenPos(),
Token::kEQ_STRICT,
- new LoadStaticFieldNode(token_index_, field),
- new LiteralNode(token_index_,
+ new LoadStaticFieldNode(TokenPos(), field),
+ new LiteralNode(TokenPos(),
Instance::ZoneHandle(Object::transition_sentinel())));
// Set field to null prior to throwing exception, so that subsequent
// accesses to the field do not throw again, since initializers should only
// be executed once.
- SequenceNode* report_circular = new SequenceNode(token_index_, NULL);
+ SequenceNode* report_circular = new SequenceNode(TokenPos(), NULL);
report_circular->Add(
new StoreStaticFieldNode(
- token_index_,
+ TokenPos(),
field,
- new LiteralNode(token_index_, Instance::ZoneHandle())));
+ new LiteralNode(TokenPos(), Instance::ZoneHandle())));
// TODO(regis): Exception to throw is not specified by spec.
const String& circular_error = String::ZoneHandle(
String::NewSymbol("circular dependency in field initialization"));
report_circular->Add(
- new ThrowNode(token_index_,
- new LiteralNode(token_index_, circular_error),
+ new ThrowNode(TokenPos(),
+ new LiteralNode(TokenPos(), circular_error),
NULL));
AstNode* circular_check =
- new IfNode(token_index_, compare_circular, report_circular, NULL);
+ new IfNode(TokenPos(), compare_circular, report_circular, NULL);
current_block_->statements->Add(circular_check);
// Generate code checking for uninitialized field.
AstNode* compare_uninitialized = new ComparisonNode(
- token_index_,
+ TokenPos(),
Token::kEQ_STRICT,
- new LoadStaticFieldNode(token_index_, field),
- new LiteralNode(token_index_,
+ new LoadStaticFieldNode(TokenPos(), field),
+ new LiteralNode(TokenPos(),
Instance::ZoneHandle(Object::sentinel())));
- SequenceNode* initialize_field = new SequenceNode(token_index_, NULL);
+ SequenceNode* initialize_field = new SequenceNode(TokenPos(), NULL);
initialize_field->Add(
new StoreStaticFieldNode(
- token_index_,
+ TokenPos(),
field,
new LiteralNode(
- token_index_,
+ TokenPos(),
Instance::ZoneHandle(Object::transition_sentinel()))));
- initialize_field->Add(new StoreStaticFieldNode(token_index_, field, expr));
+ initialize_field->Add(new StoreStaticFieldNode(TokenPos(), field, expr));
AstNode* uninitialized_check =
- new IfNode(token_index_, compare_uninitialized, initialize_field, NULL);
+ new IfNode(TokenPos(), compare_uninitialized, initialize_field, NULL);
current_block_->statements->Add(uninitialized_check);
// Generate code returning the field value.
ReturnNode* return_node =
- new ReturnNode(token_index_,
- new LoadStaticFieldNode(token_index_, field));
+ new ReturnNode(TokenPos(),
+ new LoadStaticFieldNode(TokenPos(), field));
current_block_->statements->Add(return_node);
}
return CloseBlock();
@@ -855,7 +878,7 @@
SequenceNode* Parser::ParseInstanceGetter(const Function& func) {
TRACE_PARSER("ParseInstanceGetter");
ParamList params;
- params.AddReceiver(token_index_);
+ params.AddReceiver(TokenPos());
ASSERT(func.num_fixed_parameters() == 1); // receiver.
ASSERT(func.num_optional_parameters() == 0);
ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
@@ -866,9 +889,9 @@
// Receiver is local 0.
LocalVariable* receiver = current_block_->scope->VariableAt(0);
- LoadLocalNode* load_receiver = new LoadLocalNode(token_index_, *receiver);
- // token_index_ is the function's token position which points to the name of
- // the field;
+ LoadLocalNode* load_receiver = new LoadLocalNode(TokenPos(), *receiver);
+ // TokenPos() returns the function's token position which points to the
+ // name of the field;
ASSERT(IsIdentifier());
const String& field_name = *CurrentLiteral();
const Class& field_class = Class::Handle(func.owner());
@@ -876,9 +899,9 @@
Field::ZoneHandle(field_class.LookupInstanceField(field_name));
LoadInstanceFieldNode* load_field =
- new LoadInstanceFieldNode(token_index_, load_receiver, field);
+ new LoadInstanceFieldNode(TokenPos(), load_receiver, field);
- ReturnNode* return_node = new ReturnNode(token_index_, load_field);
+ ReturnNode* return_node = new ReturnNode(TokenPos(), load_field);
current_block_->statements->Add(return_node);
return CloseBlock();
}
@@ -891,8 +914,8 @@
// ReturnNode (void);
SequenceNode* Parser::ParseInstanceSetter(const Function& func) {
TRACE_PARSER("ParseInstanceSetter");
- // token_index_ is the function's token position which points to the name of
- // the field; we can use it to form the field_name.
+ // TokenPos() returns the function's token position which points to
+ // the name of the field; we can use it to form the field_name.
const String& field_name = *CurrentLiteral();
const Class& field_class = Class::ZoneHandle(func.owner());
const Field& field =
@@ -900,8 +923,8 @@
const AbstractType& field_type = AbstractType::ZoneHandle(field.type());
ParamList params;
- params.AddReceiver(token_index_);
- params.AddFinalParameter(token_index_, "value", &field_type);
+ params.AddReceiver(TokenPos());
+ params.AddFinalParameter(TokenPos(), "value", &field_type);
ASSERT(func.num_fixed_parameters() == 2); // receiver, value.
ASSERT(func.num_optional_parameters() == 0);
ASSERT(AbstractType::Handle(func.result_type()).IsVoidType());
@@ -911,15 +934,15 @@
AddFormalParamsToScope(&params, current_block_->scope);
LoadLocalNode* receiver =
- new LoadLocalNode(token_index_, *current_block_->scope->VariableAt(0));
+ new LoadLocalNode(TokenPos(), *current_block_->scope->VariableAt(0));
LoadLocalNode* value =
- new LoadLocalNode(token_index_, *current_block_->scope->VariableAt(1));
+ new LoadLocalNode(TokenPos(), *current_block_->scope->VariableAt(1));
StoreInstanceFieldNode* store_field =
- new StoreInstanceFieldNode(token_index_, receiver, field, value);
+ new StoreInstanceFieldNode(TokenPos(), receiver, field, value);
current_block_->statements->Add(store_field);
- current_block_->statements->Add(new ReturnNode(token_index_));
+ current_block_->statements->Add(new ReturnNode(TokenPos()));
return CloseBlock();
}
@@ -927,14 +950,14 @@
void Parser::SkipBlock() {
ASSERT(CurrentToken() == Token::kLBRACE);
GrowableArray<Token::Kind> token_stack(8);
- const intptr_t block_start_pos = token_index_;
+ const intptr_t block_start_pos = TokenPos();
bool is_match = true;
bool unexpected_token_found = false;
Token::Kind token;
- intptr_t token_index;
+ intptr_t token_pos;
do {
token = CurrentToken();
- token_index = token_index_;
+ token_pos = TokenPos();
switch (token) {
case Token::kLBRACE:
case Token::kLPAREN:
@@ -963,7 +986,7 @@
ConsumeToken();
} while (!token_stack.is_empty() && is_match && !unexpected_token_found);
if (!is_match) {
- ErrorMsg(token_index, "unbalanced '%s'", Token::Str(token));
+ ErrorMsg(token_pos, "unbalanced '%s'", Token::Str(token));
} else if (unexpected_token_found) {
ErrorMsg(block_start_pos, "unterminated block");
}
@@ -1035,7 +1058,7 @@
}
// At this point, we must see an identifier for the parameter name.
- parameter.name_pos = token_index_;
+ parameter.name_pos = TokenPos();
parameter.name = ExpectIdentifier("parameter name expected");
if (parameter.is_field_initializer) {
params->has_field_initializer = true;
@@ -1193,10 +1216,10 @@
}
-void Parser::CheckFunctionIsCallable(intptr_t token_index,
+void Parser::CheckFunctionIsCallable(intptr_t token_pos,
const Function& function) {
if (Class::Handle(function.owner()).is_interface()) {
- ErrorMsg(token_index, "cannot call function of interface '%s'",
+ ErrorMsg(token_pos, "cannot call function of interface '%s'",
function.ToFullyQualifiedCString());
}
}
@@ -1270,7 +1293,7 @@
const String& function_name,
const ArgumentListNode& function_args) {
ASSERT(function_args.length() >= 1); // The receiver is the first argument.
- const intptr_t args_pos = function_args.token_index();
+ const intptr_t args_pos = function_args.token_pos();
ArgumentListNode* arguments = new ArgumentListNode(args_pos);
arguments->Add(function_args.NodeAt(0));
// The second argument is the original function name.
@@ -1289,7 +1312,7 @@
AstNode* Parser::ParseSuperCall(const String& function_name) {
TRACE_PARSER("ParseSuperCall");
ASSERT(CurrentToken() == Token::kLPAREN);
- const intptr_t supercall_pos = token_index_;
+ const intptr_t supercall_pos = TokenPos();
bool is_no_such_method = false;
const Function& super_function = Function::ZoneHandle(
@@ -1322,7 +1345,7 @@
AstNode* Parser::ParseSuperOperator() {
TRACE_PARSER("ParseSuperOperator");
AstNode* super_op = NULL;
- const intptr_t operator_pos = token_index_;
+ const intptr_t operator_pos = TokenPos();
if (CurrentToken() == Token::kLBRACK) {
ConsumeToken();
@@ -1447,7 +1470,7 @@
AstNode* Parser::ParseSuperFieldAccess(const String& field_name) {
TRACE_PARSER("ParseSuperFieldAccess");
- const intptr_t field_pos = token_index_;
+ const intptr_t field_pos = TokenPos();
const Class& super_class = Class::Handle(current_class().SuperClass());
if (super_class.IsNull()) {
ErrorMsg("class '%s' does not have a superclass",
@@ -1510,7 +1533,7 @@
void Parser::GenerateSuperConstructorCall(const Class& cls,
LocalVariable* receiver) {
- const intptr_t supercall_pos = token_index_;
+ const intptr_t supercall_pos = TokenPos();
const Class& super_class = Class::Handle(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
@@ -1549,7 +1572,7 @@
LocalVariable* receiver) {
TRACE_PARSER("ParseSuperInitializer");
ASSERT(CurrentToken() == Token::kSUPER);
- const intptr_t supercall_pos = token_index_;
+ const intptr_t supercall_pos = TokenPos();
ConsumeToken();
const Class& super_class = Class::Handle(cls.SuperClass());
ASSERT(!super_class.IsNull());
@@ -1599,7 +1622,7 @@
AstNode* Parser::ParseInitializer(const Class& cls, LocalVariable* receiver) {
TRACE_PARSER("ParseInitializer");
- const intptr_t field_pos = token_index_;
+ const intptr_t field_pos = TokenPos();
if (CurrentToken() == Token::kTHIS) {
ConsumeToken();
ExpectToken(Token::kPERIOD);
@@ -1663,13 +1686,13 @@
TRACE_PARSER("ParseInitializedInstanceFields");
const Array& fields = Array::Handle(cls.fields());
Field& f = Field::Handle();
- const intptr_t saved_pos = token_index_;
+ const intptr_t saved_pos = TokenPos();
for (int i = 0; i < fields.Length(); i++) {
f ^= fields.At(i);
if (!f.is_static() && f.has_initializer()) {
Field& field = Field::ZoneHandle();
field ^= fields.At(i);
- intptr_t field_pos = field.token_index();
+ intptr_t field_pos = field.token_pos();
SetPosition(field_pos);
ASSERT(IsIdentifier());
ConsumeToken();
@@ -1730,7 +1753,7 @@
LocalVariable* receiver) {
TRACE_PARSER("ParseConstructorRedirection");
ASSERT(CurrentToken() == Token::kTHIS);
- const intptr_t call_pos = token_index_;
+ const intptr_t call_pos = TokenPos();
ConsumeToken();
String& ctor_name = String::Handle(cls.Name());
String& ctor_suffix = String::Handle(String::NewSymbol("."));
@@ -1773,7 +1796,7 @@
SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
ASSERT(func.IsConstructor());
- const intptr_t ctor_pos = token_index_;
+ const intptr_t ctor_pos = TokenPos();
// Implicit 'this' is the only parameter/local variable.
OpenFunctionBlock(func);
@@ -1800,9 +1823,9 @@
// to strore the initializer expressions in the respective instance fields.
for (int i = 0; i < initializers.length(); i++) {
const Field* field = initializers[i].inst_field;
- AstNode* instance = new LoadLocalNode(field->token_index(), *receiver);
+ AstNode* instance = new LoadLocalNode(field->token_pos(), *receiver);
AstNode* field_init =
- new StoreInstanceFieldNode(field->token_index(),
+ new StoreInstanceFieldNode(field->token_pos(),
instance,
*field,
initializers[i].expr);
@@ -1849,11 +1872,11 @@
// Add implicit receiver parameter which is passed the allocated
// but uninitialized instance to construct.
- params.AddReceiver(token_index_);
+ params.AddReceiver(TokenPos());
// Add implicit parameter for construction phase.
params.AddFinalParameter(
- token_index_,
+ TokenPos(),
kPhaseParameterName,
&Type::ZoneHandle(Type::DynamicType()));
@@ -1886,9 +1909,9 @@
OpenBlock();
for (int i = 0; i < initializers.length(); i++) {
const Field* field = initializers[i].inst_field;
- AstNode* instance = new LoadLocalNode(field->token_index(), *receiver);
+ AstNode* instance = new LoadLocalNode(field->token_pos(), *receiver);
AstNode* field_init =
- new StoreInstanceFieldNode(field->token_index(),
+ new StoreInstanceFieldNode(field->token_pos(),
instance,
*field,
initializers[i].expr);
@@ -1931,18 +1954,18 @@
if (init_statements->length() > 0) {
// Generate guard around the initializer code.
LocalVariable* phase_param = LookupPhaseParameter();
- AstNode* phase_value = new LoadLocalNode(token_index_, *phase_param);
+ AstNode* phase_value = new LoadLocalNode(TokenPos(), *phase_param);
AstNode* phase_check = new BinaryOpNode(
- token_index_, Token::kBIT_AND, phase_value,
- new LiteralNode(token_index_,
+ TokenPos(), Token::kBIT_AND, phase_value,
+ new LiteralNode(TokenPos(),
Smi::ZoneHandle(Smi::New(Function::kCtorPhaseInit))));
AstNode* comparison =
- new ComparisonNode(token_index_, Token::kNE_STRICT,
+ new ComparisonNode(TokenPos(), Token::kNE_STRICT,
phase_check,
- new LiteralNode(token_index_,
+ new LiteralNode(TokenPos(),
Smi::ZoneHandle(Smi::New(0))));
AstNode* guarded_init_statements =
- new IfNode(token_index_, comparison, init_statements, NULL);
+ new IfNode(TokenPos(), comparison, init_statements, NULL);
current_block_->statements->Add(guarded_init_statements);
}
@@ -1980,9 +2003,9 @@
AstNode* arg = ctor_args->NodeAt(i);
if (!IsSimpleLocalOrLiteralNode(arg)) {
LocalVariable* temp =
- CreateTempConstVariable(arg->token_index(), arg->id(), "sca");
+ CreateTempConstVariable(arg->token_pos(), arg->id(), "sca");
AstNode* save_temp =
- new StoreLocalNode(arg->token_index(), *temp, arg);
+ new StoreLocalNode(arg->token_pos(), *temp, arg);
ctor_args->SetNodeAt(i, save_temp);
}
}
@@ -1995,38 +2018,38 @@
const Function& super_ctor = super_call->function();
// Patch the initializer call so it only executes the super initializer.
initializer_args->SetNodeAt(1,
- new LiteralNode(token_index_,
+ new LiteralNode(TokenPos(),
Smi::ZoneHandle(Smi::New(Function::kCtorPhaseInit))));
- ArgumentListNode* super_call_args = new ArgumentListNode(token_index_);
+ ArgumentListNode* super_call_args = new ArgumentListNode(TokenPos());
// First argument is the receiver.
- super_call_args->Add(new LoadLocalNode(token_index_, *receiver));
+ super_call_args->Add(new LoadLocalNode(TokenPos(), *receiver));
// Second argument is the construction phase argument.
AstNode* phase_parameter =
- new LiteralNode(token_index_,
- Smi::ZoneHandle(Smi::New(Function::kCtorPhaseBody)));
+ new LiteralNode(TokenPos(),
+ Smi::ZoneHandle(Smi::New(Function::kCtorPhaseBody)));
super_call_args->Add(phase_parameter);
super_call_args->set_names(initializer_args->names());
for (int i = 2; i < initializer_args->length(); i++) {
AstNode* arg = initializer_args->NodeAt(i);
if (arg->IsLiteralNode()) {
LiteralNode* lit = arg->AsLiteralNode();
- super_call_args->Add(new LiteralNode(token_index_, lit->literal()));
+ super_call_args->Add(new LiteralNode(TokenPos(), lit->literal()));
} else {
ASSERT(arg->IsLoadLocalNode() || arg->IsStoreLocalNode());
if (arg->IsLoadLocalNode()) {
const LocalVariable& temp = arg->AsLoadLocalNode()->local();
- super_call_args->Add(new LoadLocalNode(token_index_, temp));
+ super_call_args->Add(new LoadLocalNode(TokenPos(), temp));
} else if (arg->IsStoreLocalNode()) {
const LocalVariable& temp = arg->AsStoreLocalNode()->local();
- super_call_args->Add(new LoadLocalNode(token_index_, temp));
+ super_call_args->Add(new LoadLocalNode(TokenPos(), temp));
}
}
}
ASSERT(super_ctor.AreValidArguments(super_call_args->length(),
super_call_args->names()));
current_block_->statements->Add(
- new StaticCallNode(token_index_, super_ctor, super_call_args));
+ new StaticCallNode(TokenPos(), super_ctor, super_call_args));
}
if (CurrentToken() == Token::kLBRACE) {
@@ -2048,19 +2071,19 @@
if (ctor_block->length() > 0) {
// Generate guard around the constructor body code.
LocalVariable* phase_param = LookupPhaseParameter();
- AstNode* phase_value = new LoadLocalNode(token_index_, *phase_param);
+ AstNode* phase_value = new LoadLocalNode(TokenPos(), *phase_param);
AstNode* phase_check =
- new BinaryOpNode(token_index_, Token::kBIT_AND,
+ new BinaryOpNode(TokenPos(), Token::kBIT_AND,
phase_value,
- new LiteralNode(token_index_,
+ new LiteralNode(TokenPos(),
Smi::ZoneHandle(Smi::New(Function::kCtorPhaseBody))));
AstNode* comparison =
- new ComparisonNode(token_index_, Token::kNE_STRICT,
+ new ComparisonNode(TokenPos(), Token::kNE_STRICT,
phase_check,
- new LiteralNode(token_index_,
+ new LiteralNode(TokenPos(),
Smi::ZoneHandle(Smi::New(0))));
AstNode* guarded_block_statements =
- new IfNode(token_index_, comparison, ctor_block, NULL);
+ new IfNode(TokenPos(), comparison, ctor_block, NULL);
current_block_->statements->Add(guarded_block_statements);
}
@@ -2092,7 +2115,7 @@
(!func.is_static() || func.IsFactory());
const bool allow_explicit_default_values = true;
if (has_receiver) {
- params.AddReceiver(token_index_);
+ params.AddReceiver(TokenPos());
}
ASSERT(CurrentToken() == Token::kLPAREN);
ParseFormalParameterList(allow_explicit_default_values, &params);
@@ -2140,7 +2163,7 @@
ExpectToken(Token::kRBRACE);
} else if (CurrentToken() == Token::kARROW) {
ConsumeToken();
- const intptr_t expr_pos = token_index_;
+ const intptr_t expr_pos = TokenPos();
AstNode* expr = ParseExpr(kAllowConst);
ASSERT(expr != NULL);
current_block_->statements->Add(new ReturnNode(expr_pos, expr));
@@ -2208,7 +2231,7 @@
TRACE_PARSER("ParseQualIdent");
ASSERT(IsIdentifier());
ASSERT(!current_class().IsNull());
- qual_ident->ident_pos = token_index_;
+ qual_ident->ident_pos = TokenPos();
qual_ident->ident = CurrentLiteral();
qual_ident->lib_prefix = NULL;
ConsumeToken();
@@ -2226,11 +2249,11 @@
const Class& scope_class = Class::Handle(TypeParametersScopeClass());
if (scope_class.IsNull() ||
(scope_class.LookupTypeParameter(*(qual_ident->ident),
- token_index_) ==
+ TokenPos()) ==
TypeParameter::null())) {
ConsumeToken(); // Consume the kPERIOD token.
qual_ident->lib_prefix = &lib_prefix;
- qual_ident->ident_pos = token_index_;
+ qual_ident->ident_pos = TokenPos();
qual_ident->ident =
ExpectIdentifier("identifier expected after '.'");
}
@@ -2243,7 +2266,7 @@
void Parser::ParseMethodOrConstructor(ClassDesc* members, MemberDesc* method) {
TRACE_PARSER("ParseMethodOrConstructor");
ASSERT(CurrentToken() == Token::kLPAREN);
- intptr_t method_pos = this->token_index_;
+ intptr_t method_pos = this->TokenPos();
ASSERT(method->type != NULL);
ASSERT(method->name_pos > 0);
ASSERT(current_member_ == method);
@@ -2286,7 +2309,7 @@
!method->has_static || method->IsConstructor() || method->has_factory;
const bool are_implicitly_final = method->has_const;
const bool allow_explicit_default_values = true;
- const intptr_t formal_param_pos = token_index_;
+ const intptr_t formal_param_pos = TokenPos();
method->params.Clear();
if (has_this_param) {
method->params.AddReceiver(formal_param_pos);
@@ -2294,7 +2317,7 @@
// Constructors have an implicit parameter for the construction phase.
if (method->IsConstructor()) {
method->params.AddFinalParameter(
- token_index_,
+ TokenPos(),
kPhaseParameterName,
&Type::ZoneHandle(Type::DynamicType()));
}
@@ -2383,7 +2406,7 @@
SkipExpr();
ExpectSemicolon();
}
- method_end_pos = token_index_;
+ method_end_pos = TokenPos();
} else if (IsLiteral("native")) {
if (method->has_abstract) {
ErrorMsg(method->name_pos,
@@ -2441,7 +2464,7 @@
method->has_const,
method_pos));
func.set_result_type(*method->type);
- func.set_end_token_index(method_end_pos);
+ func.set_end_token_pos(method_end_pos);
// No need to resolve parameter types yet, or add parameters to local scope.
ASSERT(is_top_level_);
@@ -2523,7 +2546,7 @@
field->has_static, field->has_final,
field->name_pos);
ParamList params;
- params.AddReceiver(token_index_);
+ params.AddReceiver(TokenPos());
getter.set_result_type(*field->type);
AddFormalParamsToFunction(&params, getter);
members->AddFunction(getter);
@@ -2534,8 +2557,8 @@
field->has_static, field->has_final,
field->name_pos);
ParamList params;
- params.AddReceiver(token_index_);
- params.AddFinalParameter(token_index_, "value", field->type);
+ params.AddReceiver(TokenPos());
+ params.AddFinalParameter(TokenPos(), "value", field->type);
setter.set_result_type(Type::Handle(Type::VoidType()));
AddFormalParamsToFunction(&params, setter);
members->AddFunction(setter);
@@ -2546,7 +2569,7 @@
break;
}
ConsumeToken();
- field->name_pos = this->token_index_;
+ field->name_pos = this->TokenPos();
field->name = ExpectIdentifier("field name expected");
}
ExpectSemicolon();
@@ -2668,7 +2691,7 @@
TypeArguments::Handle(),
factory_name.ident_pos));
} else {
- member.name_pos = token_index_;
+ member.name_pos = TokenPos();
member.name = CurrentLiteral();
ConsumeToken();
}
@@ -2706,7 +2729,7 @@
(LookaheadToken(1) != Token::kSEMICOLON)) {
ConsumeToken();
member.kind = RawFunction::kGetterFunction;
- member.name_pos = this->token_index_;
+ member.name_pos = this->TokenPos();
member.name = ExpectIdentifier("identifier expected");
if (CurrentToken() != Token::kLPAREN) {
ErrorMsg("'(' expected");
@@ -2719,7 +2742,7 @@
(LookaheadToken(1) != Token::kSEMICOLON)) {
ConsumeToken();
member.kind = RawFunction::kSetterFunction;
- member.name_pos = this->token_index_;
+ member.name_pos = this->TokenPos();
member.name = ExpectIdentifier("identifier expected");
if (CurrentToken() != Token::kLPAREN) {
ErrorMsg("'(' expected");
@@ -2743,13 +2766,13 @@
}
operator_token = CurrentToken();
member.kind = RawFunction::kFunction;
- member.name_pos = this->token_index_;
+ member.name_pos = this->TokenPos();
member.name =
&String::ZoneHandle(String::NewSymbol(Token::Str(operator_token)));
ConsumeToken();
} else if (IsIdentifier()) {
member.name = CurrentLiteral();
- member.name_pos = token_index_;
+ member.name_pos = TokenPos();
ConsumeToken();
} else {
ErrorMsg("identifier expected");
@@ -2797,9 +2820,9 @@
void Parser::ParseClassDefinition(const GrowableObjectArray& pending_classes) {
TRACE_PARSER("ParseClassDefinition");
- const intptr_t class_pos = token_index_;
+ const intptr_t class_pos = TokenPos();
ExpectToken(Token::kCLASS);
- const intptr_t classname_pos = token_index_;
+ const intptr_t classname_pos = TokenPos();
String& class_name = *ExpectTypeIdentifier("class name expected");
if (FLAG_trace_parser) {
OS::Print("TopLevel parsing class '%s'\n", class_name.ToCString());
@@ -2830,7 +2853,7 @@
Type& super_type = Type::Handle();
if (CurrentToken() == Token::kEXTENDS) {
ConsumeToken();
- const intptr_t type_pos = token_index_;
+ const intptr_t type_pos = TokenPos();
const AbstractType& type = AbstractType::Handle(
ParseType(ClassFinalizer::kTryResolve));
if (type.IsTypeParameter()) {
@@ -2855,7 +2878,7 @@
if (CurrentToken() == Token::kIMPLEMENTS) {
Array& interfaces = Array::Handle();
- const intptr_t interfaces_pos = token_index_;
+ const intptr_t interfaces_pos = TokenPos();
interfaces = ParseInterfaceList();
AddInterfaces(interfaces_pos, cls, interfaces);
}
@@ -2902,10 +2925,10 @@
class_desc->token_pos()));
ParamList params;
// Add implicit 'this' parameter.
- params.AddReceiver(token_index_);
+ params.AddReceiver(TokenPos());
// Add implicit parameter for construction phase.
params.AddFinalParameter(
- token_index_,
+ TokenPos(),
kPhaseParameterName,
&Type::ZoneHandle(Type::DynamicType()));
@@ -2952,7 +2975,7 @@
if (IsIdentifier() && (LookaheadToken(1) == Token::kLPAREN)) {
return true;
}
- const intptr_t saved_pos = token_index_;
+ const intptr_t saved_pos = TokenPos();
bool is_alias_name = false;
if (IsIdentifier() && (LookaheadToken(1) == Token::kLT)) {
ConsumeToken();
@@ -2975,7 +2998,7 @@
const Class& alias_owner = Class::Handle(
Class::New(String::Handle(String::NewSymbol(":alias_owner")),
Script::Handle(),
- token_index_));
+ TokenPos()));
alias_owner.set_is_interface();
alias_owner.set_library(library_);
set_current_class(alias_owner);
@@ -2991,7 +3014,7 @@
result_type = ParseType(ClassFinalizer::kDoNotResolve);
}
- const intptr_t alias_name_pos = token_index_;
+ const intptr_t alias_name_pos = TokenPos();
const String* alias_name =
ExpectTypeIdentifier("function alias name expected");
@@ -3070,9 +3093,9 @@
void Parser::ParseInterfaceDefinition(
const GrowableObjectArray& pending_classes) {
TRACE_PARSER("ParseInterfaceDefinition");
- const intptr_t interface_pos = token_index_;
+ const intptr_t interface_pos = TokenPos();
ExpectToken(Token::kINTERFACE);
- const intptr_t interfacename_pos = token_index_;
+ const intptr_t interfacename_pos = TokenPos();
String& interface_name = *ExpectTypeIdentifier("interface name expected");
if (FLAG_trace_parser) {
OS::Print("TopLevel parsing interface '%s'\n", interface_name.ToCString());
@@ -3105,7 +3128,7 @@
if (CurrentToken() == Token::kEXTENDS) {
Array& interfaces = Array::Handle();
- const intptr_t interfaces_pos = token_index_;
+ const intptr_t interfaces_pos = TokenPos();
interfaces = ParseInterfaceList();
AddInterfaces(interfaces_pos, interface, interfaces);
}
@@ -3246,7 +3269,7 @@
type_parameter = TypeParameter::New(cls,
index,
type_parameter_name,
- token_index_);
+ TokenPos());
// Check for duplicate type parameters.
for (intptr_t i = 0; i < index; i++) {
existing_type_parameter ^= type_parameters_array.At(i);
@@ -3343,7 +3366,7 @@
AbstractType& other_interface = AbstractType::Handle();
do {
ConsumeToken();
- intptr_t supertype_pos = token_index_;
+ intptr_t supertype_pos = TokenPos();
interface = ParseType(ClassFinalizer::kTryResolve);
interface_name = interface.Name();
for (int i = 0; i < interfaces.Length(); i++) {
@@ -3415,7 +3438,7 @@
Field& field = Field::Handle();
Function& getter = Function::Handle();
while (true) {
- const intptr_t name_pos = token_index_;
+ const intptr_t name_pos = TokenPos();
String& var_name = *ExpectIdentifier("variable name expected");
if (library_.LookupObject(var_name) != Object::null()) {
@@ -3477,7 +3500,7 @@
result_type = ParseType(ClassFinalizer::kTryResolve);
}
}
- const intptr_t name_pos = token_index_;
+ const intptr_t name_pos = TokenPos();
const String& func_name = *ExpectIdentifier("function name expected");
if (library_.LookupObject(func_name) != Object::null()) {
@@ -3497,7 +3520,7 @@
if (CurrentToken() != Token::kLPAREN) {
ErrorMsg("'(' expected");
}
- const intptr_t function_pos = token_index_;
+ const intptr_t function_pos = TokenPos();
ParamList params;
const bool allow_explicit_default_values = true;
ParseFormalParameterList(allow_explicit_default_values, &params);
@@ -3505,12 +3528,12 @@
intptr_t function_end_pos = function_pos;
if (CurrentToken() == Token::kLBRACE) {
SkipBlock();
- function_end_pos = token_index_;
+ function_end_pos = TokenPos();
} else if (CurrentToken() == Token::kARROW) {
ConsumeToken();
SkipExpr();
ExpectSemicolon();
- function_end_pos = token_index_;
+ function_end_pos = TokenPos();
} else if (IsLiteral("native")) {
ParseNativeDeclaration();
} else {
@@ -3520,7 +3543,7 @@
Function::New(func_name, RawFunction::kFunction,
is_static, false, function_pos));
func.set_result_type(result_type);
- func.set_end_token_index(function_end_pos);
+ func.set_end_token_pos(function_end_pos);
AddFormalParamsToFunction(&params, func);
top_level->functions.Add(func);
library_.AddObject(func, func_name);
@@ -3550,13 +3573,13 @@
UnexpectedToken();
}
}
- const intptr_t name_pos = token_index_;
+ const intptr_t name_pos = TokenPos();
const String* field_name = ExpectIdentifier("accessor name expected");
if (CurrentToken() != Token::kLPAREN) {
ErrorMsg("'(' expected");
}
- const intptr_t accessor_pos = token_index_;
+ const intptr_t accessor_pos = TokenPos();
ParamList params;
const bool allow_explicit_default_values = true;
ParseFormalParameterList(allow_explicit_default_values, &params);
@@ -3653,7 +3676,7 @@
void Parser::ParseLibraryImport() {
TRACE_PARSER("ParseLibraryImport");
while (CurrentToken() == Token::kIMPORT) {
- const intptr_t import_pos = token_index_;
+ const intptr_t import_pos = TokenPos();
ConsumeToken();
ExpectToken(Token::kLPAREN);
if (CurrentToken() != Token::kSTRING) {
@@ -3717,7 +3740,7 @@
void Parser::ParseLibraryInclude() {
TRACE_PARSER("ParseLibraryInclude");
while (CurrentToken() == Token::kSOURCE) {
- const intptr_t source_pos = token_index_;
+ const intptr_t source_pos = TokenPos();
ConsumeToken();
ExpectToken(Token::kLPAREN);
if (CurrentToken() != Token::kSTRING) {
@@ -3782,7 +3805,7 @@
Class& toplevel_class = Class::Handle(
Class::New(String::ZoneHandle(String::NewSymbol("::")),
script_,
- token_index_));
+ TokenPos()));
toplevel_class.set_library(library_);
if (is_library_source()) {
@@ -3835,7 +3858,7 @@
void Parser::ChainNewBlock(LocalScope* outer_scope) {
Block* block = new Block(current_block_,
outer_scope,
- new SequenceNode(token_index_, outer_scope));
+ new SequenceNode(TokenPos(), outer_scope));
current_block_ = block;
}
@@ -3888,8 +3911,8 @@
if (current_block_->scope != NULL) {
// Record the begin and end token index of the scope.
ASSERT(statements != NULL);
- current_block_->scope->set_begin_token_index(statements->token_index());
- current_block_->scope->set_end_token_index(token_index_);
+ current_block_->scope->set_begin_token_pos(statements->token_pos());
+ current_block_->scope->set_end_token_pos(TokenPos());
}
current_block_ = current_block_->parent;
return statements;
@@ -3970,7 +3993,7 @@
int num_params_for_resolution = num_parameters;
// Parse the function name out.
- const intptr_t native_pos = token_index_;
+ const intptr_t native_pos = TokenPos();
const String& native_name = ParseNativeDeclaration();
if (is_instance_closure) {
@@ -3988,7 +4011,7 @@
// Now add the NativeBodyNode and return statement.
current_block_->statements->Add(
- new ReturnNode(token_index_, new NativeBodyNode(token_index_,
+ new ReturnNode(TokenPos(), new NativeBodyNode(TokenPos(),
native_name,
native_function,
num_parameters,
@@ -4032,14 +4055,14 @@
if (receiver == NULL) {
ErrorMsg(token_pos, "illegal implicit access to receiver 'this'");
}
- return new LoadLocalNode(token_index_, *receiver);
+ return new LoadLocalNode(TokenPos(), *receiver);
}
-AstNode* Parser::CallGetter(intptr_t token_index,
+AstNode* Parser::CallGetter(intptr_t token_pos,
AstNode* object,
const String& name) {
- return new InstanceGetterNode(token_index_, object, name);
+ return new InstanceGetterNode(TokenPos(), object, name);
}
@@ -4048,7 +4071,7 @@
const AbstractType& type, bool is_final) {
TRACE_PARSER("ParseVariableDeclaration");
ASSERT(IsIdentifier());
- const intptr_t ident_pos = token_index_;
+ const intptr_t ident_pos = TokenPos();
LocalVariable* variable =
new LocalVariable(ident_pos, *CurrentLiteral(), type);
ASSERT(current_block_ != NULL);
@@ -4057,7 +4080,7 @@
AstNode* initialization = NULL;
if (CurrentToken() == Token::kASSIGN) {
// Variable initialization.
- const intptr_t assign_pos = token_index_;
+ const intptr_t assign_pos = TokenPos();
ConsumeToken();
AstNode* expr = ParseExpr(kAllowConst);
initialization = new StoreLocalNode(assign_pos, *variable, expr);
@@ -4141,7 +4164,7 @@
}
// We have a second initializer. Allocate a sequence node now.
// The sequence does not own the current scope. Set its own scope to NULL.
- SequenceNode* sequence = NodeAsSequenceNode(initializers->token_index(),
+ SequenceNode* sequence = NodeAsSequenceNode(initializers->token_pos(),
initializers,
NULL);
sequence->Add(ParseVariableDeclaration(type, is_final));
@@ -4165,7 +4188,7 @@
(LookaheadToken(1) != Token::kLPAREN)) {
result_type = ParseType(ClassFinalizer::kFinalize);
}
- const intptr_t ident_pos = token_index_;
+ const intptr_t ident_pos = TokenPos();
if (IsIdentifier()) {
variable_name = CurrentLiteral();
function_name = variable_name;
@@ -4183,7 +4206,7 @@
if (CurrentToken() != Token::kLPAREN) {
ErrorMsg("'(' expected");
}
- intptr_t function_pos = token_index_;
+ intptr_t function_pos = TokenPos();
// Check whether we have parsed this closure function before, in a previous
// compilation. If so, reuse the function object, else create a new one
@@ -4196,7 +4219,7 @@
// function_pos, one enclosed in a closurized function and one enclosed in the
// non-closurized version of this same function.
function = current_class().LookupClosureFunction(function_pos);
- if (function.IsNull() || (function.token_index() != function_pos) ||
+ if (function.IsNull() || (function.token_pos() != function_pos) ||
(function.parent_function() != current_function().raw())) {
is_new_closure = true;
function = Function::NewClosureFunction(*function_name,
@@ -4243,8 +4266,8 @@
Array& default_parameter_values = Array::Handle();
SequenceNode* statements = Parser::ParseFunc(function,
default_parameter_values);
- ASSERT(is_new_closure || (function.end_token_index() == token_index_));
- function.set_end_token_index(token_index_);
+ ASSERT(is_new_closure || (function.end_token_pos() == TokenPos()));
+ function.set_end_token_pos(TokenPos());
// 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
@@ -4423,7 +4446,7 @@
// Not a legal type identifier.
return false;
}
- const intptr_t saved_pos = token_index_;
+ const intptr_t saved_pos = TokenPos();
bool is_var_decl = false;
if (TryParseOptionalType()) {
if (IsIdentifier()) {
@@ -4443,7 +4466,7 @@
// Look ahead to detect whether the next tokens should be parsed as
// a function declaration. Token position remains unchanged.
bool Parser::IsFunctionDeclaration() {
- const intptr_t saved_pos = token_index_;
+ const intptr_t saved_pos = TokenPos();
if (IsIdentifier() && (LookaheadToken(1) == Token::kLPAREN)) {
// Possibly a function without explicit return type.
ConsumeToken(); // Consume function identifier.
@@ -4476,7 +4499,7 @@
if ((CurrentToken() == Token::kGET) || (CurrentToken() == Token::kSET)) {
return true;
}
- const intptr_t saved_pos = token_index_;
+ const intptr_t saved_pos = TokenPos();
if (TryParseReturnType()) {
if ((CurrentToken() == Token::kGET) || (CurrentToken() == Token::kSET)) {
if (Token::IsIdentifier(LookaheadToken(1))) { // Accessor name.
@@ -4494,7 +4517,7 @@
if (!allow_function_literals_) {
return false;
}
- const intptr_t saved_pos = token_index_;
+ const intptr_t saved_pos = TokenPos();
bool is_function_literal = false;
if (IsIdentifier() && (LookaheadToken(1) == Token::kLPAREN)) {
ConsumeToken(); // Consume function identifier.
@@ -4521,7 +4544,7 @@
// statement. Returns true if we recognize a for ( .. in expr)
// statement.
bool Parser::IsForInStatement() {
- const intptr_t saved_pos = token_index_;
+ const intptr_t saved_pos = TokenPos();
bool result = false;
if (CurrentToken() == Token::kVAR || CurrentToken() == Token::kFINAL) {
ConsumeToken();
@@ -4567,7 +4590,7 @@
const bool dead_code_allowed = true;
bool abrupt_completing_seen = false;
while (CurrentToken() != Token::kRBRACE) {
- const intptr_t statement_pos = token_index_;
+ const intptr_t statement_pos = TokenPos();
AstNode* statement = ParseStatement();
// Do not add statements with no effect (e.g., LoadLocalNode).
if ((statement != NULL) && statement->IsLoadLocalNode()) {
@@ -4617,7 +4640,7 @@
AstNode* Parser::ParseIfStatement(String* label_name) {
TRACE_PARSER("ParseIfStatement");
ASSERT(CurrentToken() == Token::kIF);
- const intptr_t if_pos = token_index_;
+ const intptr_t if_pos = TokenPos();
SourceLabel* label = NULL;
if (label_name != NULL) {
label = SourceLabel::New(if_pos, label_name, SourceLabel::kStatement);
@@ -4650,7 +4673,7 @@
SourceLabel* case_label) {
TRACE_PARSER("ParseCaseStatement");
bool default_seen = false;
- const intptr_t case_pos = token_index_;
+ 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);
while (CurrentToken() == Token::kCASE || CurrentToken() == Token::kDEFAULT) {
@@ -4659,7 +4682,7 @@
ErrorMsg("default clause must be last case");
}
ConsumeToken(); // Keyword case.
- const intptr_t expr_pos = token_index_;
+ const intptr_t expr_pos = TokenPos();
AstNode* expr = ParseExpr(kAllowConst);
AstNode* switch_expr_load = new LoadLocalNode(case_pos,
*switch_expr_value);
@@ -4699,9 +4722,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(token_index_);
+ ArgumentListNode* arguments = new ArgumentListNode(TokenPos());
arguments->Add(new LiteralNode(
- token_index_, Integer::ZoneHandle(Integer::New(token_index_))));
+ TokenPos(), Integer::ZoneHandle(Integer::New(TokenPos()))));
current_block_->statements->Add(
MakeStaticCall(kFallThroughErrorName, kThrowNewName, arguments));
}
@@ -4723,7 +4746,7 @@
AstNode* Parser::ParseSwitchStatement(String* label_name) {
TRACE_PARSER("ParseSwitchStatement");
ASSERT(CurrentToken() == Token::kSWITCH);
- const intptr_t switch_pos = token_index_;
+ const intptr_t switch_pos = TokenPos();
SourceLabel* label =
SourceLabel::New(switch_pos, label_name, SourceLabel::kSwitch);
ConsumeToken();
@@ -4735,7 +4758,7 @@
} else if (parens_are_mandatory) {
ErrorMsg("'(' expected");
}
- const intptr_t expr_pos = token_index_;
+ const intptr_t expr_pos = TokenPos();
AstNode* switch_expr = ParseExpr(kAllowConst);
if (paren_found) {
ExpectToken(Token::kRPAREN);
@@ -4762,7 +4785,7 @@
if (IsIdentifier() && LookaheadToken(1) == Token::kCOLON) {
// Case statements start with a label.
String* label_name = CurrentLiteral();
- const intptr_t label_pos = token_index_;
+ const intptr_t label_pos = TokenPos();
ConsumeToken(); // Consume label identifier.
ConsumeToken(); // Consume colon.
case_label = current_block_->scope->LocalLookupLabel(*label_name);
@@ -4814,7 +4837,7 @@
AstNode* Parser::ParseWhileStatement(String* label_name) {
TRACE_PARSER("ParseWhileStatement");
- const intptr_t while_pos = token_index_;
+ const intptr_t while_pos = TokenPos();
SourceLabel* label =
SourceLabel::New(while_pos, label_name, SourceLabel::kWhile);
ConsumeToken();
@@ -4829,7 +4852,7 @@
AstNode* Parser::ParseDoWhileStatement(String* label_name) {
TRACE_PARSER("ParseDoWhileStatement");
- const intptr_t do_pos = token_index_;
+ const intptr_t do_pos = TokenPos();
SourceLabel* label =
SourceLabel::New(do_pos, label_name, SourceLabel::kDoWhile);
ConsumeToken();
@@ -4852,14 +4875,14 @@
LocalVariable* loop_var = NULL;
intptr_t loop_var_pos = 0;
if (LookaheadToken(1) == Token::kIN) {
- loop_var_pos = token_index_;
+ loop_var_pos = TokenPos();
loop_var_name = ExpectIdentifier("variable name expected");
} else {
// The case without a type is handled above, so require a type here.
const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
FLAG_enable_type_checks ? ClassFinalizer::kFinalize :
ClassFinalizer::kIgnore));
- loop_var_pos = token_index_;
+ loop_var_pos = TokenPos();
loop_var_name = ExpectIdentifier("variable name expected");
loop_var = new LocalVariable(loop_var_pos, *loop_var_name, type);
if (is_final) {
@@ -4867,7 +4890,7 @@
}
}
ExpectToken(Token::kIN);
- const intptr_t collection_pos = token_index_;
+ const intptr_t collection_pos = TokenPos();
AstNode* collection_expr = ParseExpr(kAllowConst);
ExpectToken(Token::kRPAREN);
@@ -4960,7 +4983,7 @@
AstNode* Parser::ParseForStatement(String* label_name) {
TRACE_PARSER("ParseForStatement");
- const intptr_t for_pos = token_index_;
+ const intptr_t for_pos = TokenPos();
ConsumeToken();
ExpectToken(Token::kLPAREN);
SourceLabel* label = SourceLabel::New(for_pos, label_name, SourceLabel::kFor);
@@ -4972,7 +4995,7 @@
// the loop variable declarations.
current_block_->scope->AddLabel(label);
AstNode* initializer = NULL;
- const intptr_t init_pos = token_index_;
+ const intptr_t init_pos = TokenPos();
LocalScope* init_scope = current_block_->scope;
if (CurrentToken() != Token::kSEMICOLON) {
if (IsVariableDeclaration()) {
@@ -4988,7 +5011,7 @@
}
ExpectSemicolon();
AstNode* increment = NULL;
- const intptr_t incr_pos = token_index_;
+ const intptr_t incr_pos = TokenPos();
LocalScope* incr_scope = current_block_->scope;
if (CurrentToken() != Token::kRPAREN) {
increment = ParseExprList();
@@ -5040,8 +5063,8 @@
arguments->names(),
Resolver::kIsQualified));
ASSERT(!func.IsNull());
- CheckFunctionIsCallable(arguments->token_index(), func);
- return new StaticCallNode(arguments->token_index(), func, arguments);
+ CheckFunctionIsCallable(arguments->token_pos(), func);
+ return new StaticCallNode(arguments->token_pos(), func, arguments);
}
@@ -5061,7 +5084,7 @@
condition->AsStoreLocalNode()->value()->IsClosureNode())) {
EnsureExpressionTemp();
// Function literal in assert implies a call.
- const intptr_t pos = condition->token_index();
+ const intptr_t pos = condition->token_pos();
condition = new ClosureCallNode(pos, condition, new ArgumentListNode(pos));
} else if (condition->IsConditionalExprNode()) {
ConditionalExprNode* cond_expr = condition->AsConditionalExprNode();
@@ -5076,14 +5099,14 @@
TRACE_PARSER("ParseAssertStatement");
ConsumeToken(); // Consume assert keyword.
ExpectToken(Token::kLPAREN);
- const intptr_t condition_pos = token_index_;
+ const intptr_t condition_pos = TokenPos();
if (!FLAG_enable_asserts && !FLAG_enable_type_checks) {
SkipExpr();
ExpectToken(Token::kRPAREN);
return NULL;
}
AstNode* condition = ParseExpr(kAllowConst);
- const intptr_t condition_end = token_index_;
+ const intptr_t condition_end = TokenPos();
ExpectToken(Token::kRPAREN);
condition = InsertClosureCallNodes(condition);
condition = new UnaryOpNode(condition_pos, Token::kNOT, condition);
@@ -5097,8 +5120,8 @@
struct CatchParamDesc {
CatchParamDesc()
- : token_index(0), type(NULL), var(NULL), is_final(false) { }
- intptr_t token_index;
+ : token_pos(0), type(NULL), var(NULL), is_final(false) { }
+ intptr_t token_pos;
const AbstractType* type;
const String* var;
bool is_final;
@@ -5114,7 +5137,7 @@
// mode.
catch_param->type = &AbstractType::ZoneHandle(
ParseFinalVarOrType(ClassFinalizer::kFinalizeWellFormed));
- catch_param->token_index = token_index_;
+ catch_param->token_pos = TokenPos();
catch_param->var = ExpectIdentifier("identifier expected");
}
@@ -5124,7 +5147,7 @@
const CatchParamDesc& stack_trace_param,
LocalScope* scope) {
ASSERT(exception_param.var != NULL);
- LocalVariable* var = new LocalVariable(exception_param.token_index,
+ LocalVariable* var = new LocalVariable(exception_param.token_pos,
*exception_param.var,
*exception_param.type);
if (exception_param.is_final) {
@@ -5133,7 +5156,7 @@
bool added_to_scope = scope->AddVariable(var);
ASSERT(added_to_scope);
if (stack_trace_param.var != NULL) {
- var = new LocalVariable(token_index_,
+ var = new LocalVariable(TokenPos(),
*stack_trace_param.var,
*stack_trace_param.type);
if (stack_trace_param.is_final) {
@@ -5141,7 +5164,7 @@
}
added_to_scope = scope->AddVariable(var);
if (!added_to_scope) {
- ErrorMsg(stack_trace_param.token_index,
+ ErrorMsg(stack_trace_param.token_pos,
"name '%s' already exists in scope",
stack_trace_param.var->ToCString());
}
@@ -5232,7 +5255,7 @@
LocalVariable* context_var =
current_block_->scope->LocalLookupVariable(context_var_name);
if (context_var == NULL) {
- context_var = new LocalVariable(token_index_,
+ context_var = new LocalVariable(TokenPos(),
context_var_name,
Type::ZoneHandle(Type::DynamicType()));
current_block_->scope->AddVariable(context_var);
@@ -5242,7 +5265,7 @@
LocalVariable* catch_excp_var =
current_block_->scope->LocalLookupVariable(catch_excp_var_name);
if (catch_excp_var == NULL) {
- catch_excp_var = new LocalVariable(token_index_,
+ catch_excp_var = new LocalVariable(TokenPos(),
catch_excp_var_name,
Type::ZoneHandle(Type::DynamicType()));
current_block_->scope->AddVariable(catch_excp_var);
@@ -5252,13 +5275,13 @@
LocalVariable* catch_trace_var =
current_block_->scope->LocalLookupVariable(catch_trace_var_name);
if (catch_trace_var == NULL) {
- catch_trace_var = new LocalVariable(token_index_,
+ catch_trace_var = new LocalVariable(TokenPos(),
catch_trace_var_name,
Type::ZoneHandle(Type::DynamicType()));
current_block_->scope->AddVariable(catch_trace_var);
}
- const intptr_t try_pos = token_index_;
+ const intptr_t try_pos = TokenPos();
ConsumeToken(); // Consume the 'try'.
SourceLabel* try_label = NULL;
@@ -5280,7 +5303,7 @@
// Now create a label for the end of catch block processing so that we can
// jump over the catch block code after executing the try block.
SourceLabel* end_catch_label =
- SourceLabel::New(token_index_, NULL, SourceLabel::kCatch);
+ SourceLabel::New(TokenPos(), NULL, SourceLabel::kCatch);
// Now parse the 'catch' blocks if any and merge all of them into
// an if-then sequence of the different types specified using the 'is'
@@ -5288,12 +5311,12 @@
bool catch_seen = false;
bool generic_catch_seen = false;
SequenceNode* catch_handler_list = NULL;
- const intptr_t handler_pos = token_index_;
+ const intptr_t handler_pos = TokenPos();
OpenBlock(); // Start the catch block sequence.
current_block_->scope->AddLabel(end_catch_label);
while (CurrentToken() == Token::kCATCH) {
catch_seen = true;
- const intptr_t catch_pos = token_index_;
+ const intptr_t catch_pos = TokenPos();
ConsumeToken(); // Consume the 'catch'.
ExpectToken(Token::kLPAREN);
CatchParamDesc exception_param;
@@ -5388,7 +5411,7 @@
if (CurrentToken() == Token::kFINALLY) {
current_function_.set_is_optimizable(false);
ConsumeToken(); // Consume the 'finally'.
- const intptr_t finally_pos = token_index_;
+ const intptr_t finally_pos = TokenPos();
// Add the finally block to the exit points recorded so far.
intptr_t node_index = 0;
AstNode* node_to_inline =
@@ -5401,14 +5424,14 @@
AddFinallyBlockToNode(node_to_inline, node);
node_index += 1;
node_to_inline = inner_try_block->GetNodeToInlineFinally(node_index);
- token_index_ = finally_pos;
+ tokens_iterator_.SetCurrentPosition(finally_pos);
}
if (!generic_catch_seen) {
// No generic catch handler exists so execute this finally block
// before rethrowing the exception.
finally_block = ParseFinallyBlock();
catch_handler_list->Add(finally_block);
- token_index_ = finally_pos;
+ tokens_iterator_.SetCurrentPosition(finally_pos);
}
finally_block = ParseFinallyBlock();
} else {
@@ -5452,7 +5475,7 @@
TRACE_PARSER("ParseJump");
ASSERT(CurrentToken() == Token::kBREAK || CurrentToken() == Token::kCONTINUE);
Token::Kind jump_kind = CurrentToken();
- const intptr_t jump_pos = token_index_;
+ const intptr_t jump_pos = TokenPos();
SourceLabel* target = NULL;
ConsumeToken();
if (IsIdentifier()) {
@@ -5478,7 +5501,7 @@
if (switch_scope != NULL) {
// We found a switch scope. Enter a forward reference to the label.
target = new SourceLabel(
- token_index_, target_name, SourceLabel::kForward);
+ TokenPos(), target_name, SourceLabel::kForward);
switch_scope->AddLabel(target);
}
}
@@ -5512,7 +5535,7 @@
bool Parser::IsDefinedInLexicalScope(const String& ident) {
- if (ResolveIdentInLocalScope(token_index_, ident, NULL)) {
+ if (ResolveIdentInLocalScope(TokenPos(), ident, NULL)) {
return true;
}
Object& obj = Object::Handle();
@@ -5530,13 +5553,13 @@
if (LookaheadToken(1) == Token::kCOLON) {
// Statement starts with a label.
label_name = CurrentLiteral();
- label_pos = token_index_;
+ label_pos = TokenPos();
ASSERT(label_pos > 0);
ConsumeToken(); // Consume identifier.
ConsumeToken(); // Consume colon.
}
}
- const intptr_t statement_pos = token_index_;
+ const intptr_t statement_pos = TokenPos();
if (CurrentToken() == Token::kWHILE) {
statement = ParseWhileStatement(label_name);
@@ -5549,7 +5572,7 @@
} else if (CurrentToken() == Token::kTRY) {
statement = ParseTryStatement(label_name);
} else if (CurrentToken() == Token::kRETURN) {
- const intptr_t return_pos = token_index_;
+ const intptr_t return_pos = TokenPos();
ConsumeToken();
if (CurrentToken() != Token::kSEMICOLON) {
if (current_function().IsConstructor() &&
@@ -5636,13 +5659,13 @@
RawError* Parser::FormatErrorWithAppend(const Error& prev_error,
const Script& script,
- intptr_t token_index,
+ intptr_t token_pos,
const char* message_header,
const char* format,
va_list args) {
const intptr_t kMessageBufferSize = 512;
char message_buffer[kMessageBufferSize];
- FormatMessage(script, token_index, message_header,
+ FormatMessage(script, token_pos, message_header,
message_buffer, kMessageBufferSize,
format, args);
const String& msg1 = String::Handle(String::New(prev_error.ToErrorCString()));
@@ -5652,13 +5675,13 @@
RawError* Parser::FormatError(const Script& script,
- intptr_t token_index,
+ intptr_t token_pos,
const char* message_header,
const char* format,
va_list args) {
const intptr_t kMessageBufferSize = 512;
char message_buffer[kMessageBufferSize];
- FormatMessage(script, token_index, message_header,
+ FormatMessage(script, token_pos, message_header,
message_buffer, kMessageBufferSize,
format, args);
const String& msg = String::Handle(String::New(message_buffer));
@@ -5667,7 +5690,7 @@
void Parser::FormatMessage(const Script& script,
- intptr_t token_index,
+ intptr_t token_pos,
const char* message_header,
char* message_buffer,
intptr_t message_buffer_size,
@@ -5675,9 +5698,9 @@
intptr_t msg_len = 0;
if (!script.IsNull()) {
const String& script_url = String::CheckedHandle(script.url());
- if (token_index >= 0) {
+ if (token_pos >= 0) {
intptr_t line, column;
- script.GetTokenLocation(token_index, &line, &column);
+ script.GetTokenLocation(token_pos, &line, &column);
msg_len += OS::SNPrint(message_buffer + msg_len,
message_buffer_size - msg_len,
"'%s': %s: line %d pos %d: ",
@@ -5729,11 +5752,11 @@
}
-void Parser::ErrorMsg(intptr_t token_index, const char* format, ...) {
+void Parser::ErrorMsg(intptr_t token_pos, const char* format, ...) {
va_list args;
va_start(args, format);
const Error& error = Error::Handle(
- FormatError(script_, token_index, "Error", format, args));
+ FormatError(script_, token_pos, "Error", format, args));
va_end(args);
Isolate::Current()->long_jump_base()->Jump(1, error);
UNREACHABLE();
@@ -5744,7 +5767,7 @@
va_list args;
va_start(args, format);
const Error& error = Error::Handle(
- FormatError(script_, token_index_, "Error", format, args));
+ FormatError(script_, TokenPos(), "Error", format, args));
va_end(args);
Isolate::Current()->long_jump_base()->Jump(1, error);
UNREACHABLE();
@@ -5758,23 +5781,23 @@
void Parser::AppendErrorMsg(
- const Error& prev_error, intptr_t token_index, const char* format, ...) {
+ const Error& prev_error, intptr_t token_pos, const char* format, ...) {
va_list args;
va_start(args, format);
const Error& error = Error::Handle(FormatErrorWithAppend(
- prev_error, script_, token_index, "Error", format, args));
+ prev_error, script_, token_pos, "Error", format, args));
va_end(args);
Isolate::Current()->long_jump_base()->Jump(1, error);
UNREACHABLE();
}
-void Parser::Warning(intptr_t token_index, const char* format, ...) {
+void Parser::Warning(intptr_t token_pos, const char* format, ...) {
if (FLAG_silent_warnings) return;
va_list args;
va_start(args, format);
const Error& error = Error::Handle(
- FormatError(script_, token_index, "Warning", format, args));
+ FormatError(script_, token_pos, "Warning", format, args));
va_end(args);
if (FLAG_warning_as_error) {
Isolate::Current()->long_jump_base()->Jump(1, error);
@@ -5790,7 +5813,7 @@
va_list args;
va_start(args, format);
const Error& error = Error::Handle(
- FormatError(script_, token_index_, "Warning", format, args));
+ FormatError(script_, TokenPos(), "Warning", format, args));
va_end(args);
if (FLAG_warning_as_error) {
Isolate::Current()->long_jump_base()->Jump(1, error);
@@ -5802,7 +5825,7 @@
void Parser::Unimplemented(const char* msg) {
- ErrorMsg(token_index_, msg);
+ ErrorMsg(TokenPos(), msg);
}
@@ -5916,7 +5939,7 @@
if (op_kind == Token::kTIGHTADD) {
op_kind = Token::kADD;
}
- const intptr_t op_pos = token_index_;
+ const intptr_t op_pos = TokenPos();
ConsumeToken();
AstNode* right_operand = NULL;
if (op_kind != Token::kIS) {
@@ -5927,7 +5950,7 @@
ConsumeToken();
op_kind = Token::kISNOT;
}
- const intptr_t type_pos = token_index_;
+ const intptr_t type_pos = TokenPos();
const AbstractType& type =
AbstractType::ZoneHandle(ParseType(ClassFinalizer::kFinalize));
if (!type.IsInstantiated() &&
@@ -5978,7 +6001,7 @@
AstNode* expressions = ParseExpr(kAllowConst);
if (CurrentToken() == Token::kCOMMA) {
// Collect comma-separated expressions in a non scope owning sequence node.
- SequenceNode* list = new SequenceNode(token_index_, NULL);
+ SequenceNode* list = new SequenceNode(TokenPos(), NULL);
list->Add(expressions);
while (CurrentToken() == Token::kCOMMA) {
ConsumeToken();
@@ -5994,7 +6017,7 @@
const LocalVariable& Parser::GetIncrementTempLocal() {
if (expression_temp_ == NULL) {
expression_temp_ = ParsedFunction::CreateExpressionTempVar(
- current_function().token_index());
+ current_function().token_pos());
}
return *expression_temp_;
}
@@ -6006,13 +6029,13 @@
}
-LocalVariable* Parser::CreateTempConstVariable(intptr_t token_index,
+LocalVariable* Parser::CreateTempConstVariable(intptr_t token_pos,
intptr_t token_id,
const char* s) {
char name[64];
OS::SNPrint(name, 64, ":%s%d", s, token_id);
LocalVariable* temp =
- new LocalVariable(token_index,
+ new LocalVariable(token_pos,
String::ZoneHandle(String::NewSymbol(name)),
Type::ZoneHandle(Type::DynamicType()));
temp->set_is_final();
@@ -6113,30 +6136,30 @@
LoadIndexedNode* left_node = node->AsLoadIndexedNode();
LoadIndexedNode* right_node = left_node;
intptr_t node_id = node->id();
- intptr_t token_index = node->token_index();
+ intptr_t token_pos = node->token_pos();
node = NULL; // Do not use it.
if (!IsSimpleLocalOrLiteralNode(left_node->array())) {
LocalVariable* temp =
- CreateTempConstVariable(token_index, node_id, "lia");
+ CreateTempConstVariable(token_pos, node_id, "lia");
StoreLocalNode* save =
- new StoreLocalNode(token_index, *temp, left_node->array());
+ new StoreLocalNode(token_pos, *temp, left_node->array());
left_node =
- new LoadIndexedNode(token_index, save, left_node->index_expr());
- right_node = new LoadIndexedNode(token_index,
- new LoadLocalNode(token_index, *temp),
+ new LoadIndexedNode(token_pos, save, left_node->index_expr());
+ right_node = new LoadIndexedNode(token_pos,
+ new LoadLocalNode(token_pos, *temp),
right_node->index_expr());
}
if (!IsSimpleLocalOrLiteralNode(left_node->index_expr())) {
LocalVariable* temp =
- CreateTempConstVariable(token_index, node_id, "lix");
+ CreateTempConstVariable(token_pos, node_id, "lix");
StoreLocalNode* save =
- new StoreLocalNode(token_index, *temp, left_node->index_expr());
- left_node = new LoadIndexedNode(token_index,
+ new StoreLocalNode(token_pos, *temp, left_node->index_expr());
+ left_node = new LoadIndexedNode(token_pos,
left_node->array(),
save);
- right_node = new LoadIndexedNode(token_index,
+ right_node = new LoadIndexedNode(token_pos,
right_node->array(),
- new LoadLocalNode(token_index, *temp));
+ new LoadLocalNode(token_pos, *temp));
}
*expr = right_node;
return left_node;
@@ -6145,18 +6168,18 @@
InstanceGetterNode* left_node = node->AsInstanceGetterNode();
InstanceGetterNode* right_node = left_node;
intptr_t node_id = node->id();
- intptr_t token_index = node->token_index();
+ intptr_t token_pos = node->token_pos();
node = NULL; // Do not use it.
if (!IsSimpleLocalOrLiteralNode(left_node->receiver())) {
LocalVariable* temp =
- CreateTempConstVariable(token_index, node_id, "igr");
+ CreateTempConstVariable(token_pos, node_id, "igr");
StoreLocalNode* save =
- new StoreLocalNode(token_index, *temp, left_node->receiver());
- left_node = new InstanceGetterNode(token_index,
+ new StoreLocalNode(token_pos, *temp, left_node->receiver());
+ left_node = new InstanceGetterNode(token_pos,
save,
left_node->field_name());
- right_node = new InstanceGetterNode(token_index,
- new LoadLocalNode(token_index, *temp),
+ right_node = new InstanceGetterNode(token_pos,
+ new LoadLocalNode(token_pos, *temp),
right_node->field_name());
}
*expr = right_node;
@@ -6179,7 +6202,7 @@
AstNode* Parser::ParseExpr(bool require_compiletime_const) {
TRACE_PARSER("ParseExpr");
- const intptr_t expr_pos = token_index_;
+ const intptr_t expr_pos = TokenPos();
AstNode* expr = ParseConditionalExpr();
if (!Token::IsAssignmentOperator(CurrentToken())) {
if (require_compiletime_const) {
@@ -6189,9 +6212,9 @@
}
// Assignment expressions.
Token::Kind assignment_op = CurrentToken();
- const intptr_t assignment_pos = token_index_;
+ const intptr_t assignment_pos = TokenPos();
ConsumeToken();
- const intptr_t right_expr_pos = token_index_;
+ const intptr_t right_expr_pos = TokenPos();
if (require_compiletime_const && (assignment_op != Token::kASSIGN)) {
ErrorMsg(right_expr_pos, "expression must be a compile time constant");
}
@@ -6223,7 +6246,7 @@
AstNode* Parser::ParseConditionalExpr() {
TRACE_PARSER("ParseConditionalExpr");
- const intptr_t expr_pos = token_index_;
+ const intptr_t expr_pos = TokenPos();
AstNode* expr = ParseBinaryExpr(Token::Precedence(Token::kOR));
if (CurrentToken() == Token::kCONDITIONAL) {
EnsureExpressionTemp();
@@ -6240,7 +6263,7 @@
AstNode* Parser::ParseUnaryExpr() {
TRACE_PARSER("ParseUnaryExpr");
AstNode* expr = NULL;
- const intptr_t op_pos = token_index_;
+ const intptr_t op_pos = TokenPos();
if (IsPrefixOperator(CurrentToken())) {
Token::Kind unary_op = CurrentToken();
ConsumeToken();
@@ -6287,7 +6310,7 @@
const bool saved_mode = SetAllowFunctionLiterals(true);
ArgumentListNode* arguments;
if (implicit_arguments == NULL) {
- arguments = new ArgumentListNode(token_index_);
+ arguments = new ArgumentListNode(TokenPos());
} else {
arguments = implicit_arguments;
}
@@ -6336,7 +6359,7 @@
const String& func_name,
intptr_t ident_pos) {
TRACE_PARSER("ParseStaticCall");
- const intptr_t call_pos = token_index_;
+ const intptr_t call_pos = TokenPos();
ASSERT(CurrentToken() == Token::kLPAREN);
ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
const int num_arguments = arguments->length();
@@ -6386,7 +6409,7 @@
} else {
ArgumentListNode* arguments = new ArgumentListNode(ident_pos);
arguments->Add(new LiteralNode(
- token_index_, Integer::ZoneHandle(Integer::New(ident_pos))));
+ TokenPos(), Integer::ZoneHandle(Integer::New(ident_pos))));
return MakeStaticCall(kStaticResolutionExceptionName,
kThrowNewName,
arguments);
@@ -6399,7 +6422,7 @@
AstNode* Parser::ParseInstanceCall(AstNode* receiver, const String& func_name) {
TRACE_PARSER("ParseInstanceCall");
- const intptr_t call_pos = token_index_;
+ const intptr_t call_pos = TokenPos();
if (CurrentToken() != Token::kLPAREN) {
ErrorMsg(call_pos, "left parenthesis expected");
}
@@ -6410,7 +6433,7 @@
AstNode* Parser::ParseClosureCall(AstNode* closure) {
TRACE_PARSER("ParseClosureCall");
- const intptr_t call_pos = token_index_;
+ const intptr_t call_pos = TokenPos();
ASSERT(CurrentToken() == Token::kLPAREN);
EnsureExpressionTemp();
ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
@@ -6422,7 +6445,7 @@
const String& field_name) {
TRACE_PARSER("ParseInstanceFieldAccess");
AstNode* access = NULL;
- const intptr_t call_pos = token_index_;
+ const intptr_t call_pos = TokenPos();
if (Token::IsAssignmentOperator(CurrentToken())) {
Token::Kind assignment_op = CurrentToken();
ConsumeToken();
@@ -6469,7 +6492,7 @@
intptr_t ident_pos) {
TRACE_PARSER("ParseStaticFieldAccess");
AstNode* access = NULL;
- const intptr_t call_pos = token_index_;
+ const intptr_t call_pos = TokenPos();
const Field& field = Field::ZoneHandle(cls.LookupStaticField(field_name));
Function& func = Function::ZoneHandle();
if (Token::IsAssignmentOperator(CurrentToken())) {
@@ -6515,7 +6538,7 @@
field_name.ToCString());
return access;
}
- load_access = GenerateStaticFieldLookup(field, token_index_);
+ load_access = GenerateStaticFieldLookup(field, TokenPos());
}
value = ExpandAssignableOp(call_pos, assignment_op, load_access, value);
access = CreateAssignmentNode(load_access, value);
@@ -6549,7 +6572,7 @@
field_name);
}
} else {
- return GenerateStaticFieldLookup(field, token_index_);
+ return GenerateStaticFieldLookup(field, TokenPos());
}
}
return access;
@@ -6568,12 +6591,12 @@
String& name = String::CheckedZoneHandle(primary->primary().raw());
if (current_function().is_static() ||
current_function().IsInFactoryScope()) {
- ErrorMsg(primary->token_index(),
+ ErrorMsg(primary->token_pos(),
"identifier '%s' is not declared in this scope",
name.ToCString());
} else {
- AstNode* receiver = LoadReceiver(primary->token_index());
- return CallGetter(node->token_index(), receiver, name);
+ AstNode* receiver = LoadReceiver(primary->token_pos());
+ return CallGetter(node->token_pos(), receiver, name);
}
}
return primary;
@@ -6588,17 +6611,17 @@
const String& funcname = String::ZoneHandle(func.name());
if (func.is_static()) {
// Static function access.
- closure = CreateImplicitClosureNode(func, primary->token_index(), NULL);
+ closure = CreateImplicitClosureNode(func, primary->token_pos(), NULL);
} else {
// Instance function access.
if (current_function().is_static() ||
current_function().IsInFactoryScope()) {
- ErrorMsg(primary->token_index(),
+ ErrorMsg(primary->token_pos(),
"cannot access instance method '%s' from static method",
funcname.ToCString());
}
- AstNode* receiver = LoadReceiver(primary->token_index());
- closure = CallGetter(primary->token_index(), receiver, funcname);
+ AstNode* receiver = LoadReceiver(primary->token_pos());
+ closure = CallGetter(primary->token_pos(), receiver, funcname);
}
return closure;
}
@@ -6606,7 +6629,7 @@
AstNode* Parser::ParsePostfixExpr() {
TRACE_PARSER("ParsePostfixExpr");
- const intptr_t postfix_expr_pos = token_index_;
+ const intptr_t postfix_expr_pos = TokenPos();
AstNode* postfix_expr = ParsePrimary();
while (true) {
AstNode* selector = NULL;
@@ -6620,7 +6643,7 @@
left = LoadFieldIfUnresolved(left);
}
}
- const intptr_t ident_pos = token_index_;
+ const intptr_t ident_pos = TokenPos();
String* ident = ExpectIdentifier("identifier expected");
if (CurrentToken() == Token::kLPAREN) {
// Identifier followed by a opening paren: method call.
@@ -6653,7 +6676,7 @@
}
}
} else if (CurrentToken() == Token::kLBRACK) {
- const intptr_t bracket_pos = token_index_;
+ const intptr_t bracket_pos = TokenPos();
ConsumeToken();
left = LoadFieldIfUnresolved(left);
const bool saved_mode = SetAllowFunctionLiterals(true);
@@ -6675,7 +6698,7 @@
} else if (CurrentToken() == Token::kLPAREN) {
if (left->IsPrimaryNode()) {
PrimaryNode* primary = left->AsPrimaryNode();
- const intptr_t primary_pos = primary->token_index();
+ const intptr_t primary_pos = primary->token_pos();
if (primary->primary().IsFunction()) {
Function& func = Function::CheckedHandle(primary->primary().raw());
String& func_name = String::ZoneHandle(func.name());
@@ -6697,16 +6720,16 @@
// Primary is an unresolved name.
String& name = String::CheckedZoneHandle(primary->primary().raw());
if (current_function().is_static()) {
- ErrorMsg(primary->token_index(),
+ ErrorMsg(primary->token_pos(),
"identifier '%s' is not declared in this scope",
name.ToCString());
} else {
// Treat as call to unresolved (instance) method.
- AstNode* receiver = LoadReceiver(primary->token_index());
+ AstNode* receiver = LoadReceiver(primary->token_pos());
selector = ParseInstanceCall(receiver, name);
}
} else if (primary->primary().IsClass()) {
- ErrorMsg(left->token_index(),
+ ErrorMsg(left->token_pos(),
"must use 'new' or 'const' to construct new instance");
} else {
UNREACHABLE(); // Internal parser error.
@@ -6728,7 +6751,7 @@
Class& cls = Class::CheckedHandle(
left->AsPrimaryNode()->primary().raw());
String& cls_name = String::Handle(cls.Name());
- ErrorMsg(left->token_index(),
+ ErrorMsg(left->token_pos(),
"illegal use of class name '%s'",
cls_name.ToCString());
} else {
@@ -6797,12 +6820,12 @@
// First check if the type is a type parameter of the given scope class.
const TypeParameter& type_parameter = TypeParameter::Handle(
scope_class.LookupTypeParameter(unresolved_class_name,
- type->token_index()));
+ type->token_pos()));
if (!type_parameter.IsNull()) {
// A type parameter cannot be parameterized, so report an error if
// type arguments have previously been parsed.
if (!AbstractTypeArguments::Handle(type->arguments()).IsNull()) {
- ErrorMsg(type_parameter.token_index(),
+ ErrorMsg(type_parameter.token_pos(),
"type parameter '%s' cannot be parameterized",
String::Handle(type_parameter.Name()).ToCString());
}
@@ -6921,7 +6944,7 @@
String::Handle(field.name()).ToCString());
} else {
// The implicit static getter will throw the exception if necessary.
- return new StaticGetterNode(token_index_,
+ return new StaticGetterNode(TokenPos(),
Class::ZoneHandle(field.owner()),
String::ZoneHandle(field.name()));
}
@@ -6955,7 +6978,7 @@
field.set_value(Instance::Handle());
// It is a compile-time error if evaluation of a compile-time constant
// would raise an exception.
- AppendErrorMsg(error, token_index_,
+ AppendErrorMsg(error, TokenPos(),
"error initializing final field '%s'",
String::Handle(field.name()).ToCString());
} else {
@@ -6970,7 +6993,7 @@
}
field.set_value(instance);
} else {
- return new StaticGetterNode(token_index_,
+ return new StaticGetterNode(TokenPos(),
Class::ZoneHandle(field.owner()),
String::ZoneHandle(field.name()));
}
@@ -7415,7 +7438,7 @@
TRACE_PARSER("ParseListLiteral");
ASSERT(type_pos >= 0);
ASSERT(CurrentToken() == Token::kLBRACK || CurrentToken() == Token::kINDEX);
- const intptr_t literal_pos = token_index_;
+ const intptr_t literal_pos = TokenPos();
bool is_empty_literal = CurrentToken() == Token::kINDEX;
ConsumeToken();
@@ -7441,13 +7464,13 @@
// Parse the list elements. Note: there may be an optional extra
// comma after the last element.
- ArrayNode* list = new ArrayNode(token_index_, type_arguments);
+ ArrayNode* list = new ArrayNode(TokenPos(), type_arguments);
if (!is_empty_literal) {
const bool saved_mode = SetAllowFunctionLiterals(true);
const String& dst_name = String::ZoneHandle(
String::NewSymbol("list literal element"));
while (CurrentToken() != Token::kRBRACK) {
- const intptr_t element_pos = token_index_;
+ const intptr_t element_pos = TokenPos();
AstNode* element = ParseExpr(is_const);
if (FLAG_enable_type_checks &&
!is_const &&
@@ -7488,7 +7511,7 @@
if (!malformed_error.IsNull()) {
ErrorMsg(malformed_error);
} else {
- ErrorMsg(elem->AsLiteralNode()->token_index(),
+ ErrorMsg(elem->AsLiteralNode()->token_pos(),
"list literal element at index %d must be "
"a constant of type '%s'",
i,
@@ -7531,7 +7554,7 @@
ConstructorCallNode* Parser::CreateConstructorCallNode(
- intptr_t token_index,
+ intptr_t token_pos,
const AbstractTypeArguments& type_arguments,
const Function& constructor,
ArgumentListNode* arguments) {
@@ -7539,8 +7562,8 @@
EnsureExpressionTemp();
}
LocalVariable* allocated =
- CreateTempConstVariable(token_index, token_index, "alloc");
- return new ConstructorCallNode(token_index,
+ CreateTempConstVariable(token_pos, token_pos, "alloc");
+ return new ConstructorCallNode(token_pos,
type_arguments,
constructor,
arguments,
@@ -7579,7 +7602,7 @@
TRACE_PARSER("ParseMapLiteral");
ASSERT(type_pos >= 0);
ASSERT(CurrentToken() == Token::kLBRACE);
- const intptr_t literal_pos = token_index_;
+ const intptr_t literal_pos = TokenPos();
ConsumeToken();
AbstractType& value_type = Type::ZoneHandle(Type::DynamicType());
@@ -7627,7 +7650,7 @@
// 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(token_index_, TypeArguments::ZoneHandle());
+ new ArrayNode(TokenPos(), TypeArguments::ZoneHandle());
const String& dst_name = String::ZoneHandle(
String::NewSymbol("list literal element"));
while (CurrentToken() != Token::kRBRACE) {
@@ -7642,7 +7665,7 @@
}
ExpectToken(Token::kCOLON);
const bool saved_mode = SetAllowFunctionLiterals(true);
- const intptr_t value_pos = token_index_;
+ const intptr_t value_pos = TokenPos();
AstNode* value = ParseExpr(is_const);
SetAllowFunctionLiterals(saved_mode);
if (FLAG_enable_type_checks &&
@@ -7687,7 +7710,7 @@
if (!malformed_error.IsNull()) {
ErrorMsg(malformed_error);
} else {
- ErrorMsg(arg->AsLiteralNode()->token_index(),
+ ErrorMsg(arg->AsLiteralNode()->token_pos(),
"map literal value at index %d must be "
"a constant of type '%s'",
i >> 1,
@@ -7705,7 +7728,7 @@
const Class& immutable_map_class =
Class::Handle(LookupImplClass(immutable_map_class_name));
ASSERT(!immutable_map_class.IsNull());
- ArgumentListNode* constr_args = new ArgumentListNode(token_index_);
+ ArgumentListNode* constr_args = new ArgumentListNode(TokenPos());
constr_args->Add(new LiteralNode(literal_pos, key_value_array));
const String& constr_name =
String::Handle(String::NewSymbol(kImmutableMapConstructorName));
@@ -7759,7 +7782,7 @@
is_const = true;
ConsumeToken();
}
- const intptr_t type_pos = token_index_;
+ const intptr_t type_pos = TokenPos();
Error& malformed_error = Error::Handle();
AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle(
ParseTypeArguments(&malformed_error,
@@ -7800,14 +7823,14 @@
AstNode* Parser::ParseNewOperator() {
TRACE_PARSER("ParseNewOperator");
- const intptr_t new_pos = token_index_;
+ const intptr_t new_pos = TokenPos();
ASSERT((CurrentToken() == Token::kNEW) || (CurrentToken() == Token::kCONST));
bool is_const = (CurrentToken() == Token::kCONST);
ConsumeToken();
if (!IsIdentifier()) {
ErrorMsg("type name expected");
}
- intptr_t type_pos = token_index_;
+ intptr_t type_pos = TokenPos();
const AbstractType& type = AbstractType::Handle(
ParseType(ClassFinalizer::kFinalizeWellFormed));
// Malformed bounds never result in a compile time error, therefore, the
@@ -7847,7 +7870,7 @@
if (CurrentToken() != Token::kLPAREN) {
ErrorMsg("'(' expected");
}
- intptr_t call_pos = token_index_;
+ intptr_t call_pos = TokenPos();
ArgumentListNode* arguments = ParseActualParameters(NULL, is_const);
// A constructor has an implicit 'this' parameter (instance to construct)
@@ -7963,7 +7986,7 @@
}
// TODO(regis): Temporary type should be allocated in new gen heap.
Type& temp_type = Type::Handle(
- Type::New(constructor_class, temp_type_arguments, type.token_index()));
+ Type::New(constructor_class, temp_type_arguments, type.token_pos()));
temp_type ^= ClassFinalizer::FinalizeType(
current_class(), temp_type, ClassFinalizer::kFinalize);
// The type argument vector may have been expanded with the type arguments
@@ -8069,7 +8092,7 @@
AstNode* Parser::ParseStringLiteral() {
TRACE_PARSER("ParseStringLiteral");
AstNode* primary = NULL;
- const intptr_t literal_start = token_index_;
+ const intptr_t literal_start = TokenPos();
ASSERT(CurrentToken() == Token::kSTRING);
Token::Kind l1_token = LookaheadToken(1);
if ((l1_token != Token::kSTRING) &&
@@ -8082,16 +8105,16 @@
}
// String interpolation needed.
bool is_compiletime_const = true;
- ArrayNode* values = new ArrayNode(token_index_, TypeArguments::ZoneHandle());
+ ArrayNode* values = new ArrayNode(TokenPos(), TypeArguments::ZoneHandle());
while (CurrentToken() == Token::kSTRING) {
- values->AddElement(new LiteralNode(token_index_, *CurrentLiteral()));
+ values->AddElement(new LiteralNode(TokenPos(), *CurrentLiteral()));
ConsumeToken();
while ((CurrentToken() == Token::kINTERPOL_VAR) ||
(CurrentToken() == Token::kINTERPOL_START)) {
AstNode* expr = NULL;
- const intptr_t expr_pos = token_index_;
+ const intptr_t expr_pos = TokenPos();
if (CurrentToken() == Token::kINTERPOL_VAR) {
- expr = ResolveIdent(token_index_, *CurrentLiteral(), true);
+ expr = ResolveIdent(TokenPos(), *CurrentLiteral(), true);
ConsumeToken();
} else {
ASSERT(CurrentToken() == Token::kINTERPOL_START);
@@ -8118,7 +8141,7 @@
primary = new LiteralNode(literal_start, Interpolate(values));
} else {
ArgumentListNode* interpolate_arg =
- new ArgumentListNode(values->token_index());
+ new ArgumentListNode(values->token_pos());
interpolate_arg->Add(values);
primary = MakeStaticCall(kStringClassName,
kInterpolateName,
@@ -8160,7 +8183,7 @@
if (CurrentToken() == Token::kINTERPOL_START) {
ConsumeToken();
if (IsIdentifier()) {
- resolved_name = ResolveImportVar(token_index_, *CurrentLiteral());
+ resolved_name = ResolveImportVar(TokenPos(), *CurrentLiteral());
result = String::Concat(result, resolved_name);
ConsumeToken();
if (CurrentToken() != Token::kINTERPOL_END) {
@@ -8172,7 +8195,7 @@
}
} else {
ASSERT(CurrentToken() == Token::kINTERPOL_VAR);
- resolved_name = ResolveImportVar(token_index_, *CurrentLiteral());
+ resolved_name = ResolveImportVar(TokenPos(), *CurrentLiteral());
result = String::Concat(result, resolved_name);
ConsumeToken();
}
@@ -8207,7 +8230,7 @@
if (!scope_class.IsNull()) {
TypeParameter& type_param = TypeParameter::ZoneHandle(
scope_class.LookupTypeParameter(*(qual_ident.ident),
- token_index_));
+ TokenPos()));
if (!type_param.IsNull()) {
String& type_param_name = String::Handle(type_param.Name());
ErrorMsg(qual_ident.ident_pos,
@@ -8236,20 +8259,20 @@
if (local == NULL) {
ErrorMsg("receiver 'this' is not in scope");
}
- primary = new LoadLocalNode(token_index_, *local);
+ primary = new LoadLocalNode(TokenPos(), *local);
ConsumeToken();
} else if (CurrentToken() == Token::kINTEGER) {
const Integer& literal = Integer::ZoneHandle(CurrentIntegerLiteral());
- primary = new LiteralNode(token_index_, literal);
+ primary = new LiteralNode(TokenPos(), literal);
ConsumeToken();
} else if (CurrentToken() == Token::kTRUE) {
- primary = new LiteralNode(token_index_, Bool::ZoneHandle(Bool::True()));
+ primary = new LiteralNode(TokenPos(), Bool::ZoneHandle(Bool::True()));
ConsumeToken();
} else if (CurrentToken() == Token::kFALSE) {
- primary = new LiteralNode(token_index_, Bool::ZoneHandle(Bool::False()));
+ primary = new LiteralNode(TokenPos(), Bool::ZoneHandle(Bool::False()));
ConsumeToken();
} else if (CurrentToken() == Token::kNULL) {
- primary = new LiteralNode(token_index_, Instance::ZoneHandle());
+ primary = new LiteralNode(TokenPos(), Instance::ZoneHandle());
ConsumeToken();
} else if (CurrentToken() == Token::kLPAREN) {
ConsumeToken();
@@ -8262,7 +8285,7 @@
if (double_value.IsNull()) {
ErrorMsg("invalid double literal");
}
- primary = new LiteralNode(token_index_, double_value);
+ primary = new LiteralNode(TokenPos(), double_value);
ConsumeToken();
} else if (CurrentToken() == Token::kSTRING) {
primary = ParseStringLiteral();
@@ -8317,11 +8340,11 @@
return expr->AsLiteralNode()->literal();
} else {
ASSERT(expr->EvalConstExpr() != NULL);
- ReturnNode* ret = new ReturnNode(expr->token_index(), expr);
+ ReturnNode* ret = new 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_index(), empty_scope);
+ SequenceNode* seq = new SequenceNode(expr->token_pos(), empty_scope);
seq->Add(ret);
Object& result = Object::Handle(Compiler::ExecuteOnce(seq));
« no previous file with comments | « vm/parser.h ('k') | vm/raw_object.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698