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

runtime/vm/kernel_to_il.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_TO_IL_H_
 #define RUNTIME_VM_KERNEL_TO_IL_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/growable_array.h"
@@ skipping 63 matching lines @@
     } else {
       return pair->value;
     }
   }
 
   inline Pair* LookupPair(const Key& key) {
     return DirectChainedHashMap<RawPointerKeyValueTrait<K, V> >::Lookup(key);
   }
 };
 
+
+template <typename V>
+class IntKeyRawPointerValueTrait {
+ public:
+  typedef int64_t Key;
+  typedef V Value;
+
+  struct Pair {
+    Key key;
+    Value value;
+    Pair() : key(NULL), value() {}
+    Pair(const Key key, const Value& value) : key(key), value(value) {}
+    Pair(const Pair& other) : key(other.key), value(other.value) {}
+  };
+
+  static Key KeyOf(Pair kv) { return kv.key; }
+  static Value ValueOf(Pair kv) { return kv.value; }
+  static intptr_t Hashcode(Key key) { return reinterpret_cast<intptr_t>(key); }
+  static bool IsKeyEqual(Pair kv, Key key) { return kv.key == key; }
+};
+
+template <typename V>
+class IntMap : public DirectChainedHashMap<IntKeyRawPointerValueTrait<V> > {
+ public:
+  typedef typename IntKeyRawPointerValueTrait<V>::Key Key;
+  typedef typename IntKeyRawPointerValueTrait<V>::Value Value;
+  typedef typename IntKeyRawPointerValueTrait<V>::Pair Pair;
+
+  inline void Insert(const Key& key, const Value& value) {
+    Pair pair(key, value);
+    DirectChainedHashMap<IntKeyRawPointerValueTrait<V> >::Insert(pair);
+  }
+
+  inline V Lookup(const Key& key) {
+    Pair* pair =
+        DirectChainedHashMap<IntKeyRawPointerValueTrait<V> >::Lookup(key);
+    if (pair == NULL) {
+      return V();
+    } else {
+      return pair->value;
+    }
+  }
+
+  inline Pair* LookupPair(const Key& key) {
+    return DirectChainedHashMap<IntKeyRawPointerValueTrait<V> >::Lookup(key);
+  }
+};
+
 template <typename K, typename V>
 class MallocMap
     : public MallocDirectChainedHashMap<RawPointerKeyValueTrait<K, V> > {
  public:
   typedef typename RawPointerKeyValueTrait<K, V>::Key Key;
   typedef typename RawPointerKeyValueTrait<K, V>::Value Value;
   typedef typename RawPointerKeyValueTrait<K, V>::Pair Pair;
 
   inline void Insert(const Key& key, const Value& value) {
     Pair pair(key, value);
@@ skipping 401 matching lines @@
   Zone* zone_;
   TranslationHelper& translation_helper_;
   DartTypeTranslator& type_translator_;
 
   Script& script_;
   Instance& result_;
 };
 
 
 struct FunctionScope {
-  FunctionNode* function;
+  int64_t kernelFileOffset;

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

This should be named kernel_file_offset to fit the coding style, but I think it
would be better as kernel_offset.

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

Done.

   LocalScope* scope;
 };
 
 
 class ScopeBuildingResult : public ZoneAllocated {
  public:
   ScopeBuildingResult()
       : this_variable(NULL),
         type_arguments_variable(NULL),
         switch_variable(NULL),
         finally_return_variable(NULL),
         setter_value(NULL),
         yield_jump_variable(NULL),
         yield_context_variable(NULL) {}
 
-  Map<VariableDeclaration, LocalVariable*> locals;
-  Map<TreeNode, LocalScope*> scopes;
+  IntMap<LocalVariable*> locals;
+  IntMap<LocalScope*> scopes;
   GrowableArray<FunctionScope> function_scopes;
 
   // Only non-NULL for instance functions.
   LocalVariable* this_variable;
 
   // Only non-NULL for factory constructor functions.
   LocalVariable* type_arguments_variable;
 
   // Non-NULL when the function contains a switch statement.
   LocalVariable* switch_variable;
@@ skipping 66 matching lines @@
   virtual void VisitTryCatch(TryCatch* node);
   virtual void VisitTryFinally(TryFinally* node);
   virtual void VisitYieldStatement(YieldStatement* node);
   virtual void VisitAssertStatement(AssertStatement* node);
 
   virtual void VisitFunctionNode(FunctionNode* node);
 
   virtual void VisitConstructor(Constructor* node);
 
  private:
-  void EnterScope(TreeNode* node, TokenPosition start_position);
+  template <typename NewScopeType>
+  void EnterScope(NewScopeType* node, TokenPosition start_position);
   void ExitScope(TokenPosition end_position);
 
   const Type& TranslateVariableType(VariableDeclaration* variable);
   LocalVariable* MakeVariable(TokenPosition declaration_pos,
                               TokenPosition token_pos,
                               const dart::String& name,
                               const AbstractType& type);
 
   void AddParameters(FunctionNode* function, intptr_t pos = 0);
   void AddParameter(VariableDeclaration* declaration, intptr_t pos);
   void AddVariable(VariableDeclaration* declaration);
   void AddExceptionVariable(GrowableArray<LocalVariable*>* variables,
                             const char* prefix,
                             intptr_t nesting_depth);
   void AddTryVariables();
   void AddCatchVariables();
   void AddIteratorVariable();
   void AddSwitchVariable();
 
   // Record an assignment or reference to a variable.  If the occurrence is
   // in a nested function, ensure that the variable is handled properly as a
   // captured variable.
   void LookupVariable(VariableDeclaration* declaration);
 
   const dart::String& GenerateName(const char* prefix, intptr_t suffix);
 
-  void HandleLocalFunction(TreeNode* parent, FunctionNode* function);
+  template <typename FunctionType>
+  void HandleLocalFunction(FunctionType* parent, FunctionNode* function);
   void HandleSpecialLoad(LocalVariable** variable, const dart::String& symbol);
   void LookupCapturedVariableByName(LocalVariable** variable,
                                     const dart::String& name);
 
   struct DepthState {
     explicit DepthState(intptr_t function)
         : loop_(0),
           function_(function),
           try_(0),
           catch_(0),
@@ skipping 127 matching lines @@
 
   Fragment TranslateStatement(Statement* statement);
   Fragment TranslateCondition(Expression* expression, bool* negate);
   Fragment TranslateExpression(Expression* expression);
 
   Fragment TranslateFinallyFinalizers(TryFinallyBlock* outer_finally,
                                       intptr_t target_context_depth);
 
   Fragment TranslateFunctionNode(FunctionNode* node, TreeNode* parent);
 
-  Fragment EnterScope(TreeNode* node, bool* new_context = NULL);
-  Fragment ExitScope(TreeNode* node);
+  Fragment EnterScope(int64_t kernel_offset, bool* new_context = NULL);
+  Fragment ExitScope(int64_t kernel_offset);
 
   Fragment LoadContextAt(int depth);
   Fragment AdjustContextTo(int depth);
 
   Fragment PushContext(int size);
   Fragment PopContext();
 
   Fragment LoadInstantiatorTypeArguments();
   Fragment InstantiateType(const AbstractType& type);
   Fragment InstantiateTypeArguments(const TypeArguments& type_arguments);
@@ skipping 233 matching lines @@
 namespace kernel {
 
 RawObject* EvaluateMetadata(TreeNode* const kernel_node);
 RawObject* BuildParameterDescriptor(TreeNode* const kernel_node);
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_TO_IL_H_