Separate lookup state from config.

Author: MAJKFL

Sources/SwiftLexicalLookup/Configurations/LookupConfig.swift

@@ -17,15 +17,9 @@ import Foundation
   /// `memberBlockUpToLastDecl` by default.
   public var fileScopeHandling: FileScopeHandlingConfig
 
-  /// Specifies scopes that introduce names to their parent and
-  /// should be skipped during lookup in sequential scopes.
-  public var ignoreChildrenToSequentialParentIntroductionsFrom: [IntroducingToSequentialParentScopeSyntax]
-
   public init(
-    fileScopeHandling: FileScopeHandlingConfig = .memberBlockUpToLastDecl,
-    ignoreChildrenToSequentialParentIntroductionsFrom: [IntroducingToSequentialParentScopeSyntax] = []
+    fileScopeHandling: FileScopeHandlingConfig = .memberBlockUpToLastDecl
   ) {
     self.fileScopeHandling = fileScopeHandling
-    self.ignoreChildrenToSequentialParentIntroductionsFrom = ignoreChildrenToSequentialParentIntroductionsFrom
   }
 }

Sources/SwiftLexicalLookup/IntroducingToSequentialParentScopeSyntax.swift

@@ -18,6 +18,7 @@ import SwiftSyntax
   func introducesToSequentialParent(
     for name: String?,
     at syntax: SyntaxProtocol,
-    with config: LookupConfig
+    with config: LookupConfig,
+    state: LookupState
   ) -> [LookupResult]
 }

Sources/SwiftLexicalLookup/LookupState.swift

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import Foundation
+
+@_spi(Experimental) public struct LookupState {
+  /// Specifies scopes that introduce names to their parent and
+  /// should be skipped during lookup in sequential scopes.
+  var skipSequentialIntroductionFrom: IntroducingToSequentialParentScopeSyntax?
+  
+  @_spi(Experimental) public init() {}
+}

Sources/SwiftLexicalLookup/ScopeImplementations.swift

@@ -103,7 +103,8 @@ extension SyntaxProtocol {
   public func lookup(
     for name: String?,
     at syntax: SyntaxProtocol,
-    with config: LookupConfig
+    with config: LookupConfig,
+    state: LookupState
   ) -> [LookupResult] {
     switch config.fileScopeHandling {
     case .codeBlock:
@@ -112,6 +113,7 @@ extension SyntaxProtocol {
         for: name,
         at: syntax,
         with: config,
+        state: state,
         createResultsForThisScopeWith: { .fromFileScope(self, withNames: $0) }
       )
     case .memberBlock:
@@ -148,6 +150,7 @@ extension SyntaxProtocol {
         for: name,
         at: syntax,
         with: config,
+        state: state,
         createResultsForThisScopeWith: { .fromFileScope(self, withNames: $0) }
       )
 
@@ -165,18 +168,24 @@ extension SyntaxProtocol {
     }
   }
 
-  public func lookup(for name: String?, at syntax: SyntaxProtocol, with config: LookupConfig) -> [LookupResult] {
+  public func lookup(
+    for name: String?,
+    at syntax: SyntaxProtocol,
+    with config: LookupConfig,
+    state: LookupState
+  ) -> [LookupResult] {
     sequentialLookup(
       in: statements,
       for: name,
       at: syntax,
       with: config,
+      state: state,
       createResultsForThisScopeWith: { .fromScope(self, withNames: $0) }
     )
   }
 }
 
-@_spi(Experimental) extension ForStmtSyntax: ScopeSyntax {
+@_spi(Experimental) extension ForStmtSyntax: ScopeSyntax {  
   /// Names introduced in the `for` body.
   public var introducedNames: [LookupName] {
     LookupName.getNames(from: pattern)
@@ -290,12 +299,13 @@ extension SyntaxProtocol {
   public func lookup(
     for name: String?,
     at syntax: SyntaxProtocol,
-    with config: LookupConfig
+    with config: LookupConfig,
+    state: LookupState
   ) -> [LookupResult] {
     if let elseBody, elseBody.position <= syntax.position, elseBody.endPosition >= syntax.position {
-      lookupInParent(for: name, at: syntax, with: config)
+      lookupInParent(for: name, at: syntax, with: config, state: state)
     } else {
-      defaultLookupImplementation(for: name, at: syntax, with: config)
+      defaultLookupImplementation(for: name, at: syntax, with: config, state: state)
     }
   }
 }
@@ -313,7 +323,8 @@ extension SyntaxProtocol {
   public func introducesToSequentialParent(
     for name: String?,
     at syntax: SwiftSyntax.SyntaxProtocol,
-    with config: LookupConfig
+    with config: LookupConfig,
+    state: LookupState
   ) -> [LookupResult] {
     let names = conditions.flatMap { element in
       LookupName.getNames(from: element.condition, accessibleAfter: element.endPosition)
@@ -342,14 +353,15 @@ extension SyntaxProtocol {
   public func lookup(
     for name: String?,
     at syntax: SyntaxProtocol,
-    with config: LookupConfig
+    with config: LookupConfig,
+    state: LookupState
   ) -> [LookupResult] {
     if body.position <= syntax.position && body.endPosition >= syntax.position {
-      var newConfig = config
-      newConfig.ignoreChildrenToSequentialParentIntroductionsFrom.append(self)
-      return lookupInParent(for: name, at: syntax, with: newConfig)
+      var newState = state
+      newState.skipSequentialIntroductionFrom = self
+      return lookupInParent(for: name, at: syntax, with: config, state: newState)
     } else {
-      return defaultLookupImplementation(for: name, at: syntax, with: config)
+      return defaultLookupImplementation(for: name, at: syntax, with: config, state: state)
     }
   }
 }

Sources/SwiftLexicalLookup/ScopeSyntax.swift

@@ -47,7 +47,7 @@ extension SyntaxProtocol {
     for name: String?,
     with config: LookupConfig = LookupConfig()
   ) -> [LookupResult] {
-    scope?.lookup(for: name, at: self, with: config) ?? []
+    scope?.lookup(for: name, at: self, with: config, state: LookupState()) ?? []
   }
 }
 
@@ -58,7 +58,10 @@ extension SyntaxProtocol {
   var introducedNames: [LookupName] { get }
   /// Finds all declarations `name` refers to. `at` specifies the node lookup was triggered with.
   /// If `name` set to `nil`, returns all available names at the given node.
-  func lookup(for name: String?, at syntax: SyntaxProtocol, with config: LookupConfig) -> [LookupResult]
+  func lookup(for name: String?, 
+              at syntax: SyntaxProtocol,
+              with config: LookupConfig,
+              state: LookupState) -> [LookupResult]
 }
 
 @_spi(Experimental) extension ScopeSyntax {
@@ -72,9 +75,10 @@ extension SyntaxProtocol {
   public func lookup(
     for name: String?,
     at syntax: SyntaxProtocol,
-    with config: LookupConfig
+    with config: LookupConfig,
+    state: LookupState
   ) -> [LookupResult] {
-    defaultLookupImplementation(for: name, at: syntax, with: config)
+    defaultLookupImplementation(for: name, at: syntax, with: config, state: state)
   }
 
   /// Returns `LookupResult` of all names introduced in this scope that `name`
@@ -83,7 +87,8 @@ extension SyntaxProtocol {
   func defaultLookupImplementation(
     for name: String?,
     at syntax: SyntaxProtocol,
-    with config: LookupConfig
+    with config: LookupConfig,
+    state: LookupState
   ) -> [LookupResult] {
     let filteredNames =
       introducedNames
@@ -92,19 +97,20 @@ extension SyntaxProtocol {
       }
 
     if filteredNames.isEmpty {
-      return lookupInParent(for: name, at: syntax, with: config)
+      return lookupInParent(for: name, at: syntax, with: config, state: state)
     } else {
-      return [.fromScope(self, withNames: filteredNames)] + lookupInParent(for: name, at: syntax, with: config)
+      return [.fromScope(self, withNames: filteredNames)] + lookupInParent(for: name, at: syntax, with: config, state: state)
     }
   }
 
   /// Looks up in parent scope.
   func lookupInParent(
     for name: String?,
     at syntax: SyntaxProtocol,
-    with config: LookupConfig
+    with config: LookupConfig,
+    state: LookupState
   ) -> [LookupResult] {
-    parentScope?.lookup(for: name, at: syntax, with: config) ?? []
+    parentScope?.lookup(for: name, at: syntax, with: config, state: state) ?? []
   }
 
   func does(name: String?, referTo introducedName: LookupName, at syntax: SyntaxProtocol) -> Bool {

Sources/SwiftLexicalLookup/SequentialScopeSyntax.swift

@@ -24,6 +24,7 @@ import SwiftSyntax
     for name: String?,
     at syntax: SyntaxProtocol,
     with config: LookupConfig,
+    state: LookupState,
     createResultsForThisScopeWith getResults: ([LookupName]) -> (LookupResult)
   ) -> [LookupResult]
 }
@@ -34,6 +35,7 @@ import SwiftSyntax
     for name: String?,
     at syntax: SyntaxProtocol,
     with config: LookupConfig,
+    state: LookupState,
     createResultsForThisScopeWith getResults: ([LookupName]) -> (LookupResult)
   ) -> [LookupResult] {
     var result = [LookupResult]()
@@ -43,23 +45,24 @@ import SwiftSyntax
       if let introducingToParentScope = Syntax(codeBlockItem.item).asProtocol(SyntaxProtocol.self)
         as? IntroducingToSequentialParentScopeSyntax
       {
-        guard
-          !config.ignoreChildrenToSequentialParentIntroductionsFrom.contains(where: {
-            $0.id == introducingToParentScope.id
-          })
-        else {
+        // Check if the enocountered scope should be ignored.
+        if let scopeToSkip = state.skipSequentialIntroductionFrom,
+           scopeToSkip.id == introducingToParentScope.id {
           continue
         }
 
+        // If there are some names collected, create a new result for this scope.
         if !currentChunk.isEmpty {
           result.append(getResults(currentChunk))
           currentChunk = []
         }
 
+        // Add names introduced by the encountered scope.
         result.append(
-          contentsOf: introducingToParentScope.introducesToSequentialParent(for: name, at: syntax, with: config)
+          contentsOf: introducingToParentScope.introducesToSequentialParent(for: name, at: syntax, with: config, state: state)
         )
       } else {
+        // Extract new names from encountered node.
         currentChunk.append(
           contentsOf:
             LookupName.getNames(
@@ -72,11 +75,12 @@ import SwiftSyntax
       }
     }
 
+    // If there are some names collected, create a new result for this scope.
     if !currentChunk.isEmpty {
       result.append(getResults(currentChunk))
       currentChunk = []
     }
 
-    return (result.isEmpty ? [] : result.reversed()) + lookupInParent(for: name, at: syntax, with: config)
+    return (result.isEmpty ? [] : result.reversed()) + lookupInParent(for: name, at: syntax, with: config, state: state)
   }
 }