Introduce LookupConfigDictionary for retrieving lookup configurations.

Author: MAJKFL

Sources/SwiftLexicalLookup/FileScopeHandlingConfig.swift renamed to Sources/SwiftLexicalLookup/Configurations/FileScopeHandlingConfig.swift

@@ -14,3 +14,9 @@ import Foundation
 
 /// Used to customize lookup behavior.
 @_spi(Experimental) public protocol LookupConfig {}
+
+extension LookupConfig {
+  var identifier: ObjectIdentifier {
+    ObjectIdentifier(Self.self)
+  }
+}

Sources/SwiftLexicalLookup/LookupConfig.swift renamed to Sources/SwiftLexicalLookup/Configurations/LookupConfig.swift

@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SwiftSyntax
+
+/// Stores and provides easy access for lookup configuration.
+@_spi(Experimental) public struct LookupConfigDictionary {
+  private var dictionary: [ObjectIdentifier: LookupConfig]
+  
+  /// Creates a new lookup configuration dictionary
+  /// from a given array of configurations.
+  init(from configArray: [LookupConfig]) {
+    dictionary = [:]
+    
+    for config in configArray {
+      dictionary[config.identifier] = config
+    }
+  }
+  
+  subscript<T: LookupConfig>(key: T.Type) -> T? {
+    get {
+      return dictionary[ObjectIdentifier(key)] as? T
+    }
+    set {
+      dictionary[ObjectIdentifier(key)] = newValue
+    }
+  }
+}

Sources/SwiftLexicalLookup/Configurations/LookupConfigDictionary.swift

@@ -58,10 +58,8 @@ extension SyntaxProtocol {
     }
   }
 
-  public func lookup(for name: String?, at syntax: SyntaxProtocol, with config: [LookupConfig]) -> [LookupResult] {
-    let nameIntroductionStrategy = config.first {
-      $0 is FileScopeNameIntroductionStrategy
-    } as? FileScopeNameIntroductionStrategy ?? .memberBlockUpToLastDecl
+  public func lookup(for name: String?, at syntax: SyntaxProtocol, with configDict: LookupConfigDictionary) -> [LookupResult] {
+    let nameIntroductionStrategy = configDict[FileScopeNameIntroductionStrategy.self] ?? .memberBlockUpToLastDecl
 
     let names = introducedNames(using: nameIntroductionStrategy)
       .filter { introducedName in
@@ -146,11 +144,11 @@ 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 configDict: LookupConfigDictionary) -> [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: configDict)
     } else {
-      defaultLookupImplementation(for: name, at: syntax, with: config)
+      defaultLookupImplementation(for: name, at: syntax, with: configDict)
     }
   }
 }
@@ -168,11 +166,11 @@ 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 configDict: LookupConfigDictionary) -> [LookupResult] {
     if body.position <= syntax.position && body.endPosition >= syntax.position {
-      lookupInParent(for: name, at: self, with: config)
+      lookupInParent(for: name, at: self, with: configDict)
     } else {
-      defaultLookupImplementation(for: name, at: syntax, with: config)
+      defaultLookupImplementation(for: name, at: syntax, with: configDict)
     }
   }
 }

Sources/SwiftLexicalLookup/ScopeImplementations.swift

@@ -43,8 +43,8 @@ extension SyntaxProtocol {
   /// declaration, followed by the first function name, and then the second function name,
   /// in this exact order. The constant declaration within the function body is omitted
   /// due to the ordering rules that prioritize visibility within the function body.
-  @_spi(Experimental) public func lookup(for name: String?, with config: [LookupConfig] = []) -> [LookupResult] {
-    scope?.lookup(for: name, at: self, with: config) ?? []
+  @_spi(Experimental) public func lookup(for name: String?, with configArr: [LookupConfig] = []) -> [LookupResult] {
+    scope?.lookup(for: name, at: self, with: LookupConfigDictionary(from: configArr)) ?? []
   }
 }
 
@@ -55,7 +55,7 @@ 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 configDict: LookupConfigDictionary) -> [LookupResult]
 }
 
 @_spi(Experimental) extension ScopeSyntax {
@@ -66,8 +66,8 @@ extension SyntaxProtocol {
   /// Returns `LookupResult` of all names introduced in this scope that `name`
   /// refers to and is accessible at given syntax node then passes lookup to the parent.
   /// If `name` set to `nil`, returns all available names at the given node.
-  public func lookup(for name: String?, at syntax: SyntaxProtocol, with config: [LookupConfig]) -> [LookupResult] {
-    defaultLookupImplementation(for: name, at: syntax, with: config)
+  public func lookup(for name: String?, at syntax: SyntaxProtocol, with configDict: LookupConfigDictionary) -> [LookupResult] {
+    defaultLookupImplementation(for: name, at: syntax, with: configDict)
   }
 
   /// Returns `LookupResult` of all names introduced in this scope that `name`
@@ -76,7 +76,7 @@ extension SyntaxProtocol {
   func defaultLookupImplementation(
     for name: String?,
     at syntax: SyntaxProtocol,
-    with config: [LookupConfig]
+    with configDict: LookupConfigDictionary
   ) -> [LookupResult] {
     let filteredNames =
       introducedNames
@@ -85,18 +85,18 @@ extension SyntaxProtocol {
       }
 
     if filteredNames.isEmpty {
-      return lookupInParent(for: name, at: syntax, with: config)
+      return lookupInParent(for: name, at: syntax, with: configDict)
     } else {
-      return [.fromScope(self, withNames: filteredNames)] + lookupInParent(for: name, at: syntax, with: config)
+      return [.fromScope(self, withNames: filteredNames)] + lookupInParent(for: name, at: syntax, with: configDict)
     }
   }
 
   /// Looks up in parent scope.
   func lookupInParent(
     for name: String?,
     at syntax: SyntaxProtocol,
-    with config: [LookupConfig]
+    with configDict: LookupConfigDictionary
   ) -> [LookupResult] {
-    parentScope?.lookup(for: name, at: syntax, with: config) ?? []
+    parentScope?.lookup(for: name, at: syntax, with: configDict) ?? []
   }
 }