Merge of source position information from kernel-sdk.

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 <map>
 #include <vector>
 
 #include "platform/globals.h"
 #include "vm/flags.h"
@@ skipping 337 matching lines @@
       // 11...
       ASSERT(offset_ + 4 <= size_);
       uint32_t value = ((byte0 & ~0xc0) << 24) | (buffer_[offset_ + 1] << 16) |
                        (buffer_[offset_ + 2] << 8) |
                        (buffer_[offset_ + 3] << 0);
       offset_ += 4;
       return value;
     }
   }
 
+  TokenPosition ReadPosition() {
+    intptr_t value = ReadUInt();
+    // Position is saved as unsigned,
+    // but actually ranges from -1 and up (thus the -1)
+    return TokenPosition(value - 1);
+  }
+
   intptr_t ReadListLength() { return ReadUInt(); }
 
   uint8_t ReadByte() { return buffer_[offset_++]; }
 
   bool ReadBool() { return (ReadByte() & 1) == 1; }
 
   word ReadFlags() { return ReadByte(); }
 
   Tag ReadTag(uint8_t* payload = NULL) {
     uint8_t byte = ReadByte();
@@ skipping 175 matching lines @@
   void WriteTag(Tag tag, uint8_t payload) {
     ASSERT((payload & ~kSpecializedPayloadMask) == 0);
     WriteByte(kSpecializedTagHighBit | static_cast<uint8_t>(tag) | payload);
   }
 
   void WriteBytes(uint8_t* bytes, int length) {
     out_->WriteBytes(bytes, length);
     offset_ += length;
   }
 
+  void WritePosition(TokenPosition position) {
+    intptr_t value = position.value() + 1;
+    WriteUInt(value);
+  }
+
   template <typename T>
   void WriteOptional(T* object) {
     if (object == NULL) {
       WriteTag(kNothing);
     } else {
       WriteTag(kSomething);
       object->WriteTo(this);
     }
   }
 
@@ skipping 224 matching lines @@
   strings_.WriteToStatic<StringImpl>(writer);
 
   // Build up the "String* -> index" table.
   WriterHelper* helper = writer->helper();
   for (int i = 0; i < strings_.length(); i++) {
     helper->strings().Push(strings_[i]);
   }
 }
 
 
-void LineStartingTable::ReadFrom(Reader* reader, intptr_t length) {
-  size_ = length;
+void LineStartingTable::ReadFrom(Reader* reader) {
+  size_ = reader->helper()->program()->source_uri_table().strings().length();
   values_ = new intptr_t*[size_];
   for (intptr_t i = 0; i < size_; ++i) {
     intptr_t line_count = reader->ReadUInt();
     intptr_t* line_starts = new intptr_t[line_count + 1];
     line_starts[0] = line_count;
     intptr_t previous_line_start = 0;
     for (intptr_t j = 0; j < line_count; ++j) {
-      intptr_t lineStart = reader->ReadUInt() + previous_line_start;
-      line_starts[j + 1] = lineStart;
-      previous_line_start = lineStart;
+      intptr_t line_start = reader->ReadUInt() + previous_line_start;
+      line_starts[j + 1] = line_start;
+      previous_line_start = line_start;
     }
     values_[i] = line_starts;
   }
 }
 
 
 void LineStartingTable::WriteTo(Writer* writer) {
   for (intptr_t i = 0; i < size_; ++i) {
     intptr_t* line_starts = values_[i];
     intptr_t line_count = line_starts[0];
     writer->WriteUInt(line_count);
 
     intptr_t previous_line_start = 0;
     for (intptr_t j = 0; j < line_count; ++j) {
       intptr_t line_start = line_starts[j + 1];
       writer->WriteUInt(line_start - previous_line_start);
       previous_line_start = line_start;
     }
   }
 }
 
 
 Library* Library::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   int flags = reader->ReadFlags();
   ASSERT(flags == 0);  // external libraries not supported
   name_ = Reference::ReadStringFrom(reader);
   import_uri_ = Reference::ReadStringFrom(reader);
-  reader->ReadUInt();
+  source_uri_index_ = reader->ReadUInt();
 
   int num_classes = reader->ReadUInt();
   classes().EnsureInitialized(num_classes);
   for (int i = 0; i < num_classes; i++) {
     Tag tag = reader->ReadTag();
     if (tag == kNormalClass) {
       NormalClass* klass = classes().GetOrCreate<NormalClass>(i, this);
       klass->ReadFrom(reader);
     } else {
       ASSERT(tag == kMixinClass);
       MixinClass* klass = classes().GetOrCreate<MixinClass>(i, this);
       klass->ReadFrom(reader);
     }
   }
 
   fields().ReadFrom<Field>(reader, this);
   procedures().ReadFrom<Procedure>(reader, this);
   return this;
 }
 
 
 void Library::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   name_->WriteTo(writer);
   import_uri_->WriteTo(writer);
-  writer->WriteUInt(0);
+  writer->WriteUInt(source_uri_index_);
 
   writer->WriteUInt(classes_.length());
   for (int i = 0; i < classes_.length(); i++) {
     Class* klass = classes_[i];
     if (klass->IsNormalClass()) {
       writer->WriteTag(kNormalClass);
       NormalClass::Cast(klass)->WriteTo(writer);
     } else {
       writer->WriteTag(kMixinClass);
       MixinClass::Cast(klass)->WriteTo(writer);
     }
   }
   fields().WriteTo(writer);
   procedures().WriteTo(writer);
 }
 
 
 Class* Class::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
 
   is_abstract_ = reader->ReadBool();
   name_ = Reference::ReadStringFrom(reader);
-  reader->ReadUInt();
+  source_uri_index_ = reader->ReadUInt();
   annotations_.ReadFromStatic<Expression>(reader);
 
   return this;
 }
 
 
 void Class::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteBool(is_abstract_);
   name_->WriteTo(writer);
-  writer->WriteUInt(0);
+  writer->WriteUInt(source_uri_index_);
   annotations_.WriteTo(writer);
 }
 
 
 NormalClass* NormalClass::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Class::ReadFrom(reader);
   TypeParameterScope<ReaderHelper> scope(reader->helper());
 
   type_parameters_.ReadFrom(reader);
@@ skipping 213 matching lines @@
   int index = writer->helper()->strings().Lookup(string);
   writer->WriteUInt(index);
 }
 
 
 Field* Field::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   ASSERT(tag == kField);
 
-  reader->ReadUInt();
+  position_ = reader->ReadPosition();
   flags_ = reader->ReadFlags();
   name_ = Name::ReadFrom(reader);
-  reader->ReadUInt();
+  source_uri_index_ = reader->ReadUInt();
   annotations_.ReadFromStatic<Expression>(reader);
   type_ = DartType::ReadFrom(reader);
   inferred_value_ = reader->ReadOptional<InferredValue>();
   initializer_ = reader->ReadOptional<Expression>();
   return this;
 }
 
 
 void Field::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kField);
-  writer->WriteUInt(0);
+  writer->WritePosition(position_);
   writer->WriteFlags(flags_);
   name_->WriteTo(writer);
-  writer->WriteUInt(0);
+  writer->WriteUInt(source_uri_index_);
   annotations_.WriteTo(writer);
   type_->WriteTo(writer);
   writer->WriteOptional<InferredValue>(inferred_value_);
   writer->WriteOptional<Expression>(initializer_);
 }
 
 
 Constructor* Constructor::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
@@ skipping 24 matching lines @@
 
 Procedure* Procedure::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   ASSERT(tag == kProcedure);
 
   VariableScope<ReaderHelper> parameters(reader->helper());
   kind_ = static_cast<ProcedureKind>(reader->ReadByte());
   flags_ = reader->ReadFlags();
   name_ = Name::ReadFrom(reader);
-  reader->ReadUInt();
+  source_uri_index_ = reader->ReadUInt();
   annotations_.ReadFromStatic<Expression>(reader);
   function_ = reader->ReadOptional<FunctionNode>();
   return this;
 }
 
 
 void Procedure::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kProcedure);
 
   VariableScope<WriterHelper> parameters(writer->helper());
   writer->WriteByte(kind_);
   writer->WriteFlags(flags_);
   name_->WriteTo(writer);
-  writer->WriteUInt(0);
+  writer->WriteUInt(source_uri_index_);
   annotations_.WriteTo(writer);
   writer->WriteOptional<FunctionNode>(function_);
 }
 
 
 Initializer* Initializer::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   switch (tag) {
     case kInvalidInitializer:
@@ skipping 262 matching lines @@
     writer->WriteTag(kVariableSet);
     writer->WriteUInt(index);
   }
   expression_->WriteTo(writer);
 }
 
 
 PropertyGet* PropertyGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   PropertyGet* get = new PropertyGet();
-  reader->ReadUInt();
+  get->position_ = reader->ReadPosition();
   get->receiver_ = Expression::ReadFrom(reader);
   get->name_ = Name::ReadFrom(reader);
   get->interfaceTarget_ = Reference::ReadMemberFrom(reader, true);
   return get;
 }
 
 
 void PropertyGet::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kPropertyGet);
-  writer->WriteUInt(0);
+  writer->WritePosition(position_);
   receiver_->WriteTo(writer);
   name_->WriteTo(writer);
   Reference::WriteMemberTo(writer, interfaceTarget_, true);
 }
 
 
 PropertySet* PropertySet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   PropertySet* set = new PropertySet();
-  reader->ReadUInt();
+  set->position_ = reader->ReadPosition();
   set->receiver_ = Expression::ReadFrom(reader);
   set->name_ = Name::ReadFrom(reader);
   set->value_ = Expression::ReadFrom(reader);
   set->interfaceTarget_ = Reference::ReadMemberFrom(reader, true);
   return set;
 }
 
 
 void PropertySet::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kPropertySet);
-  writer->WriteUInt(0);
+  writer->WritePosition(position_);
   receiver_->WriteTo(writer);
   name_->WriteTo(writer);
   value_->WriteTo(writer);
   Reference::WriteMemberTo(writer, interfaceTarget_, true);
 }
 
 
 DirectPropertyGet* DirectPropertyGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   DirectPropertyGet* get = new DirectPropertyGet();
@@ skipping 26 matching lines @@
   writer->WriteTag(kDirectPropertySet);
   receiver_->WriteTo(writer);
   Reference::WriteMemberTo(writer, target_);
   value_->WriteTo(writer);
 }
 
 
 StaticGet* StaticGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   StaticGet* get = new StaticGet();
-  reader->ReadUInt();
+  get->position_ = reader->ReadPosition();
   get->target_ = Reference::ReadMemberFrom(reader);
   return get;
 }
 
 
 void StaticGet::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kStaticGet);
-  writer->WriteUInt(0);
+  writer->WritePosition(position_);
   Reference::WriteMemberTo(writer, target_);
 }
 
 
 StaticSet* StaticSet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   StaticSet* set = new StaticSet();
   set->target_ = Reference::ReadMemberFrom(reader);
   set->expression_ = Expression::ReadFrom(reader);
   return set;
@@ skipping 37 matching lines @@
 void NamedExpression::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   name_->WriteTo(writer);
   expression_->WriteTo(writer);
 }
 
 
 MethodInvocation* MethodInvocation::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   MethodInvocation* invocation = new MethodInvocation();
-  reader->ReadUInt();
+  invocation->position_ = reader->ReadPosition();
   invocation->receiver_ = Expression::ReadFrom(reader);
   invocation->name_ = Name::ReadFrom(reader);
   invocation->arguments_ = Arguments::ReadFrom(reader);
   invocation->interfaceTarget_ = Reference::ReadMemberFrom(reader, true);
   return invocation;
 }
 
 
 void MethodInvocation::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kMethodInvocation);
-  writer->WriteUInt(0);
+  writer->WritePosition(position_);
   receiver_->WriteTo(writer);
   name_->WriteTo(writer);
   arguments_->WriteTo(writer);
   Reference::WriteMemberTo(writer, interfaceTarget_, true);
 }
 
 
 DirectMethodInvocation* DirectMethodInvocation::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   DirectMethodInvocation* invocation = new DirectMethodInvocation();
   invocation->receiver_ = Expression::ReadFrom(reader);
   invocation->target_ = Procedure::Cast(Reference::ReadMemberFrom(reader));
   invocation->arguments_ = Arguments::ReadFrom(reader);
   return invocation;
 }
 
 
 void DirectMethodInvocation::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kDirectMethodInvocation);
   receiver_->WriteTo(writer);
   Reference::WriteMemberTo(writer, target_);
   arguments_->WriteTo(writer);
 }
 
 
 StaticInvocation* StaticInvocation::ReadFrom(Reader* reader, bool is_const) {
   TRACE_READ_OFFSET();
-
-  reader->ReadUInt();
-  Member* member = Reference::ReadMemberFrom(reader);
-  Arguments* args = Arguments::ReadFrom(reader);
-
-  return new StaticInvocation(Procedure::Cast(member), args, is_const);
+  StaticInvocation* invocation = new StaticInvocation();
+  invocation->is_const_ = is_const;
+  invocation->position_ = reader->ReadPosition();
+  invocation->procedure_ = Procedure::Cast(Reference::ReadMemberFrom(reader));
+  invocation->arguments_ = Arguments::ReadFrom(reader);
+  return invocation;
 }
 
 
 void StaticInvocation::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(is_const_ ? kConstStaticInvocation : kStaticInvocation);
-  writer->WriteUInt(0);
+  writer->WritePosition(position_);
   Reference::WriteMemberTo(writer, procedure_);
   arguments_->WriteTo(writer);
 }
 
 
 ConstructorInvocation* ConstructorInvocation::ReadFrom(Reader* reader,
                                                        bool is_const) {
   TRACE_READ_OFFSET();
   ConstructorInvocation* invocation = new ConstructorInvocation();
   invocation->is_const_ = is_const;
-  reader->ReadUInt();
+  invocation->position_ = reader->ReadPosition();
   invocation->target_ = Constructor::Cast(Reference::ReadMemberFrom(reader));
   invocation->arguments_ = Arguments::ReadFrom(reader);
   return invocation;
 }
 
 
 void ConstructorInvocation::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(is_const_ ? kConstConstructorInvocation
                              : kConstructorInvocation);
-  writer->WriteUInt(0);
+  writer->WritePosition(position_);
   Reference::WriteMemberTo(writer, target_);
   arguments_->WriteTo(writer);
 }
 
 
 Not* Not::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Not* n = new Not();
   n->expression_ = Expression::ReadFrom(reader);
   return n;
@@ skipping 242 matching lines @@
 
 void Rethrow::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kRethrow);
 }
 
 
 Throw* Throw::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Throw* t = new Throw();
-  reader->ReadUInt();
+  t->position_ = reader->ReadPosition();
   t->expression_ = Expression::ReadFrom(reader);
   return t;
 }
 
 
 void Throw::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kThrow);
-  writer->WriteUInt(0);
+  writer->WritePosition(position_);
   expression_->WriteTo(writer);
 }
 
 
 ListLiteral* ListLiteral::ReadFrom(Reader* reader, bool is_const) {
   TRACE_READ_OFFSET();
   ListLiteral* literal = new ListLiteral();
   literal->is_const_ = is_const;
   literal->type_ = DartType::ReadFrom(reader);
   literal->expressions_.ReadFromStatic<Expression>(reader);
@@ skipping 789 matching lines @@
 
 Program* Program::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   uint32_t magic = reader->ReadUInt32();
   if (magic != kMagicProgramFile) FATAL("Invalid magic identifier");
 
   Program* program = new Program();
   reader->helper()->set_program(program);
 
   program->string_table_.ReadFrom(reader);
-  StringTable dummy1;
-  dummy1.ReadFrom(reader);
-  LineStartingTable dummy2;
-  dummy2.ReadFrom(reader, dummy1.strings_.length());
+  program->source_uri_table_.ReadFrom(reader);
+  program->line_starting_table_.ReadFrom(reader);
 
   int libraries = reader->ReadUInt();
   program->libraries().EnsureInitialized(libraries);
   for (int i = 0; i < libraries; i++) {
     program->libraries().GetOrCreate<Library>(i)->ReadFrom(reader);
   }
 
   program->main_method_ = Procedure::Cast(Reference::ReadMemberFrom(reader));
 
   return program;
 }
 
 
 void Program::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
 
   writer->helper()->SetProgram(this);
 
   writer->WriteUInt32(kMagicProgramFile);
 
   // NOTE: Currently we don't GC strings and we require that all referenced
   // strings in nodes are present in [string_table_].
   string_table_.WriteTo(writer);
-  StringTable dummy1;
-  dummy1.WriteTo(writer);
-  LineStartingTable dummy2;
-  dummy2.WriteTo(writer);
+  source_uri_table_.WriteTo(writer);
+  line_starting_table_.WriteTo(writer);
 
   libraries_.WriteTo(writer);
   Reference::WriteMemberTo(writer, main_method_);
 }
 
 
 FunctionNode* FunctionNode::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   TypeParameterScope<ReaderHelper> scope(reader->helper());
 
@@ skipping 59 matching lines @@
 void WritePrecompiledKernel(ByteWriter* byte_writer, kernel::Program* program) {
   ASSERT(byte_writer != NULL);
 
   kernel::Writer writer(byte_writer);
   program->WriteTo(&writer);
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)