Add kernel_offset to all expressions; Make KernelConstMapKeyEqualsTraits use kernel_offset

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"
 #include "vm/hash_map.h"
 
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/intermediate_language.h"
 #include "vm/kernel.h"
 
 namespace dart {
 namespace kernel {
 
 class StreamingFlowGraphBuilder;
 
-// TODO(27590): Instead of using [dart::kernel::TreeNode]s as keys we
-// should use [TokenPosition]s.
 class KernelConstMapKeyEqualsTraits {
  public:
   static const char* Name() { return "KernelConstMapKeyEqualsTraits"; }
   static bool ReportStats() { return false; }
 
   static bool IsMatch(const Object& a, const Object& b) {
     const Smi& key1 = Smi::Cast(a);
     const Smi& key2 = Smi::Cast(b);
     return (key1.Value() == key2.Value());
   }
-  static bool IsMatch(const TreeNode* key1, const Object& b) {
+  static bool IsMatch(const intptr_t key1, const Object& b) {
     return KeyAsSmi(key1) == Smi::Cast(b).raw();
   }
   static uword Hash(const Object& obj) {
     const Smi& key = Smi::Cast(obj);
     return HashValue(key.Value());
   }
-  static uword Hash(const TreeNode* key) {
+  static uword Hash(const intptr_t key) {
     return HashValue(Smi::Value(KeyAsSmi(key)));
   }
-  static RawObject* NewKey(const TreeNode* key) { return KeyAsSmi(key); }
+  static RawObject* NewKey(const intptr_t key) { return KeyAsSmi(key); }
 
  private:
   static uword HashValue(intptr_t pos) { return pos % (Smi::kMaxValue - 13); }
 
-  static RawSmi* KeyAsSmi(const TreeNode* key) {
-    // We exploit that all [TreeNode] objects will be aligned and therefore are
-    // already [Smi]s!
-    return reinterpret_cast<RawSmi*>(const_cast<TreeNode*>(key));
+  static RawSmi* KeyAsSmi(const intptr_t key) {
+    ASSERT(key >= 0);
+    return Smi::New(key);
   }
 };
 typedef UnorderedHashMap<KernelConstMapKeyEqualsTraits> KernelConstantsMap;
 
 
 template <typename K, typename V>
 class Map : public DirectChainedHashMap<RawPointerKeyValueTrait<K, V> > {
  public:
   typedef typename RawPointerKeyValueTrait<K, V>::Key Key;
   typedef typename RawPointerKeyValueTrait<K, V>::Value Value;
@@ skipping 464 matching lines @@
       translation_helper_.ReportError("Expected boolean expression.");
     }
   }
 
   bool EvaluateBooleanExpression(Expression* expression) {
     EvaluateExpression(expression);
     AssertBoolInCheckedMode();
     return result_.raw() == Bool::True().raw();
   }
 
-  // TODO(27590): Instead of using [dart::kernel::TreeNode]s as keys we
-  // should use [TokenPosition]s as well as the existing functionality in
-  // `Parser::CacheConstantValue`.
   bool GetCachedConstant(TreeNode* node, Instance* value);
   void CacheConstantValue(TreeNode* node, const Instance& value);
 
   FlowGraphBuilder* builder_;
   Isolate* isolate_;
   Zone* zone_;
   TranslationHelper& translation_helper_;
   DartTypeTranslator& type_translator_;
 
   Script& script_;
@@ skipping 560 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_