[WIP] Rename CacheLookupTable<T> to WeakLookupTable<Element>

Author: rintaro

Sources/SwiftSyntax/CacheLookupTable.swift renamed to Sources/SwiftSyntax/WeakLookupTable.swift

@@ -1,4 +1,4 @@
-//===----------- CacheLookupTable.swift - Swift Syntax Library -----------===//
+//===----------- WeakLookupTable.swift - Swift Syntax Library -------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -9,7 +9,7 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
-// This file provides lookup table for cached object.
+// This file provides lookup table with weak reference.
 //===----------------------------------------------------------------------===//
 
 /// Protocol for self-identifiable object
@@ -35,10 +35,10 @@ private struct WeakReference<T: AnyObject>: ExpressibleByNilLiteral {
 /// References are stored in a hash table with simple open adressing. Because
 /// of weak reference, unlike normal open addressing, erased bucket are simply
 /// turned into 'nil'.
-class CacheLookupTable<T: Identifiable & AnyObject> {
+class WeakLookupTable<Element: Identifiable & AnyObject> {
 
   /// Storage for the hash table.
-  private var buckets: UnsafeMutablePointer<WeakReference<T>>
+  private var buckets: UnsafeMutablePointer<WeakReference<Element>>
   private var bucketCount: Int
 
   /// Estimated count of inserted values. This is greater than or equal to
@@ -47,7 +47,7 @@ class CacheLookupTable<T: Identifiable & AnyObject> {
   private var estimatedCount: Int
 
   init(capacity: Int = 0) {
-    bucketCount = CacheLookupTable<T>._bucketCount(for: capacity)
+    bucketCount = WeakLookupTable<Element>._bucketCount(for: capacity)
     buckets = .allocate(capacity: bucketCount)
     buckets.initialize(repeating: nil, count: bucketCount)
     estimatedCount = 0
@@ -98,13 +98,13 @@ class CacheLookupTable<T: Identifiable & AnyObject> {
   }
 
   @inline(__always)
-  private func _idealBucket(for id: T.Identifier) -> Int {
+  private func _idealBucket(for id: Element.Identifier) -> Int {
     return id.hashValue & _bucketMask
   }
 
   /// Finds the bucket where the object with the specified id should be stored
   /// to.
-  private func _findHole(_ id: T.Identifier) -> (pos: Int, found: Bool) {
+  private func _findHole(_ id: Element.Identifier) -> (pos: Int, found: Bool) {
     var bucket = _idealBucket(for: id)
 
     // Starting from the ideal bucket for the id, search an available bucket,
@@ -123,8 +123,8 @@ class CacheLookupTable<T: Identifiable & AnyObject> {
   /// Reserves enough space to store the specified number of elements. Returns
   /// true if resizing happened.
   func reserveCapacity(_ requiredCapacity: Int) -> Bool {
-    let requiredBucketCount =
-      CacheLookupTable<T>._bucketCount(for: requiredCapacity, from: bucketCount)
+    let requiredBucketCount = WeakLookupTable<Element>
+      ._bucketCount(for: requiredCapacity, from: bucketCount)
     if (bucketCount >= requiredBucketCount) {
       return false
     }
@@ -165,7 +165,7 @@ class CacheLookupTable<T: Identifiable & AnyObject> {
   /// Reserves enough space to store a single new object. Returns true if
   /// resizing happened.
   private func _ensurePlusOneCapacity() -> Bool {
-    if bucketCount >= CacheLookupTable<T>
+    if bucketCount >= WeakLookupTable<Element>
                         ._minimalBucketCount(for: estimatedCount &+ 1) {
       return false
     }
@@ -177,7 +177,7 @@ class CacheLookupTable<T: Identifiable & AnyObject> {
 
   /// Inserts the given object into the table.
   @discardableResult
-  func insert(_ obj: T) -> Bool {
+  func insert(_ obj: Element) -> Bool {
     var (pos, found) = _findHole(obj.id)
     if found {
       return false
@@ -193,7 +193,7 @@ class CacheLookupTable<T: Identifiable & AnyObject> {
 
   /// Get a object with specified id. Returns 'nil' if the object hasn't been
   /// insert()-ed or it's already been freed.
-  public subscript(id: T.Identifier) -> T? {
+  public subscript(id: Element.Identifier) -> Element? {
     // Since we don't fill the bucket when the object is freed (because we don't
     // know), we can't stop iteration at a hole. So in the worst case (i.e. if
     // the object doesn't exist in the table), full linear search is needed.