Merge of source position information from kernel-sdk.

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"
 #include "vm/globals.h"
+#include "vm/token_position.h"
 
 
 #define KERNEL_NODES_DO(M)                                                     \
   M(Name)                                                                      \
   M(InferredValue)                                                             \
   M(DartType)                                                                  \
   M(InvalidType)                                                               \
   M(DynamicType)                                                               \
   M(VoidType)                                                                  \
   M(InterfaceType)                                                             \
@@ skipping 279 matching lines @@
   friend class Program;
 
   List<String> strings_;
 
   DISALLOW_COPY_AND_ASSIGN(StringTable);
 };
 
 
 class LineStartingTable {
  public:
-  void ReadFrom(Reader* reader, intptr_t length);
+  void ReadFrom(Reader* reader);
   void WriteTo(Writer* writer);
   ~LineStartingTable() {
     for (intptr_t i = 0; i < size_; ++i) {
       delete[] values_[i];
     }
     delete[] values_;
   }
 
   intptr_t size() { return size_; }
   intptr_t* valuesFor(int i) { return values_[i]; }
@@ skipping 84 matching lines @@
   void WriteTo(Writer* writer);
 
   virtual ~Library();
 
   DEFINE_CASTING_OPERATIONS(Library);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   String* import_uri() { return import_uri_; }
+  intptr_t source_uri_index() { return source_uri_index_; }
   String* name() { return name_; }
   List<Class>& classes() { return classes_; }
   List<Field>& fields() { return fields_; }
   List<Procedure>& procedures() { return procedures_; }
 
   bool IsCorelibrary() {
     static const char* dart_library = "dart:";
     static intptr_t dart_library_length = strlen(dart_library);
     static const char* patch_library = "dart:_patch";
     static intptr_t patch_library_length = strlen(patch_library);
@@ skipping 15 matching lines @@
   }
 
  private:
   Library() : name_(NULL) {}
 
   template <typename T>
   friend class List;
 
   Ref<String> name_;
   Ref<String> import_uri_;
+  intptr_t source_uri_index_;
   List<Class> classes_;
   List<Field> fields_;
   List<Procedure> procedures_;
 
   DISALLOW_COPY_AND_ASSIGN(Library);
 };
 
 
 class Class : public TreeNode {
  public:
   Class* ReadFrom(Reader* reader);
   void WriteTo(Writer* writer);
 
   virtual ~Class();
 
   DEFINE_CASTING_OPERATIONS(Class);
 
   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_; }
 
   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) {}
 
  private:
   template <typename T>
   friend class List;
 
   Ref<Library> parent_;
   Ref<String> name_;
+  intptr_t source_uri_index_;
   bool is_abstract_;
   List<Expression> annotations_;
 
   DISALLOW_COPY_AND_ASSIGN(Class);
 };
 
 
 class NormalClass : public Class {
  public:
   NormalClass* ReadFrom(Reader* reader);
@@ skipping 120 matching lines @@
 
   DEFINE_CASTING_OPERATIONS(Field);
 
   virtual void AcceptMemberVisitor(MemberVisitor* visitor);
   virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor);
   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() {}
+  Field() : position_(TokenPosition::kNoSource) {}
 
   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 61 matching lines @@
   virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   ProcedureKind kind() { return kind_; }
   FunctionNode* function() { return function_; }
 
   bool IsStatic() { return (flags_ & kFlagStatic) == kFlagStatic; }
   bool IsAbstract() { return (flags_ & kFlagAbstract) == kFlagAbstract; }
   bool IsExternal() { return (flags_ & kFlagExternal) == kFlagExternal; }
   bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; }
+  intptr_t source_uri_index() { return source_uri_index_; }
 
  private:
   Procedure() : kind_(kIncompleteProcedure), flags_(0), function_(NULL) {}
 
   template <typename T>
   friend class List;
 
   ProcedureKind kind_;
   word flags_;
+  intptr_t source_uri_index_;
   Child<FunctionNode> function_;
 
   DISALLOW_COPY_AND_ASSIGN(Procedure);
 };
 
 
 class Initializer : public TreeNode {
  public:
   static Initializer* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer) = 0;
@@ skipping 180 matching lines @@
  public:
   static Expression* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer) = 0;
 
   virtual ~Expression();
 
   DEFINE_CASTING_OPERATIONS(Expression);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor) = 0;
+  TokenPosition position() { return position_; }
 
  protected:
-  Expression() {}
+  Expression() : position_(TokenPosition::kNoSource) {}
+  TokenPosition position_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Expression);
 };
 
 
 class InvalidExpression : public Expression {
  public:
   static InvalidExpression* ReadFrom(Reader* reader);
   virtual void WriteTo(Writer* writer);
@@ skipping 324 matching lines @@
   Child<Arguments> arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectMethodInvocation);
 };
 
 
 class StaticInvocation : public Expression {
  public:
   static StaticInvocation* ReadFrom(Reader* reader, bool is_const);
   virtual void WriteTo(Writer* writer);
-
-  explicit StaticInvocation(Procedure* procedure,
-                            Arguments* args,
-                            bool is_const)
-      : procedure_(procedure), arguments_(args), is_const_(is_const) {}
   ~StaticInvocation();
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   Procedure* procedure() { return procedure_; }
   Arguments* arguments() { return arguments_; }
   bool is_const() { return is_const_; }
 
  private:
@@ skipping 1479 matching lines @@
   void WriteTo(Writer* writer);
 
   virtual ~Program();
 
   DEFINE_CASTING_OPERATIONS(Program);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   StringTable& string_table() { return string_table_; }
+  StringTable& source_uri_table() { return source_uri_table_; }
+  LineStartingTable& line_starting_table() { return line_starting_table_; }
   List<Library>& libraries() { return libraries_; }
   Procedure* main_method() { return main_method_; }
 
  private:
   Program() {}
 
   List<Library> libraries_;
   Ref<Procedure> main_method_;
   StringTable string_table_;
+  StringTable source_uri_table_;
+  LineStartingTable line_starting_table_;
 
   DISALLOW_COPY_AND_ASSIGN(Program);
 };
 
 
 class Reference : public AllStatic {
  public:
   static Member* ReadMemberFrom(Reader* reader, bool allow_null = false);
   static void WriteMemberTo(Writer* writer,
                             Member* member,
@@ skipping 433 matching lines @@
 };
 
 
 void WritePrecompiledKernel(ByteWriter* out, kernel::Program* program);
 
 
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_H_