[ADT] Add a new data structure to enumerate values.

This data structure enumerates values and gives them unqiue indices.  This data
structure will be used by the AliasAnalysis Cache.

Author: nadavrot

include/swift/Basic/ValueEnumerator.h

@@ -0,0 +1,58 @@
+//===--- ValueEnumerator.h --- Enumerates values ----------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_BASIC_VALUEENUMERATOR_H
+#define SWIFT_BASIC_VALUEENUMERATOR_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace swift {
+
+/// / This class maps values to unique indices.
+template<class ValueTy, class IndexTy = size_t>
+class ValueEnumerator {
+  /// A running counter to enumerate values.
+  IndexTy counter;
+
+  /// Maps values to unique integers.
+  llvm::DenseMap<ValueTy, IndexTy> ValueToIndex;
+
+public:
+  /// Return the index of value \p v.
+  IndexTy getIndex(const ValueTy &v) {
+    // Return the index of this Key, if we've assigned one already.
+    auto It = ValueToIndex.find(v);
+    if (It != ValueToIndex.end()) {
+      return It->second;
+    }
+
+    // Generate a new counter for the key.
+    ValueToIndex[v] = ++counter;
+    return counter;
+  }
+
+  ValueEnumerator() = default;
+
+  /// Forget about key \p v.
+  void invalidateValue(const ValueTy &v) { ValueToIndex.erase(v); }
+
+  /// Clear the enumeration state of the
+  void clear() {
+    ValueToIndex.clear();
+    counter = 0;
+  }
+};
+
+} // end namespace swift
+
+#endif

unittests/Basic/ADTTests.cpp

@@ -1,4 +1,5 @@
 #include "swift/Basic/OptionSet.h"
+#include "swift/Basic/ValueEnumerator.h"
 #include "gtest/gtest.h"
 
 using namespace swift;
@@ -99,3 +100,62 @@ TEST(OptionSet, intptr_t_isConstructible) {
 }
 
 
+TEST(ValueEnumerator, basic) {
+
+  {
+  ValueEnumerator<int> Trans;
+  // Check that indexing is persistent.
+  EXPECT_EQ(Trans.getIndex(99), Trans.getIndex(99));
+  EXPECT_EQ(Trans.getIndex(100), Trans.getIndex(100));
+
+  // Check that we don't have collisions.
+  bool SameIndex = Trans.getIndex(82) == Trans.getIndex(73);
+  EXPECT_FALSE(SameIndex);
+
+  // Check that invalidation works.
+  // After invalidation the old index must not be equal to the new index.
+  size_t oldIndex = Trans.getIndex(99);
+  Trans.invalidateValue(99);
+  size_t newIndex = Trans.getIndex(99);
+  EXPECT_FALSE(newIndex == oldIndex);
+  }
+
+  {
+  const char *string_1 = "hello";
+  const char *string_2 = "goodbye";
+  const char *string_3 = ":-)";
+  ValueEnumerator<const char*> Trans;
+  EXPECT_EQ(Trans.getIndex(nullptr), Trans.getIndex(nullptr));
+  EXPECT_EQ(Trans.getIndex(string_1), Trans.getIndex(string_1));
+  EXPECT_EQ(Trans.getIndex(string_2), Trans.getIndex(string_2));
+
+  // Check that invalidation works.
+  size_t oldIndex = Trans.getIndex(string_3);
+  Trans.invalidateValue(string_3);
+  size_t newIndex = Trans.getIndex(string_3);
+  EXPECT_FALSE(newIndex == oldIndex);
+
+  // Check that different values don't give the same index.
+  EXPECT_FALSE(Trans.getIndex(string_2) == Trans.getIndex(string_3));
+  }
+
+
+  {
+  ValueEnumerator<int> Trans;
+  // Check a bunch of integers.
+  for (int i = 1; i < 10000; i++) {
+    EXPECT_TRUE(Trans.getIndex(0) != Trans.getIndex(i));
+  }
+
+  // Check that there are no accidental collisions.
+  for (int i = 0; i < 10000; i++) {
+    for (int j = 1; j < 10; j++) {
+      EXPECT_TRUE(Trans.getIndex(i) != Trans.getIndex(i + j));
+    }
+  }
+
+  // Check that indexing is still persistent.
+  EXPECT_EQ(Trans.getIndex(100), Trans.getIndex(100));
+  }
+
+}