[kernel] Don't use kernel ast nodes as keys

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 685 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_; }
+  int64_t kernel_file_offset() { return kernelFileOffset_; }
 
  private:
-  Field() {}
+  Field() : kernelFileOffset_(-1) {}
 
   template <typename T>
   friend class List;
 
   word flags_;
   intptr_t source_uri_index_;
   Child<DartType> type_;
   Child<InferredValue> inferred_value_;
   Child<Expression> initializer_;
+  int64_t kernelFileOffset_;

[Kevin Millikin (Google), 2017/03/28 06:42:22]

I wonder why this is int64_t.

Call the field kernel_file_offset_;

(Though I think 'file' is a noise word here anyway.  It's not necessarily a file
at all except in the sense that an array of bytes is a file.)

Please document it.  Specifically, I want to know that it is the offset of just
after the tag.

[jensj, 2017/03/28 08:56:28]

Done.

 
   DISALLOW_COPY_AND_ASSIGN(Field);
 };
 
 
 class Constructor : public Member {
  public:
   enum Flags {
     kFlagConst = 1 << 0,
     kFlagExternal = 1 << 1,
@@ skipping 238 matching lines @@
   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_; }
+  int64_t kernel_file_offset() { return kernelFileOffset_; }
 
  private:
-  FunctionNode()
+  explicit FunctionNode(int64_t kernelFileOffset)
       : position_(TokenPosition::kNoSource),
-        end_position_(TokenPosition::kNoSource) {}
+        end_position_(TokenPosition::kNoSource),
+        kernelFileOffset_(kernelFileOffset) {}
 
   AsyncMarker async_marker_;
   AsyncMarker dart_async_marker_;
   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_;
+  int64_t kernelFileOffset_;
 
   DISALLOW_COPY_AND_ASSIGN(FunctionNode);
 };
 
 
 class Expression : public TreeNode {
  public:
   static Expression* ReadFrom(Reader* reader);
 
   virtual ~Expression();
@@ skipping 872 matching lines @@
   static FunctionExpression* ReadFrom(Reader* reader);
 
   virtual ~FunctionExpression();
 
   DEFINE_CASTING_OPERATIONS(FunctionExpression);
 
   virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   FunctionNode* function() { return function_; }
+  int64_t kernel_file_offset() { return kernelFileOffset_; }
 
  private:
-  FunctionExpression() {}
+  explicit FunctionExpression(int64_t kernelFileOffset)
+      : kernelFileOffset_(kernelFileOffset) {}
 
   Child<FunctionNode> function_;
+  int64_t kernelFileOffset_;
 
   DISALLOW_COPY_AND_ASSIGN(FunctionExpression);
 };
 
 
 class Let : public Expression {
  public:
   static Let* ReadFrom(Reader* reader);
 
   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_; }
+  int64_t kernel_file_offset() { return kernelFileOffset_; }
 
  private:
-  Let()
+  explicit Let(int64_t kernelFileOffset)
       : position_(TokenPosition::kNoSource),
-        end_position_(TokenPosition::kNoSource) {}
+        end_position_(TokenPosition::kNoSource),
+        kernelFileOffset_(kernelFileOffset) {}
 
   Child<VariableDeclaration> variable_;
   Child<Expression> body_;
   TokenPosition position_;
   TokenPosition end_position_;
+  int64_t kernelFileOffset_;
 
   DISALLOW_COPY_AND_ASSIGN(Let);
 };
 
 
 class Statement : public TreeNode {
  public:
   static Statement* ReadFrom(Reader* reader);
 
   virtual ~Statement();
@@ skipping 60 matching lines @@
 
   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_; }
+  int64_t kernel_file_offset() { return kernelFileOffset_; }
 
  private:
-  Block() : end_position_(TokenPosition::kNoSource) {}
+  explicit Block(int64_t kernelFileOffset)
+      : end_position_(TokenPosition::kNoSource),
+        kernelFileOffset_(kernelFileOffset) {}
 
   List<Statement> statements_;
   TokenPosition end_position_;
+  int64_t kernelFileOffset_;
 
   DISALLOW_COPY_AND_ASSIGN(Block);
 };
 
 
 class EmptyStatement : public Statement {
  public:
   static EmptyStatement* ReadFrom(Reader* reader);
 
   virtual ~EmptyStatement();
@@ skipping 136 matching lines @@
 
   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_; }
+  int64_t kernel_file_offset() { return kernelFileOffset_; }
 
  private:
-  ForStatement()
+  explicit ForStatement(int64_t kernelFileOffset)
       : position_(TokenPosition::kNoSource),
-        end_position_(TokenPosition::kNoSource) {}
+        end_position_(TokenPosition::kNoSource),
+        kernelFileOffset_(kernelFileOffset) {}
 
   List<VariableDeclaration> variables_;
   Child<Expression> condition_;
   List<Expression> updates_;
   Child<Statement> body_;
   TokenPosition position_;
   TokenPosition end_position_;
+  int64_t kernelFileOffset_;
 
   DISALLOW_COPY_AND_ASSIGN(ForStatement);
 };
 
 
 class ForInStatement : public Statement {
  public:
   static ForInStatement* ReadFrom(Reader* reader, bool is_async);
 
   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_; }
+  int64_t kernel_file_offset() { return kernelFileOffset_; }
 
  private:
-  ForInStatement()
+  explicit ForInStatement(int64_t kernelFileOffset)
       : position_(TokenPosition::kNoSource),
-        end_position_(TokenPosition::kNoSource) {}
+        end_position_(TokenPosition::kNoSource),
+        kernelFileOffset_(kernelFileOffset) {}
 
   Child<VariableDeclaration> variable_;
   Child<Expression> iterable_;
   Child<Statement> body_;
   bool is_async_;
   TokenPosition position_;
   TokenPosition end_position_;
+  int64_t kernelFileOffset_;
 
   DISALLOW_COPY_AND_ASSIGN(ForInStatement);
 };
 
 
 class SwitchStatement : public Statement {
  public:
   static SwitchStatement* ReadFrom(Reader* reader);
 
   virtual ~SwitchStatement();
@@ skipping 149 matching lines @@
 
   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_; }
+  int64_t kernel_file_offset() { return kernelFileOffset_; }
 
  private:
-  Catch()
+  explicit Catch(int64_t kernelFileOffset)
       : position_(TokenPosition::kNoSource),
-        end_position_(TokenPosition::kNoSource) {}
+        end_position_(TokenPosition::kNoSource),
+        kernelFileOffset_(kernelFileOffset) {}
 
   template <typename T>
   friend class List;
 
   Child<DartType> guard_;
   Child<VariableDeclaration> exception_;
   Child<VariableDeclaration> stack_trace_;
   Child<Statement> body_;
   TokenPosition position_;
   TokenPosition end_position_;
+  int64_t kernelFileOffset_;
 
   DISALLOW_COPY_AND_ASSIGN(Catch);
 };
 
 
 class TryFinally : public Statement {
  public:
   static TryFinally* ReadFrom(Reader* reader);
 
   virtual ~TryFinally();
@@ skipping 65 matching lines @@
   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 equals_position() { return equals_position_; }
   TokenPosition end_position() { return end_position_; }
   void set_end_position(TokenPosition position) { end_position_ = position; }
+  int64_t kernel_file_offset() { return kernelFileOffset_; }
 
  private:
-  VariableDeclaration()
+  explicit VariableDeclaration(int64_t kernelFileOffset)
       : equals_position_(TokenPosition::kNoSourcePos),
-        end_position_(TokenPosition::kNoSource) {}
+        end_position_(TokenPosition::kNoSource),
+        kernelFileOffset_(kernelFileOffset) {}
 
   template <typename T>
   friend class List;
 
   word flags_;
   Ref<String> name_;
   Child<DartType> type_;
   Child<InferredValue> inferred_value_;
   Child<Expression> initializer_;
   TokenPosition equals_position_;
   TokenPosition end_position_;
+  int64_t kernelFileOffset_;
 
   DISALLOW_COPY_AND_ASSIGN(VariableDeclaration);
 };
 
 
 class FunctionDeclaration : public Statement {
  public:
   static FunctionDeclaration* ReadFrom(Reader* reader);
 
   virtual ~FunctionDeclaration();
 
   DEFINE_CASTING_OPERATIONS(FunctionDeclaration);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   VariableDeclaration* variable() { return variable_; }
   FunctionNode* function() { return function_; }
+  int64_t kernel_file_offset() { return kernelFileOffset_; }
 
  private:
-  FunctionDeclaration() {}
+  explicit FunctionDeclaration(int64_t kernelFileOffset)
+      : kernelFileOffset_(kernelFileOffset) {}
 
   Child<VariableDeclaration> variable_;
   Child<FunctionNode> function_;
+  int64_t kernelFileOffset_;
 
   DISALLOW_COPY_AND_ASSIGN(FunctionDeclaration);
 };
 
 
 class Name : public Node {
  public:
   static Name* ReadFrom(Reader* reader);
 
   virtual ~Name();
@@ skipping 716 matching lines @@
 
 kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer,
                                                  intptr_t buffer_length);
 
 
 
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_H_