TokenPositions on more nodes when running from Kernel

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 354 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;
     }
   }
 
+  /**
+   * Read and return a TokenPosition from this reader.
+   */
   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 value = ReadUInt() - 1;
+    TokenPosition result = TokenPosition(value);
+    max_position_ = Utils::Maximum(max_position_, result);
+    if (min_position_.IsNoSource()) {
+      min_position_ = result;
+    } else if (result.IsReal()) {
+      min_position_ = Utils::Minimum(min_position_, result);
+    }
+
+    return result;
   }
 
   intptr_t ReadListLength() { return ReadUInt(); }
 
   uint8_t ReadByte() { return buffer_[offset_++]; }
 
   bool ReadBool() { return (ReadByte() & 1) == 1; }
 
   word ReadFlags() { return ReadByte(); }
 
@@ skipping 23 matching lines @@
           "Reading Kernel file: Expected to be at EOF "
           "(offset: %" Pd64 ", size: %" Pd64 ")",
           offset_, size_);
     }
   }
 
   void DumpOffset(const char* str) {
     OS::PrintErr("@%" Pd64 " %s\n", offset_, str);
   }
 
+  // The largest position read yet (since last reset).
+  // This is automatically updated when calling ReadPosition,
+  // but can be overwritten (e.g. via the PositionScope class).
+  TokenPosition max_position() { return max_position_; }
+  // The smallest position read yet (since last reset).
+  // This is automatically updated when calling ReadPosition,
+  // but can be overwritten (e.g. via the PositionScope class).
+  TokenPosition min_position() { return min_position_; }
+  // The current script id for what we are currently processing.
+  // Note though that this is only a convenience helper and has to be set
+  // manually.
+  intptr_t current_script_id() { return current_script_id_; }
+  void set_current_script_id(intptr_t script_id) {
+    current_script_id_ = script_id;
+  }
+
   template <typename T, typename RT>
   T* ReadOptional() {
     Tag tag = ReadTag();
     if (tag == kNothing) {
       return NULL;
     }
     ASSERT(tag == kSomething);
     return RT::ReadFrom(this);
   }
 
   template <typename T>
   T* ReadOptional() {
     return ReadOptional<T, T>();
   }
 
   ReaderHelper* helper() { return &builder_; }
 
  private:
   const uint8_t* buffer_;
   int64_t size_;
   int64_t offset_;
   ReaderHelper builder_;
+  TokenPosition max_position_;
+  TokenPosition min_position_;
+  intptr_t current_script_id_;
+
+  friend class PositionScope;
 };
 
 
 class WriterHelper {
  public:
   WriterHelper() : labels_(NULL) {}
 
   void SetProgram(Program* program) {
     program_ = program;
     for (int i = 0; i < program->libraries().length(); i++) {
@@ skipping 159 matching lines @@
 
   WriterHelper* helper() { return &helper_; }
 
  private:
   ByteWriter* out_;
   WriterHelper helper_;
   int64_t offset_;
 };
 
 
+// A helper class that resets the readers min and max positions both upon
+// initialization and upon destruction, i.e. when created the min an max
+// positions will be reset to "noSource", when destructing the min and max will
+// be reset to have they value they would have had, if they hadn't been reset in
+// the first place.
+class PositionScope {
+ public:
+  explicit PositionScope(Reader* reader)
+      : reader_(reader),
+        min_(reader->min_position_),
+        max_(reader->max_position_) {
+    reader->min_position_ = reader->max_position_ = TokenPosition::kNoSource;
+  }
+
+  ~PositionScope() {
+    if (reader_->min_position_.IsNoSource()) {
+      reader_->min_position_ = min_;
+    } else if (min_.IsReal()) {
+      reader_->min_position_ = Utils::Minimum(reader_->min_position_, min_);
+    }
+    reader_->max_position_ = Utils::Maximum(reader_->max_position_, max_);
+  }
+
+ private:
+  Reader* reader_;
+  TokenPosition min_;
+  TokenPosition max_;
+};
+
 template <typename T>
 template <typename IT>
 void List<T>::ReadFrom(Reader* reader, TreeNode* parent) {
   TRACE_READ_OFFSET();
   ASSERT(parent != NULL);
   int length = reader->ReadListLength();
   EnsureInitialized(length);
 
   for (int i = 0; i < length_; i++) {
     IT* object = GetOrCreate<IT>(i, parent);
@@ skipping 231 matching lines @@
 }
 
 
 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);
   source_uri_index_ = reader->ReadUInt();
+  reader->set_current_script_id(source_uri_index_);
 
   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);
@@ skipping 30 matching lines @@
 }
 
 
 Class* Class::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
 
   position_ = reader->ReadPosition();
   is_abstract_ = reader->ReadBool();
   name_ = Reference::ReadStringFrom(reader);
   source_uri_index_ = reader->ReadUInt();
+  reader->set_current_script_id(source_uri_index_);
   annotations_.ReadFromStatic<Expression>(reader);
 
   return this;
 }
 
 
 void Class::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WritePosition(position_);
   writer->WriteBool(is_abstract_);
@@ skipping 230 matching lines @@
 Field* Field::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   ASSERT(tag == kField);
 
   position_ = reader->ReadPosition();
   end_position_ = reader->ReadPosition();
   flags_ = reader->ReadFlags();
   name_ = Name::ReadFrom(reader);
   source_uri_index_ = reader->ReadUInt();
+  reader->set_current_script_id(source_uri_index_);
   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();
@@ skipping 47 matching lines @@
   Tag tag = reader->ReadTag();
   ASSERT(tag == kProcedure);
 
   VariableScope<ReaderHelper> parameters(reader->helper());
   position_ = reader->ReadPosition();
   end_position_ = reader->ReadPosition();
   kind_ = static_cast<ProcedureKind>(reader->ReadByte());
   flags_ = reader->ReadFlags();
   name_ = Name::ReadFrom(reader);
   source_uri_index_ = reader->ReadUInt();
+  reader->set_current_script_id(source_uri_index_);
   annotations_.ReadFromStatic<Expression>(reader);
   function_ = reader->ReadOptional<FunctionNode>();
   return this;
 }
 
 
 void Procedure::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kProcedure);
 
@@ skipping 878 matching lines @@
   TRACE_WRITE_OFFSET();
   VariableScope<WriterHelper> parameters(writer->helper());
   writer->WriteTag(kFunctionExpression);
   function_->WriteTo(writer);
 }
 
 
 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->body_ = Expression::ReadFrom(reader);
+  let->position_ = reader->min_position();
+  let->end_position_ = reader->max_position();
+
   return let;
 }
 
 
 void Let::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   VariableScope<WriterHelper> vars(writer->helper());
   writer->WriteTag(kLet);
   variable_->WriteToImpl(writer);
   body_->WriteTo(writer);
@@ skipping 73 matching lines @@
 
 void ExpressionStatement::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kExpressionStatement);
   expression_->WriteTo(writer);
 }
 
 
 Block* Block::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
+  PositionScope scope(reader);
+
   VariableScope<ReaderHelper> vars(reader->helper());
   Block* block = new Block();
   block->statements().ReadFromStatic<Statement>(reader);
+  block->position_ = reader->min_position();
+  block->end_position_ = reader->max_position();
+
   return block;
 }
 
 
 void Block::WriteTo(Writer* writer) {
   writer->WriteTag(kBlock);
   WriteToImpl(writer);
 }
 
 
@@ skipping 97 matching lines @@
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kDoStatement);
   body_->WriteTo(writer);
   condition_->WriteTo(writer);
 }
 
 
 ForStatement* ForStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   VariableScope<ReaderHelper> vars(reader->helper());
+  PositionScope scope(reader);
+
   ForStatement* forstmt = new ForStatement();
   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;
 }
 
 
 void ForStatement::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kForStatement);
   VariableScope<WriterHelper> vars(writer->helper());
   variables_.WriteToStatic<VariableDeclarationImpl>(writer);
   writer->WriteOptional<Expression>(condition_);
   updates_.WriteTo(writer);
   body_->WriteTo(writer);
 }
 
 
 ForInStatement* ForInStatement::ReadFrom(Reader* reader, bool is_async) {
   TRACE_READ_OFFSET();
   VariableScope<ReaderHelper> vars(reader->helper());
+  PositionScope scope(reader);
+
   ForInStatement* forinstmt = new ForInStatement();
   forinstmt->is_async_ = is_async;
   forinstmt->variable_ = VariableDeclaration::ReadFromImpl(reader);
   forinstmt->iterable_ = Expression::ReadFrom(reader);
   forinstmt->body_ = Statement::ReadFrom(reader);
+  forinstmt->end_position_ = reader->max_position();
+  forinstmt->position_ = reader->min_position();
+
   return forinstmt;
 }
 
 
 void ForInStatement::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(is_async_ ? kAsyncForInStatement : kForInStatement);
   VariableScope<WriterHelper> vars(writer->helper());
   variable_->WriteToImpl(writer);
   iterable_->WriteTo(writer);
@@ skipping 97 matching lines @@
 void ReturnStatement::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kReturnStatement);
   writer->WritePosition(position_);
   writer->WriteOptional<Expression>(expression_);
 }
 
 
 TryCatch* TryCatch::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
+  PositionScope scope(reader);
+
   TryCatch* tc = new TryCatch();
   tc->body_ = Statement::ReadFrom(reader);
   tc->catches_.ReadFromStatic<Catch>(reader);
+  tc->position_ = reader->min_position();
+
   return tc;
 }
 
 
 void TryCatch::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kTryCatch);
   body_->WriteTo(writer);
   catches_.WriteTo(writer);
 }
 
 
 Catch* Catch::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   VariableScope<ReaderHelper> vars(reader->helper());
+  PositionScope scope(reader);
+
   Catch* c = new Catch();
   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;
 }
 
 
 void Catch::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   VariableScope<WriterHelper> vars(writer->helper());
   guard_->WriteTo(writer);
   writer->WriteOptionalStatic<VariableDeclaration, VariableDeclarationImpl>(
       exception_);
@@ skipping 42 matching lines @@
 VariableDeclaration* VariableDeclaration::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   ASSERT(tag == kVariableDeclaration);
   return VariableDeclaration::ReadFromImpl(reader);
 }
 
 
 VariableDeclaration* VariableDeclaration::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
+  PositionScope scope(reader);
+
   VariableDeclaration* decl = new VariableDeclaration();
   decl->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;
 }
 
 
 void VariableDeclaration::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kVariableDeclaration);
   WriteToImpl(writer);
 }
 
@@ skipping 348 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)