Get rid of ast node ids.

runtime/vm/parser.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 95 matching lines @@
   return new LocalVariable(token_pos,
                            String::ZoneHandle(Symbols::ExprTemp()),
                            Type::ZoneHandle(Type::DynamicType()));
 }
 
 
 void ParsedFunction::SetNodeSequence(SequenceNode* node_sequence) {
   ASSERT(node_sequence_ == NULL);
   ASSERT(node_sequence != NULL);
   node_sequence_ = node_sequence;
-  const int num_fixed_params = function().num_fixed_parameters();
-  const int num_opt_params = function().num_optional_parameters();
-  // Allocated ids for parameters.
-  intptr_t parameter_id = AstNode::kNoId;
-  for (intptr_t i = 0; i < num_fixed_params + num_opt_params; i++) {
-    parameter_id = AstNode::GetNextId();
-    if (i == 0) {
-      node_sequence_->set_first_parameter_id(parameter_id);
-    }
-  }
-  node_sequence_->set_last_parameter_id(parameter_id);
 }
 
 
 void ParsedFunction::AllocateVariables() {
   LocalScope* scope = node_sequence()->scope();
   const int fixed_parameter_count = function().num_fixed_parameters();
   const int optional_parameter_count = function().num_optional_parameters();
   const int parameter_count = fixed_parameter_count + optional_parameter_count;
   const bool is_native_instance_closure =
       function().is_native() && function().IsImplicitInstanceClosureFunction();
@@ skipping 518 matching lines @@
   } else {
     return seq->NodeAt(seq->length() - 1)->IsReturnNode();
   }
 }
 
 
 void Parser::ParseFunction(ParsedFunction* parsed_function) {
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate->long_jump_base()->IsSafeToJump());
-  // Compilation can be nested, preserve the ast node id.
-  const intptr_t prev_ast_node_id = isolate->ast_node_id();
-  isolate->set_ast_node_id(0);
   ASSERT(parsed_function != NULL);
   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_pos());
   SequenceNode* node_sequence = NULL;
   Array& default_parameter_values = Array::Handle(isolate, Array::null());
   switch (func.kind()) {
     case RawFunction::kRegularFunction:
     case RawFunction::kClosureFunction:
@@ skipping 43 matching lines @@
       instantiator = parser.LookupReceiver(node_sequence->scope(), kTestOnly);
     }
     if (!parser.current_function().IsLocalFunction() ||
         ((instantiator != NULL) && instantiator->is_captured())) {
       parsed_function->set_instantiator(
           new LoadLocalNode(node_sequence->token_pos(), *instantiator));
     }
   }
 
   parsed_function->set_default_parameter_values(default_parameter_values);
-  isolate->set_ast_node_id(prev_ast_node_id);
 }
 
 
 // TODO(regis): Implement support for non-const final static fields (currently
 // supported "final" fields are actually const fields).
 // TODO(regis): Since a const variable is implicitly final,
 // rename ParseStaticConstGetter to ParseStaticFinalGetter and
 // rename kConstImplicitGetter to kImplicitFinalGetter.
 SequenceNode* Parser::ParseStaticConstGetter(const Function& func) {
   TRACE_PARSER("ParseStaticConstGetter");
@@ skipping 591 matching lines @@
     AstNode* index_expr = ParseExpr(kAllowConst, kConsumeCascades);
     ExpectToken(Token::kRBRACK);
 
     if (Token::IsAssignmentOperator(CurrentToken()) &&
         (CurrentToken() != Token::kASSIGN)) {
       // Compound assignment. Ensure side effects in index expression
       // only execute once. If the index is not a local variable or an
       // literal, evaluate and save in a temporary local.
       if (!IsSimpleLocalOrLiteralNode(index_expr)) {
         LocalVariable* temp =
-            CreateTempConstVariable(operator_pos, index_expr->id(), "lix");
+            CreateTempConstVariable(operator_pos, "lix");
         AstNode* save =
             new StoreLocalNode(operator_pos, *temp, index_expr);
         current_block_->statements->Add(save);
         index_expr = new LoadLocalNode(operator_pos, *temp);
       }
     }
 
     // Resolve the [] operator function in the superclass.
     const String& index_operator_name =
         String::ZoneHandle(Symbols::IndexToken());
@@ skipping 676 matching lines @@
     // The temporary variables are necessary so that the argument
     // expressions are not evaluated twice.
     ArgumentListNode* ctor_args = super_call->arguments();
     // The super initializer call has at least 2 arguments: the
     // implicit receiver, and the hidden construction phase.
     ASSERT(ctor_args->length() >= 2);
     for (int i = 2; i < ctor_args->length(); i++) {
       AstNode* arg = ctor_args->NodeAt(i);
       if (!IsSimpleLocalOrLiteralNode(arg)) {
         LocalVariable* temp =
-            CreateTempConstVariable(arg->token_pos(), arg->id(), "sca");
+            CreateTempConstVariable(arg->token_pos(), "sca");
         AstNode* save_temp =
             new StoreLocalNode(arg->token_pos(), *temp, arg);
         ctor_args->SetNodeAt(i, save_temp);
       }
     }
   }
   OpenBlock();  // Block to collect constructor body nodes.
 
   // Insert the implicit super call to the super constructor body.
   if (super_call != NULL) {
@@ skipping 4251 matching lines @@
 }
 
 
 void Parser::EnsureExpressionTemp() {
   // Temporary used later by the flow_graph_builder.
   GetIncrementTempLocal();
 }
 
 
 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);
+  OS::SNPrint(name, 64, ":%s%d", s, token_pos);
   LocalVariable* temp =
       new LocalVariable(token_pos,
                         String::ZoneHandle(Symbols::New(name)),
                         Type::ZoneHandle(Type::DynamicType()));
   temp->set_is_final();
   current_block_->scope->AddVariable(temp);
   return temp;
 }
 
 
@@ skipping 79 matching lines @@
 // to control inputs with potential side effects, the store part stores any
 // side effect creating inputs into locals. The load part reads then from
 // those locals. If expr may have side effects, it will be split into two new
 // left and right nodes. 'expr' becomes the right node, left node is returned as
 // result.
 AstNode* Parser::PrepareCompoundAssignmentNodes(AstNode** expr) {
   AstNode* node = *expr;
   if (node->IsLoadIndexedNode()) {
     LoadIndexedNode* left_node = node->AsLoadIndexedNode();
     LoadIndexedNode* right_node = left_node;
-    intptr_t node_id = node->id();
     intptr_t token_pos = node->token_pos();
     node = NULL;  // Do not use it.
     if (!IsSimpleLocalOrLiteralNode(left_node->array())) {
       LocalVariable* temp =
-          CreateTempConstVariable(token_pos, node_id, "lia");
+          CreateTempConstVariable(token_pos, "lia");
       StoreLocalNode* save =
           new StoreLocalNode(token_pos, *temp, left_node->array());
       left_node =
           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_pos, node_id, "lix");
+          CreateTempConstVariable(token_pos, "lix");
       StoreLocalNode* save =
           new StoreLocalNode(token_pos, *temp, left_node->index_expr());
       left_node = new LoadIndexedNode(token_pos,
                                       left_node->array(),
                                       save);
       right_node = new LoadIndexedNode(token_pos,
                                        right_node->array(),
                                        new LoadLocalNode(token_pos, *temp));
     }
     *expr = right_node;
     return left_node;
   }
   if (node->IsInstanceGetterNode()) {
     InstanceGetterNode* left_node = node->AsInstanceGetterNode();
     InstanceGetterNode* right_node = left_node;
-    intptr_t node_id = node->id();
     intptr_t token_pos = node->token_pos();
     node = NULL;  // Do not use it.
     if (!IsSimpleLocalOrLiteralNode(left_node->receiver())) {
       LocalVariable* temp =
-          CreateTempConstVariable(token_pos, node_id, "igr");
+          CreateTempConstVariable(token_pos, "igr");
       StoreLocalNode* save =
           new StoreLocalNode(token_pos, *temp, left_node->receiver());
       left_node = new InstanceGetterNode(token_pos,
                                          save,
                                          left_node->field_name());
       right_node = new InstanceGetterNode(token_pos,
                                           new LoadLocalNode(token_pos, *temp),
                                           right_node->field_name());
     }
     *expr = right_node;
@@ skipping 12 matching lines @@
        result->IsStaticSetterNode())) {
     EnsureExpressionTemp();
   }
   return result;
 }
 
 
 AstNode* Parser::ParseCascades(AstNode* expr) {
   intptr_t cascade_pos = TokenPos();
   LocalVariable* cascade_receiver_var =
-      CreateTempConstVariable(cascade_pos, expr->id(), "casc");
+      CreateTempConstVariable(cascade_pos, "casc");
   StoreLocalNode* save_cascade =
       new StoreLocalNode(cascade_pos, *cascade_receiver_var, expr);
   current_block_->statements->Add(save_cascade);
   while (CurrentToken() == Token::kCASCADE) {
     cascade_pos = TokenPos();
     LoadLocalNode* load_cascade_receiver =
         new LoadLocalNode(cascade_pos, *cascade_receiver_var);
     if (Token::IsIdentifier(LookaheadToken(1))) {
       // Replace .. with . for ParseSelectors().
       token_kind_ = Token::kPERIOD;
@@ skipping 1394 matching lines @@
 
 ConstructorCallNode* Parser::CreateConstructorCallNode(
     intptr_t token_pos,
     const AbstractTypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
   if (!type_arguments.IsNull() && !type_arguments.IsInstantiated()) {
     EnsureExpressionTemp();
   }
   LocalVariable* allocated =
-      CreateTempConstVariable(token_pos, token_pos, "alloc");
+      CreateTempConstVariable(token_pos, "alloc");
   return new ConstructorCallNode(token_pos,
                                  type_arguments,
                                  constructor,
                                  arguments,
                                  *allocated);
 }
 
 
 static void AddKeyValuePair(ArrayNode* pairs,
                             bool is_const,
@@ skipping 1051 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart