More offsets in 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 470 matching lines @@
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void AcceptClassVisitor(ClassVisitor* visitor) = 0;
   virtual void AcceptReferenceVisitor(ClassReferenceVisitor* visitor) = 0;
 
   Library* parent() { return parent_; }
   String* name() { return name_; }
   intptr_t source_uri_index() { return source_uri_index_; }
   bool is_abstract() { return is_abstract_; }
   List<Expression>& annotations() { return annotations_; }
+  TokenPosition position() { return position_; }
 
   virtual List<TypeParameter>& type_parameters() = 0;
   virtual List<InterfaceType>& implemented_classes() = 0;
   virtual List<Field>& fields() = 0;
   virtual List<Constructor>& constructors() = 0;
   virtual List<Procedure>& procedures() = 0;
 
  protected:
-  Class() : is_abstract_(false) {}
+  Class() : is_abstract_(false), position_(TokenPosition::kNoSource) {}
 
  private:
   template <typename T>
   friend class List;
 
   Ref<Library> parent_;
   Ref<String> name_;
   intptr_t source_uri_index_;
   bool is_abstract_;
   List<Expression> annotations_;
+  TokenPosition position_;
 
   DISALLOW_COPY_AND_ASSIGN(Class);
 };
 
 
 class NormalClass : public Class {
  public:
   NormalClass* ReadFrom(Reader* reader);
   void WriteTo(Writer* writer);
 
@@ skipping 80 matching lines @@
 
   DEFINE_CASTING_OPERATIONS(Member);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void AcceptMemberVisitor(MemberVisitor* visitor) = 0;
   virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor) = 0;
 
   TreeNode* parent() { return parent_; }
   Name* name() { return name_; }
   List<Expression>& annotations() { return annotations_; }
+  TokenPosition position() { return position_; }
+  TokenPosition end_position() { return end_position_; }
 
  protected:
-  Member() {}
+  Member()
+      : position_(TokenPosition::kNoSource),
+        end_position_(TokenPosition::kNoSource) {}
 
   template <typename T>
   friend class List;
 
   Ref<TreeNode> parent_;
   Child<Name> name_;
   List<Expression> annotations_;
+  TokenPosition position_;
+  TokenPosition end_position_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Member);
 };
 
 
 class Field : public Member {
  public:
   enum Flags {
     kFlagFinal = 1 << 0,
@@ skipping 13 matching lines @@
   virtual void VisitChildren(Visitor* visitor);
 
   bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; }
   bool IsFinal() { return (flags_ & kFlagFinal) == kFlagFinal; }
   bool IsStatic() { return (flags_ & kFlagStatic) == kFlagStatic; }
   intptr_t source_uri_index() { return source_uri_index_; }
 
   DartType* type() { return type_; }
   InferredValue* inferred_value() { return inferred_value_; }
   Expression* initializer() { return initializer_; }
-  TokenPosition position() { return position_; }
 
  private:
-  Field() : position_(TokenPosition::kNoSource) {}
+  Field() {}
 
   template <typename T>
   friend class List;
 
   word flags_;
   intptr_t source_uri_index_;
   Child<DartType> type_;
   Child<InferredValue> inferred_value_;
   Child<Expression> initializer_;
-  TokenPosition position_;
 
   DISALLOW_COPY_AND_ASSIGN(Field);
 };
 
 
 class Constructor : public Member {
  public:
   enum Flags {
     kFlagConst = 1 << 0,
     kFlagExternal = 1 << 1,
@@ skipping 235 matching lines @@
   void WriteTo(Writer* writer);
 
   virtual ~FunctionNode();
 
   DEFINE_CASTING_OPERATIONS(FunctionNode);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   AsyncMarker async_marker() { return async_marker_; }
+  bool debuggable() { return debuggable_; }
   TypeParameterList& type_parameters() { return type_parameters_; }
   int required_parameter_count() { return required_parameter_count_; }
   List<VariableDeclaration>& positional_parameters() {
     return positional_parameters_;
   }
   List<VariableDeclaration>& named_parameters() { return named_parameters_; }
   DartType* return_type() { return return_type_; }
   InferredValue* inferred_return_value() { return inferred_return_value_; }
   Statement* body() { return body_; }
+  TokenPosition position() { return position_; }
+  TokenPosition end_position() { return end_position_; }
 
  private:
-  FunctionNode() {}
+  FunctionNode()
+      : position_(TokenPosition::kNoSource),
+        end_position_(TokenPosition::kNoSource) {}
 
   AsyncMarker async_marker_;
+  bool debuggable_;
   TypeParameterList type_parameters_;
   int required_parameter_count_;
   List<VariableDeclaration> positional_parameters_;
   List<VariableDeclaration> named_parameters_;
   Child<DartType> return_type_;
   Child<InferredValue> inferred_return_value_;
   Child<Statement> body_;
+  TokenPosition position_;
+  TokenPosition end_position_;
 
   DISALLOW_COPY_AND_ASSIGN(FunctionNode);
 };
 
 
 class Expression : public TreeNode {
  public:
   static Expression* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer) = 0;
 
@@ skipping 933 matching lines @@
 
   virtual ~Let();
 
   DEFINE_CASTING_OPERATIONS(Let);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   VariableDeclaration* variable() { return variable_; }
   Expression* body() { return body_; }
+  TokenPosition position() { return position_; }
+  TokenPosition end_position() { return end_position_; }
 
  private:
-  Let() {}
+  Let()
+      : position_(TokenPosition::kNoSource),
+        end_position_(TokenPosition::kNoSource) {}
 
   Child<VariableDeclaration> variable_;
   Child<Expression> body_;
+  TokenPosition position_;
+  TokenPosition end_position_;
 
   DISALLOW_COPY_AND_ASSIGN(Let);
 };
 
 
 class Statement : public TreeNode {
  public:
   static Statement* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer) = 0;
 
   virtual ~Statement();
 
   DEFINE_CASTING_OPERATIONS(Statement);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void AcceptStatementVisitor(StatementVisitor* visitor) = 0;
+  TokenPosition position() { return position_; }
 
  protected:
-  Statement() {}
+  Statement() : position_(TokenPosition::kNoSource) {}
+  TokenPosition position_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Statement);
 };
 
 
 class InvalidStatement : public Statement {
  public:
   static InvalidStatement* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer);
@@ skipping 1307 matching lines @@
 };
 
 
 void WritePrecompiledKernel(ByteWriter* out, kernel::Program* program);
 
 
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_H_