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

runtime/vm/kernel_binary.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.
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "platform/globals.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/kernel.h"
 #include "vm/kernel_to_il.h"
@@ skipping 310 matching lines @@
   MallocGrowableArray<CanonicalName*> canonical_names_;
   BlockStack<VariableDeclaration> scope_;
   BlockStack<TypeParameter> type_parameters_;
   BlockStack<SwitchCase> switch_cases_;
   BlockStack<LabeledStatement>* labels_;
 };
 
 
 class Reader {
  public:
-  Reader(const uint8_t* buffer, int64_t size)
+  Reader(const uint8_t* buffer, intptr_t size)
       : buffer_(buffer), size_(size), offset_(0) {}
 
   uint32_t ReadUInt32() {
     ASSERT(offset_ + 4 <= size_);
 
     uint32_t value = (buffer_[offset_ + 0] << 24) |
                      (buffer_[offset_ + 1] << 16) |
                      (buffer_[offset_ + 2] << 8) | (buffer_[offset_ + 3] << 0);
     offset_ += 4;
     return value;
@@ skipping 152 matching lines @@
     return name;
   }
 
   CanonicalName* ReadDefiningCanonicalNameReference(LinkedNode* node_to_link) {
     CanonicalName* name = ReadCanonicalNameReference();
     ASSERT(name != NULL);
     name->BindTo(node_to_link);
     return name;
   }
 
+  intptr_t offset() { return offset_; }
+
  private:
   const uint8_t* buffer_;
-  int64_t size_;
-  int64_t offset_;
+  intptr_t size_;
+  intptr_t offset_;
   ReaderHelper builder_;
   TokenPosition max_position_;
   TokenPosition min_position_;
   intptr_t current_script_id_;
 
   friend class PositionScope;
 };
 
 
 // A helper class that resets the readers min and max positions both upon
@@ skipping 111 matching lines @@
     TRACE_READ_OFFSET();
     return String::ReadFromImpl(reader);
   }
 };
 
 
 class VariableDeclarationImpl {
  public:
   static VariableDeclaration* ReadFrom(Reader* reader) {
     TRACE_READ_OFFSET();
-    return VariableDeclaration::ReadFromImpl(reader);
+    return VariableDeclaration::ReadFromImpl(reader, false);
   }
 };
 
 
 String* String::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   return Reference::ReadStringFrom(reader);
 }
 
 
@@ skipping 146 matching lines @@
 
 
 String* Reference::ReadStringFrom(Reader* reader) {
   int index = reader->ReadUInt();
   return reader->helper()->program()->string_table().strings()[index];
 }
 
 
 Field* Field::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
+  kernel_offset_ = reader->offset();  // Notice the ReadTag() below.
   Tag tag = reader->ReadTag();
   ASSERT(tag == kField);
 
   reader->ReadDefiningCanonicalNameReference(this);
   position_ = reader->ReadPosition(false);
   end_position_ = reader->ReadPosition(false);
   flags_ = reader->ReadFlags();
   name_ = Name::ReadFrom(reader);
   source_uri_index_ = reader->ReadUInt();
   reader->set_current_script_id(source_uri_index_);
@@ skipping 97 matching lines @@
   RedirectingInitializer* init = new RedirectingInitializer();
   init->target_reference_ = Reference::ReadMemberFrom(reader);
   init->arguments_ = Arguments::ReadFrom(reader);
   return init;
 }
 
 
 LocalInitializer* LocalInitializer::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
   LocalInitializer* init = new LocalInitializer();
-  init->variable_ = VariableDeclaration::ReadFromImpl(reader);
+  init->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
   return init;
 }
 
 
 Expression* Expression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   uint8_t payload = 0;
   Tag tag = reader->ReadTag(&payload);
   switch (tag) {
     case kInvalidExpression:
@@ skipping 447 matching lines @@
   AwaitExpression* await = new AwaitExpression();
   await->operand_ = Expression::ReadFrom(reader);
   return await;
 }
 
 
 FunctionExpression* FunctionExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   VariableScope<ReaderHelper> parameters(reader->helper());
   FunctionExpression* expr = new FunctionExpression();
+  expr->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   expr->function_ = FunctionNode::ReadFrom(reader);
   return expr;
 }
 
 
 Let* Let::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   VariableScope<ReaderHelper> vars(reader->helper());
   PositionScope scope(reader);
 
   Let* let = new Let();
-  let->variable_ = VariableDeclaration::ReadFromImpl(reader);
+  let->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
+  let->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
   let->body_ = Expression::ReadFrom(reader);
   let->position_ = reader->min_position();
   let->end_position_ = reader->max_position();
 
   return let;
 }
 
 
 Statement* Statement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
@@ skipping 31 matching lines @@
       return IfStatement::ReadFrom(reader);
     case kReturnStatement:
       return ReturnStatement::ReadFrom(reader);
     case kTryCatch:
       return TryCatch::ReadFrom(reader);
     case kTryFinally:
       return TryFinally::ReadFrom(reader);
     case kYieldStatement:
       return YieldStatement::ReadFrom(reader);
     case kVariableDeclaration:
-      return VariableDeclaration::ReadFromImpl(reader);
+      return VariableDeclaration::ReadFromImpl(reader, true);
     case kFunctionDeclaration:
       return FunctionDeclaration::ReadFrom(reader);
     default:
       UNREACHABLE();
   }
   return NULL;
 }
 
 
 InvalidStatement* InvalidStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   return new InvalidStatement();
 }
 
 
 ExpressionStatement* ExpressionStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   return new ExpressionStatement(Expression::ReadFrom(reader));
 }
 
 
 Block* Block::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
   PositionScope scope(reader);
 
   VariableScope<ReaderHelper> vars(reader->helper());
   Block* block = new Block();
+  block->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   block->statements().ReadFromStatic<Statement>(reader);
   block->position_ = reader->min_position();
   block->end_position_ = reader->max_position();
 
   return block;
 }
 
 
 EmptyStatement* EmptyStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
@@ skipping 46 matching lines @@
   return dostmt;
 }
 
 
 ForStatement* ForStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   VariableScope<ReaderHelper> vars(reader->helper());
   PositionScope scope(reader);
 
   ForStatement* forstmt = new ForStatement();
+  forstmt->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   forstmt->variables_.ReadFromStatic<VariableDeclarationImpl>(reader);
   forstmt->condition_ = reader->ReadOptional<Expression>();
   forstmt->updates_.ReadFromStatic<Expression>(reader);
   forstmt->body_ = Statement::ReadFrom(reader);
   forstmt->end_position_ = reader->max_position();
   forstmt->position_ = reader->min_position();
 
   return forstmt;
 }
 
 
 ForInStatement* ForInStatement::ReadFrom(Reader* reader, bool is_async) {
   TRACE_READ_OFFSET();
   VariableScope<ReaderHelper> vars(reader->helper());
   PositionScope scope(reader);
 
   ForInStatement* forinstmt = new ForInStatement();
+  forinstmt->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   forinstmt->is_async_ = is_async;
   forinstmt->position_ = reader->ReadPosition();
-  forinstmt->variable_ = VariableDeclaration::ReadFromImpl(reader);
+  forinstmt->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
   forinstmt->iterable_ = Expression::ReadFrom(reader);
   forinstmt->body_ = Statement::ReadFrom(reader);
   forinstmt->end_position_ = reader->max_position();
   if (!forinstmt->position_.IsReal()) {
     forinstmt->position_ = reader->min_position();
   }
   forinstmt->variable_->set_end_position(forinstmt->position_);
 
   return forinstmt;
 }
@@ skipping 71 matching lines @@
   return tc;
 }
 
 
 Catch* Catch::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   VariableScope<ReaderHelper> vars(reader->helper());
   PositionScope scope(reader);
 
   Catch* c = new Catch();
+  c->kernel_offset_ = reader->offset();  // Catch has no tag.
   c->guard_ = DartType::ReadFrom(reader);
   c->exception_ =
       reader->ReadOptional<VariableDeclaration, VariableDeclarationImpl>();
   c->stack_trace_ =
       reader->ReadOptional<VariableDeclaration, VariableDeclarationImpl>();
   c->body_ = Statement::ReadFrom(reader);
   c->end_position_ = reader->max_position();
   c->position_ = reader->min_position();
 
   return c;
@@ skipping 17 matching lines @@
   stmt->flags_ = reader->ReadByte();
   stmt->expression_ = Expression::ReadFrom(reader);
   return stmt;
 }
 
 
 VariableDeclaration* VariableDeclaration::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   ASSERT(tag == kVariableDeclaration);
-  return VariableDeclaration::ReadFromImpl(reader);
+  return VariableDeclaration::ReadFromImpl(reader, true);
 }
 
 
-VariableDeclaration* VariableDeclaration::ReadFromImpl(Reader* reader) {
+VariableDeclaration* VariableDeclaration::ReadFromImpl(Reader* reader,
+                                                       bool read_tag) {
   TRACE_READ_OFFSET();
   PositionScope scope(reader);
 
   VariableDeclaration* decl = new VariableDeclaration();
+  // -1 or -0 depending on whether there's a tag or not.
+  decl->kernel_offset_ = reader->offset() - (read_tag ? 1 : 0);
   decl->position_ = reader->ReadPosition();
   decl->equals_position_ = reader->ReadPosition();
   decl->flags_ = reader->ReadFlags();
   decl->name_ = Reference::ReadStringFrom(reader);
   decl->type_ = DartType::ReadFrom(reader);
   decl->inferred_value_ = reader->ReadOptional<InferredValue>();
   decl->initializer_ = reader->ReadOptional<Expression>();
 
   // Go to next token position so it ends *after* the last potentially
   // debuggable position in the initializer.
   TokenPosition position = reader->max_position();
   if (position.IsReal()) position.Next();
   decl->end_position_ = position;
   reader->helper()->variables().Push(decl);
 
   return decl;
 }
 
 
 FunctionDeclaration* FunctionDeclaration::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   FunctionDeclaration* decl = new FunctionDeclaration();
+  decl->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   decl->position_ = reader->ReadPosition();
-  decl->variable_ = VariableDeclaration::ReadFromImpl(reader);
+  decl->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
   VariableScope<ReaderHelper> parameters(reader->helper());
   decl->function_ = FunctionNode::ReadFrom(reader);
   return decl;
 }
 
 
 Name* Name::ReadFrom(Reader* reader) {
   String* string = Reference::ReadStringFrom(reader);
   if (string->size() >= 1 && string->buffer()[0] == '_') {
     CanonicalName* library_reference = reader->ReadCanonicalNameReference();
@@ skipping 160 matching lines @@
 
   return program;
 }
 
 
 FunctionNode* FunctionNode::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   TypeParameterScope<ReaderHelper> scope(reader->helper());
 
   FunctionNode* function = new FunctionNode();
+  function->kernel_offset_ = reader->offset();  // FunctionNode has no tag.
   function->position_ = reader->ReadPosition();
   function->end_position_ = reader->ReadPosition();
   function->async_marker_ =
       static_cast<FunctionNode::AsyncMarker>(reader->ReadByte());
   function->dart_async_marker_ =
       static_cast<FunctionNode::AsyncMarker>(reader->ReadByte());
   function->type_parameters().ReadFrom(reader);
   function->required_parameter_count_ = reader->ReadUInt();
   function->positional_parameters().ReadFromStatic<VariableDeclarationImpl>(
       reader);
@@ skipping 22 matching lines @@
 
 kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer,
                                                  intptr_t buffer_length) {
   kernel::Reader reader(buffer, buffer_length);
   return kernel::Program::ReadFrom(&reader);
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)