Implement LookupCache with LRUCache. Move LRUCache.swift to swift-syntax module with package level access.

Author: MAJKFL

CMakeLists.txt

@@ -57,6 +57,10 @@ if(NOT DEFINED SWIFTSYNTAX_PACKAGE_NAME)
   set(SWIFTSYNTAX_PACKAGE_NAME "${SWIFT_MODULE_ABI_NAME_PREFIX}${PROJECT_NAME}")
 endif()
 
+add_compile_options(
+  "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xfrontend -package-name -Xfrontend ${SWIFTSYNTAX_PACKAGE_NAME}>"
+)
+
 # Determine the module triple.
 if("${SWIFT_HOST_MODULE_TRIPLE}" STREQUAL "")
   set(module_triple_command "${CMAKE_Swift_COMPILER}" -print-target-info)

Sources/SwiftCompilerPluginMessageHandling/CMakeLists.txt

@@ -9,7 +9,6 @@
 add_swift_syntax_library(SwiftCompilerPluginMessageHandling
   CompilerPluginMessageHandler.swift
   Diagnostics.swift
-  LRUCache.swift
   Macros.swift
   PluginMacroExpansionContext.swift
   PluginMessageCompatibility.swift

Sources/SwiftLexicalLookup/LookupCache.swift

@@ -17,19 +17,21 @@ import SwiftSyntax
 public class LookupCache {
   /// Cached results of `ScopeSyntax.lookupParent` calls.
   /// Identified by `SyntaxIdentifier`.
-  private var ancestorResultsCache: [SyntaxIdentifier: [LookupResult]] = [:]
+  private let ancestorResultsCache: LRUCache<SyntaxIdentifier, [LookupResult]>
   /// Cached results of `SequentialScopeSyntax.sequentialLookup` calls.
   /// Identified by `SyntaxIdentifier`.
-  private var sequentialResultsCache: [SyntaxIdentifier: [LookupResult]] = [:]
+  private let sequentialResultsCache: LRUCache<SyntaxIdentifier, [LookupResult]>
   /// Looked-up scope identifiers during cache accesses.
   private var hits: Set<SyntaxIdentifier> = []
 
   private let dropMod: Int
   private var evictionCount = 0
 
   /// Creates a new unqualified lookup cache.
+  /// `capacity` describes the maximum amount of entries in the cache.
+  /// The cache size is maintained according to the LRU (Least Recently Used) policy.
   /// `drop` parameter specifies how many eviction calls will be
-  /// ignored before evicting not-hit members of the cache.
+  /// ignored before evicting not-hit members from subsequent lookups.
   ///
   /// Example cache eviction sequences (s - skip, e - evict):
   /// - `drop = 0` - `e -> e -> e -> e -> e -> ...`
@@ -44,7 +46,9 @@ public class LookupCache {
   /// memory accesses could take longer, slowing down the eviction process. That's why the `drop` value
   /// could be fine-tuned to maximize the performance given file size,
   /// number of lookups, and amount of available memory.
-  public init(drop: Int = 0) {
+  public init(capacity: Int, drop: Int = 0) {
+    self.ancestorResultsCache = LRUCache(capacity: (capacity + 1) / 2)
+    self.sequentialResultsCache = LRUCache(capacity: capacity / 2)
     self.dropMod = drop + 1
   }
 
@@ -91,9 +95,9 @@ public class LookupCache {
       guard evictionCount != 0 else { return }
     }
 
-    for key in Set(ancestorResultsCache.keys).union(sequentialResultsCache.keys).subtracting(hits) {
-      ancestorResultsCache.removeValue(forKey: key)
-      sequentialResultsCache.removeValue(forKey: key)
+    for key in ancestorResultsCache.keysInCache.union(sequentialResultsCache.keysInCache).subtracting(hits) {
+      ancestorResultsCache[key] = nil
+      sequentialResultsCache[key] = nil
     }
 
     hits = []

Sources/SwiftSyntax/CMakeLists.txt

@@ -17,6 +17,7 @@ add_swift_syntax_library(SwiftSyntax
   CustomTraits.swift
   EditorPlaceholder.swift
   Identifier.swift
+  LRUCache.swift
   MemoryLayout.swift
   MissingNodeInitializers.swift
   SourceEdit.swift

Sources/SwiftCompilerPluginMessageHandling/LRUCache.swift renamed to Sources/SwiftSyntax/LRUCache.swift

@@ -11,8 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 /// Simple LRU cache.
-@_spi(Testing)
-public class LRUCache<Key: Hashable, Value> {
+package class LRUCache<Key: Hashable, Value> {
   private class _Node {
     unowned var prev: _Node? = nil
     unowned var next: _Node? = nil
@@ -33,12 +32,14 @@ public class LRUCache<Key: Hashable, Value> {
   private unowned var tail: _Node?
 
   public let capacity: Int
+  public private(set) var keysInCache: Set<Key>
 
   public init(capacity: Int) {
     self.table = [:]
     self.head = nil
     self.tail = nil
     self.capacity = capacity
+    self.keysInCache = []
   }
 
   public var count: Int {
@@ -60,6 +61,7 @@ public class LRUCache<Key: Hashable, Value> {
         self.ensureCapacityForNewValue()
         let node = _Node(key: key, value: newValue)
         addToHead(node: node)
+        keysInCache.insert(key)
         table[key] = node
 
       case let (node?, newValue?):  // update.
@@ -68,6 +70,7 @@ public class LRUCache<Key: Hashable, Value> {
 
       case let (node?, nil):  // delete.
         remove(node: node)
+        keysInCache.remove(key)
         table[key] = nil
 
       case (nil, nil):  // no-op.

Tests/SwiftCompilerPluginTest/LRUCacheTests.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import SwiftSyntax
 @_spi(Testing) import SwiftCompilerPluginMessageHandling
 import XCTest
 

Tests/SwiftLexicalLookupTest/Assertions.swift

@@ -116,7 +116,7 @@ func assertLexicalNameLookup(
   )
 
   // Perform test with cache
-  let cache = LookupCache()
+  let cache = LookupCache(capacity: 10)
   assertLexicalScopeQuery(
     source: source,
     methodUnderTest: { marker, tokenAtMarker in