[kernel] Don't use kernel ast nodes as keys

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, 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 <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 43 matching lines @@
       parent = Field::Cast(*outermost_node)->parent();
     }
     if (parent != NULL && parent->IsClass()) *klass = Class::Cast(parent);
   }
 }
 
 
 void ScopeBuilder::EnterScope(TreeNode* node, TokenPosition start_position) {
   scope_ = new (Z) LocalScope(scope_, depth_.function_, depth_.loop_);
   scope_->set_begin_token_pos(start_position);
-  result_->scopes.Insert(node, scope_);
+  ASSERT(node->kernel_offset() >= 0);
+  result_->scopes.Insert(node->kernel_offset(), scope_);
 }
 
 
 void ScopeBuilder::ExitScope(TokenPosition end_position) {
   scope_->set_end_token_pos(end_position);
   scope_ = scope_->parent();
 }
 
 
 LocalVariable* ScopeBuilder::MakeVariable(TokenPosition declaration_pos,
@@ skipping 18 matching lines @@
 
 void ScopeBuilder::AddParameter(VariableDeclaration* declaration,
                                 intptr_t pos) {
   LocalVariable* variable = MakeVariable(
       declaration->position(), declaration->position(),
       H.DartSymbol(declaration->name()), T.TranslateVariableType(declaration));
   if (declaration->IsFinal()) {
     variable->set_is_final();
   }
   scope_->InsertParameterAt(pos, variable);
-  result_->locals.Insert(declaration, variable);
+  result_->locals.Insert(declaration->kernel_offset(), variable);
 
   // The default value may contain 'let' bindings for which the constant
   // evaluator needs scope bindings.
   Expression* defaultValue = declaration->initializer();
   if (defaultValue != NULL) {
     defaultValue->AcceptExpressionVisitor(this);
   }
 }
 
 
@@ skipping 64 matching lines @@
   LocalVariable* iterator =
       MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                    GenerateName(":iterator", depth_.for_in_ - 1),
                    AbstractType::dynamic_type());
   current_function_scope_->AddVariable(iterator);
   result_->iterator_variables.Add(iterator);
 }
 
 
 void ScopeBuilder::LookupVariable(VariableDeclaration* declaration) {
-  LocalVariable* variable = result_->locals.Lookup(declaration);
+  LocalVariable* variable =
+      result_->locals.Lookup(declaration->kernel_offset());
   if (variable == NULL) {
     // We have not seen a declaration of the variable, so it must be the
     // case that we are compiling a nested function and the variable is
     // declared in an outer scope.  In that case, look it up in the scope by
     // name and add it to the variable map to simplify later lookup.
     ASSERT(current_function_scope_->parent() != NULL);
     const dart::String& name = H.DartSymbol(declaration->name());
     variable = current_function_scope_->parent()->LookupVariable(name, true);
     ASSERT(variable != NULL);
-    result_->locals.Insert(declaration, variable);
+    result_->locals.Insert(declaration->kernel_offset(), variable);
   }
   if (variable->owner()->function_level() < scope_->function_level()) {
     // We call `LocalScope->CaptureVariable(variable)` in two scenarios for two
     // different reasons:
     //   Scenario 1:
     //       We need to know which variables defined in this function
     //       are closed over by nested closures in order to ensure we will
     //       create a [Context] object of appropriate size and store captured
     //       variables there instead of the stack.
     //   Scenario 2:
@@ skipping 33 matching lines @@
   const dart::String& name = declaration->name()->is_empty()
                                  ? GenerateName(":var", name_index_++)
                                  : H.DartSymbol(declaration->name());
   LocalVariable* variable =
       MakeVariable(declaration->position(), declaration->end_position(), name,
                    T.TranslateVariableType(declaration));
   if (declaration->IsFinal()) {
     variable->set_is_final();
   }
   scope_->AddVariable(variable);
-  result_->locals.Insert(declaration, variable);
+  result_->locals.Insert(declaration->kernel_offset(), variable);
 }
 
 
 static bool IsStaticInitializer(const Function& function, Zone* zone) {
   return (function.kind() == RawFunction::kImplicitStaticFinalGetter) &&
          dart::String::Handle(zone, function.name())
              .StartsWith(Symbols::InitPrefix());
 }
 
 
@@ skipping 222 matching lines @@
 void ScopeBuilder::HandleLocalFunction(TreeNode* parent,
                                        FunctionNode* function) {
   LocalScope* saved_function_scope = current_function_scope_;
   FunctionNode* saved_function_node = current_function_node_;
   ScopeBuilder::DepthState saved_depth_state = depth_;
   depth_ = DepthState(depth_.function_ + 1);
   EnterScope(parent, function->position());
   current_function_scope_ = scope_;
   current_function_node_ = function;
   if (depth_.function_ == 1) {
-    FunctionScope function_scope = {function, scope_};
+    FunctionScope function_scope = {function->kernel_offset(), scope_};
     result_->function_scopes.Add(function_scope);
   }
   AddParameters(function);
   VisitFunctionNode(function);
   ExitScope(function->end_position());
   depth_ = saved_depth_state;
   current_function_scope_ = saved_function_scope;
   current_function_node_ = saved_function_node;
 }
 
@@ skipping 1501 matching lines @@
   context_depth_ = saved_depth;
   try_depth_ = saved_try_depth;
 
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::EnterScope(TreeNode* node, bool* new_context) {
   Fragment instructions;
   const intptr_t context_size =
-      scopes_->scopes.Lookup(node)->num_context_variables();
+      scopes_->scopes.Lookup(node->kernel_offset())->num_context_variables();
   if (context_size > 0) {
     instructions += PushContext(context_size);
     instructions += Drop();
     if (new_context != NULL) {
       *new_context = true;
     }
   }
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::ExitScope(TreeNode* node) {
   Fragment instructions;
   const intptr_t context_size =
-      scopes_->scopes.Lookup(node)->num_context_variables();
+      scopes_->scopes.Lookup(node->kernel_offset())->num_context_variables();
   if (context_size > 0) {
     instructions += PopContext();
   }
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::LoadContextAt(int depth) {
   intptr_t delta = context_depth_ - depth;
   ASSERT(delta >= 0);
@@ skipping 832 matching lines @@
   if (try_catch_block_ == NULL) {
     return CatchClauseNode::kInvalidTryIndex;
   } else {
     return try_catch_block_->try_index();
   }
 }
 
 
 dart::LocalVariable* FlowGraphBuilder::LookupVariable(
     VariableDeclaration* var) {
-  LocalVariable* local = scopes_->locals.Lookup(var);
+  LocalVariable* local = scopes_->locals.Lookup(var->kernel_offset());
   ASSERT(local != NULL);
   return local;
 }
 
 
 void FlowGraphBuilder::SetTempIndex(Definition* definition) {
   definition->set_temp_index(
       stack_ == NULL ? 0 : stack_->definition()->temp_index() + 1);
 }
 
@@ skipping 3354 matching lines @@
   fragment_ = continuation;
 }
 
 
 Fragment FlowGraphBuilder::TranslateFunctionNode(FunctionNode* node,
                                                  TreeNode* parent) {
   // The VM has a per-isolate table of functions indexed by the enclosing
   // function and token position.
   Function& function = Function::ZoneHandle(Z);
   for (intptr_t i = 0; i < scopes_->function_scopes.length(); ++i) {
-    if (scopes_->function_scopes[i].function != node) continue;
+    if (scopes_->function_scopes[i].kernel_offset != node->kernel_offset()) {
+      continue;
+    }
 
     TokenPosition position = node->position();
     if (parent->IsFunctionDeclaration()) {
       position = FunctionDeclaration::Cast(parent)->position();
     }
     if (!position.IsReal()) {
       // Positions has to be unique in regards to the parent.
       // A non-real at this point is probably -1, we cannot blindly use that
       // as others might use it too. Create a new dummy non-real TokenPosition.
       position = TokenPosition(i).ToSynthetic();
@@ skipping 188 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)