Add SwiftLexicalLookup cache unit testing.

Author: MAJKFL

Sources/SwiftLexicalLookup/Scopes/ScopeSyntax.swift

@@ -50,7 +50,57 @@ extension SyntaxProtocol {
     with config: LookupConfig = LookupConfig(),
     cache: LookupCache? = nil
   ) -> [LookupResult] {
-    scope?.lookup(identifier, at: self.position, with: config, cache: cache) ?? []
+    if let cache, let identifier {
+      let filteredResult: [LookupResult] = (scope?.lookup(nil, at: self.position, with: config, cache: cache) ?? [])
+        .compactMap { result in
+          switch result {
+          case .fromScope(let syntax, let withNames):
+            let filteredNames =
+              withNames
+              .filter { name in
+                name.identifier == identifier
+              }
+
+            guard filteredNames.count != 0 else { return nil }
+            return .fromScope(syntax, withNames: filteredNames)
+          default:
+            return result
+          }
+        }
+
+      var resultWithMergedSequentialResults: [LookupResult] = []
+      var i = 0
+
+      while i < filteredResult.count {
+        let thisResult = filteredResult[i]
+
+        if i < filteredResult.count - 1,
+          case .fromScope(let thisScope, let thisNames) = thisResult,
+          thisScope.asProtocol(SyntaxProtocol.self) is SequentialScopeSyntax
+        {
+          var accumulator = thisNames
+
+          while i < filteredResult.count - 1,
+            case .fromScope(let otherScope, let otherNames) = filteredResult[i + 1],
+            otherScope.asProtocol(SyntaxProtocol.self) is SequentialScopeSyntax,
+            thisScope.id == otherScope.id
+          {
+            accumulator += otherNames
+            i += 1
+          }
+
+          resultWithMergedSequentialResults.append(.fromScope(thisScope, withNames: accumulator))
+        } else {
+          resultWithMergedSequentialResults.append(thisResult)
+        }
+
+        i += 1
+      }
+
+      return resultWithMergedSequentialResults
+    } else {
+      return scope?.lookup(identifier, at: self.position, with: config, cache: cache) ?? []
+    }
   }
 }
 

Tests/SwiftLexicalLookupTest/Assertions.swift

@@ -90,37 +90,78 @@ func assertLexicalNameLookup(
   useNilAsTheParameter: Bool = false,
   config: LookupConfig = LookupConfig()
 ) {
+  let expectedResults = references.mapValues { expectations in
+    expectations.flatMap { expectation in
+      expectation.expectedNames.flatMap { expectedName in
+        expectedName.marker
+      }
+    }
+  }
+
+  // Perform test without cache
+  assertLexicalScopeQuery(
+    source: source,
+    methodUnderTest: { marker, tokenAtMarker in
+      testFunction(
+        marker: marker,
+        tokenAtMarker: tokenAtMarker,
+        references: references,
+        useNilAsTheParameter: useNilAsTheParameter,
+        config: config,
+        cache: nil
+      )
+    },
+    expected: expectedResults,
+    expectedResultTypes: expectedResultTypes
+  )
+
+  // Perform test with cache
+  let cache = LookupCache()
   assertLexicalScopeQuery(
     source: source,
     methodUnderTest: { marker, tokenAtMarker in
-      let lookupIdentifier = Identifier(tokenAtMarker)
+      testFunction(
+        marker: marker,
+        tokenAtMarker: tokenAtMarker,
+        references: references,
+        useNilAsTheParameter: useNilAsTheParameter,
+        config: config,
+        cache: cache
+      )
+    },
+    expected: expectedResults,
+    expectedResultTypes: expectedResultTypes
+  )
+}
 
-      let result = tokenAtMarker.lookup(useNilAsTheParameter ? nil : lookupIdentifier, with: config)
+/// Asserts result of unqualified lookup for the given `marker` and `tokenAtMarker`.
+/// Returns flattened array of syntax nodes returned by the query.
+private func testFunction(
+  marker: String,
+  tokenAtMarker: TokenSyntax,
+  references: [String: [ResultExpectation]],
+  useNilAsTheParameter: Bool,
+  config: LookupConfig,
+  cache: LookupCache?
+) -> [SyntaxProtocol] {
+  let lookupIdentifier = Identifier(tokenAtMarker)
 
-      guard let expectedValues = references[marker] else {
-        XCTFail("For marker \(marker), couldn't find result expectation")
-        return []
-      }
+  let result = tokenAtMarker.lookup(useNilAsTheParameter ? nil : lookupIdentifier, with: config, cache: cache)
 
-      ResultExpectation.assertResult(marker: marker, result: result, expectedValues: expectedValues)
+  guard let expectedValues = references[marker] else {
+    XCTFail("For marker \(marker), couldn't find result expectation")
+    return []
+  }
 
-      return result.flatMap { lookUpResult in
-        lookUpResult.names.flatMap { lookupName in
-          if case .equivalentNames(let names) = lookupName {
-            return names.map(\.syntax)
-          } else {
-            return [lookupName.syntax]
-          }
-        }
-      }
-    },
-    expected: references.mapValues { expectations in
-      expectations.flatMap { expectation in
-        expectation.expectedNames.flatMap { expectedName in
-          expectedName.marker
-        }
+  ResultExpectation.assertResult(marker: marker, result: result, expectedValues: expectedValues)
+
+  return result.flatMap { lookUpResult in
+    lookUpResult.names.flatMap { lookupName in
+      if case .equivalentNames(let names) = lookupName {
+        return names.map(\.syntax)
+      } else {
+        return [lookupName.syntax]
       }
-    },
-    expectedResultTypes: expectedResultTypes
-  )
+    }
+  }
 }