TokenPositions on more nodes when running from Kernel

runtime/vm/kernel.h

 // 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.
 
 #ifndef RUNTIME_VM_KERNEL_H_
 #define RUNTIME_VM_KERNEL_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 #include "platform/assert.h"
 #include "vm/allocation.h"
@@ skipping 1985 matching lines @@
   void WriteToImpl(Writer* writer);
 
   virtual ~Block();
 
   DEFINE_CASTING_OPERATIONS(Block);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   List<Statement>& statements() { return statements_; }
+  TokenPosition end_position() { return end_position_; }
 
  private:
-  Block() {}
+  Block() : end_position_(TokenPosition::kNoSource) {}
 
   List<Statement> statements_;
+  TokenPosition end_position_;
 
   DISALLOW_COPY_AND_ASSIGN(Block);
 };
 
 
 class EmptyStatement : public Statement {
  public:
   static EmptyStatement* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer);
 
@@ skipping 141 matching lines @@
 
   DEFINE_CASTING_OPERATIONS(ForStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   List<VariableDeclaration>& variables() { return variables_; }
   Expression* condition() { return condition_; }
   List<Expression>& updates() { return updates_; }
   Statement* body() { return body_; }
+  TokenPosition position() { return position_; }
+  TokenPosition end_position() { return end_position_; }
 
  private:
-  ForStatement() {}
+  ForStatement()
+      : position_(TokenPosition::kNoSource),
+        end_position_(TokenPosition::kNoSource) {}
 
   List<VariableDeclaration> variables_;
   Child<Expression> condition_;
   List<Expression> updates_;
   Child<Statement> body_;
+  TokenPosition position_;
+  TokenPosition end_position_;
 
   DISALLOW_COPY_AND_ASSIGN(ForStatement);
 };
 
 
 class ForInStatement : public Statement {
  public:
   static ForInStatement* ReadFrom(Reader* reader, bool is_async);
   virtual void WriteTo(Writer* writer);
 
   virtual ~ForInStatement();
 
   DEFINE_CASTING_OPERATIONS(ForInStatement);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   VariableDeclaration* variable() { return variable_; }
   Expression* iterable() { return iterable_; }
   Statement* body() { return body_; }
   bool is_async() { return is_async_; }
+  TokenPosition position() { return position_; }
+  TokenPosition end_position() { return end_position_; }
 
  private:
-  ForInStatement() {}
+  ForInStatement()
+      : position_(TokenPosition::kNoSource),
+        end_position_(TokenPosition::kNoSource) {}
 
   Child<VariableDeclaration> variable_;
   Child<Expression> iterable_;
   Child<Statement> body_;
   bool is_async_;
+  TokenPosition position_;
+  TokenPosition end_position_;
 
   DISALLOW_COPY_AND_ASSIGN(ForInStatement);
 };
 
 
 class SwitchStatement : public Statement {
  public:
   static SwitchStatement* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer);
 
@@ skipping 154 matching lines @@
 
   DEFINE_CASTING_OPERATIONS(Catch);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   DartType* guard() { return guard_; }
   VariableDeclaration* exception() { return exception_; }
   VariableDeclaration* stack_trace() { return stack_trace_; }
   Statement* body() { return body_; }
+  TokenPosition position() { return position_; }
+  TokenPosition end_position() { return end_position_; }
 
  private:
-  Catch() {}
+  Catch()
+      : position_(TokenPosition::kNoSource),
+        end_position_(TokenPosition::kNoSource) {}
 
   template <typename T>
   friend class List;
 
   Child<DartType> guard_;
   Child<VariableDeclaration> exception_;
   Child<VariableDeclaration> stack_trace_;
   Child<Statement> body_;
+  TokenPosition position_;
+  TokenPosition end_position_;
 
   DISALLOW_COPY_AND_ASSIGN(Catch);
 };
 
 
 class TryFinally : public Statement {
  public:
   static TryFinally* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer);
 
@@ skipping 66 matching lines @@
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; }
   bool IsFinal() { return (flags_ & kFlagFinal) == kFlagFinal; }
 
   String* name() { return name_; }
   DartType* type() { return type_; }
   InferredValue* inferred_value() { return inferred_value_; }
   Expression* initializer() { return initializer_; }
+  TokenPosition end_position() { return end_position_; }
 
  private:
-  VariableDeclaration() {}
+  VariableDeclaration() : end_position_(TokenPosition::kNoSource) {}
 
   template <typename T>
   friend class List;
 
   word flags_;
   Ref<String> name_;
   Child<DartType> type_;
   Child<InferredValue> inferred_value_;
   Child<Expression> initializer_;
+  TokenPosition end_position_;
 
   DISALLOW_COPY_AND_ASSIGN(VariableDeclaration);
 };
 
 
 class FunctionDeclaration : public Statement {
  public:
   static FunctionDeclaration* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer);
 
@@ skipping 758 matching lines @@
 };
 
 
 void WritePrecompiledKernel(ByteWriter* out, kernel::Program* program);
 
 
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_H_