Format.

Author: MAJKFL

Sources/SwiftLexicalLookup/Configurations/LookupConfigDictionary.swift

@@ -15,17 +15,17 @@ 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

Sources/SwiftLexicalLookup/LookupResult.swift

@@ -18,7 +18,11 @@ import SwiftSyntax
   case fromScope(ScopeSyntax, withNames: [LookupName])
   /// File scope, names that matched lookup and name introduction
   /// strategy used for the lookup.
-  case fromFileScope(SourceFileSyntax, withNames: [LookupName], nameIntroductionStrategy: FileScopeNameIntroductionStrategy)
+  case fromFileScope(
+    SourceFileSyntax,
+    withNames: [LookupName],
+    nameIntroductionStrategy: FileScopeNameIntroductionStrategy
+  )
 
   /// Associated scope.
   @_spi(Experimental) public var scope: ScopeSyntax? {

Sources/SwiftLexicalLookup/ScopeImplementations.swift

@@ -27,15 +27,15 @@ extension SyntaxProtocol {
   public var introducedNames: [LookupName] {
     introducedNames(using: .memberBlockUpToLastDecl)
   }
-  
+
   public func introducedNames(using nameIntroductionStrategy: FileScopeNameIntroductionStrategy) -> [LookupName] {
     switch nameIntroductionStrategy {
     case .memberBlockUpToLastDecl:
       var encounteredNonDeclaration = false
-      
+
       return statements.flatMap { codeBlockItem in
         let item = codeBlockItem.item
-        
+
         if encounteredNonDeclaration {
           return LookupName.getNames(from: item, accessibleAfter: codeBlockItem.endPosition)
         } else {
@@ -57,15 +57,19 @@ extension SyntaxProtocol {
       }
     }
   }
-  
-  public func lookup(for name: String?, at syntax: SyntaxProtocol, with configDict: LookupConfigDictionary) -> [LookupResult] {
+
+  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
         introducedName.isAccessible(at: syntax) && (name == nil || introducedName.refersTo(name!))
       }
-    
+
     return [.fromFileScope(self, withNames: names, nameIntroductionStrategy: nameIntroductionStrategy)]
   }
 }
@@ -86,26 +90,28 @@ extension SyntaxProtocol {
 
 @_spi(Experimental) extension ClosureExprSyntax: ScopeSyntax {
   public var introducedNames: [LookupName] {
-    let captureNames = signature?.capture?.children(viewMode: .sourceAccurate).flatMap { child in
-      if let captureList = child.as(ClosureCaptureListSyntax.self) {
-        captureList.children(viewMode: .sourceAccurate).flatMap { capture in
-          LookupName.getNames(from: capture)
+    let captureNames =
+      signature?.capture?.children(viewMode: .sourceAccurate).flatMap { child in
+        if let captureList = child.as(ClosureCaptureListSyntax.self) {
+          captureList.children(viewMode: .sourceAccurate).flatMap { capture in
+            LookupName.getNames(from: capture)
+          }
+        } else {
+          LookupName.getNames(from: child)
         }
-      } else {
-        LookupName.getNames(from: child)
-      }
-    } ?? []
-    
-    let parameterNames = signature?.parameterClause?.children(viewMode: .sourceAccurate).flatMap { parameter in
-      if let parameterList = parameter.as(ClosureParameterListSyntax.self) {
-        parameterList.children(viewMode: .sourceAccurate).flatMap { parameter in
+      } ?? []
+
+    let parameterNames =
+      signature?.parameterClause?.children(viewMode: .sourceAccurate).flatMap { parameter in
+        if let parameterList = parameter.as(ClosureParameterListSyntax.self) {
+          parameterList.children(viewMode: .sourceAccurate).flatMap { parameter in
+            LookupName.getNames(from: parameter)
+          }
+        } else {
           LookupName.getNames(from: parameter)
         }
-      } else {
-        LookupName.getNames(from: parameter)
-      }
-    } ?? []
-    
+      } ?? []
+
     return captureNames + parameterNames
   }
 }
@@ -144,7 +150,11 @@ extension SyntaxProtocol {
     }
   }
 
-  public func lookup(for name: String?, at syntax: SyntaxProtocol, with configDict: LookupConfigDictionary) -> [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: configDict)
     } else {
@@ -165,8 +175,12 @@ extension SyntaxProtocol {
   public var introducedNames: [LookupName] {
     []
   }
-  
-  public func lookup(for name: String?, at syntax: SyntaxProtocol, with configDict: LookupConfigDictionary) -> [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: configDict)
     } else {

Sources/SwiftLexicalLookup/ScopeSyntax.swift

@@ -66,7 +66,11 @@ 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 configDict: LookupConfigDictionary) -> [LookupResult] {
+  public func lookup(
+    for name: String?,
+    at syntax: SyntaxProtocol,
+    with configDict: LookupConfigDictionary
+  ) -> [LookupResult] {
     defaultLookupImplementation(for: name, at: syntax, with: configDict)
   }
 
@@ -90,7 +94,7 @@ extension SyntaxProtocol {
       return [.fromScope(self, withNames: filteredNames)] + lookupInParent(for: name, at: syntax, with: configDict)
     }
   }
-  
+
   /// Looks up in parent scope.
   func lookupInParent(
     for name: String?,

Tests/SwiftLexicalLookupTest/Assertions.swift

@@ -172,7 +172,10 @@ func assertLexicalNameLookup(
             scope.syntaxNodeType == expectedType,
             "For marker \(marker), scope result type of \(scope.syntaxNodeType) doesn't match expected \(expectedType)"
           )
-        case (.fromFileScope(_, withNames: _, nameIntroductionStrategy: let nameIntroductionStrategy), .fromFileScope(expectedNames: _, nameIntroductionStrategy: let expectedNameIntroductionStrategy)):
+        case (
+          .fromFileScope(_, withNames: _, nameIntroductionStrategy: let nameIntroductionStrategy),
+          .fromFileScope(expectedNames: _, nameIntroductionStrategy: let expectedNameIntroductionStrategy)
+        ):
           XCTAssert(
             nameIntroductionStrategy == expectedNameIntroductionStrategy,
             "For marker \(marker), actual file scope name introduction strategy \(nameIntroductionStrategy) doesn't match expected \(expectedNameIntroductionStrategy)"

Tests/SwiftLexicalLookupTest/NameLookupTests.swift

@@ -134,7 +134,7 @@ final class testNameLookup: XCTestCase {
       )
     )
   }
-  
+
   func testClosureCaptureLookup() {
     assertLexicalNameLookup(
       source: """
@@ -156,7 +156,7 @@ final class testNameLookup: XCTestCase {
       expectedResultTypes: .all(
         ClosureCaptureSyntax.self,
         except: [
-          "1️⃣": IdentifierPatternSyntax.self,
+          "1️⃣": IdentifierPatternSyntax.self
         ]
       )
     )
@@ -353,7 +353,7 @@ final class testNameLookup: XCTestCase {
       )
     )
   }
-  
+
   func testIfCaseLookup() {
     assertLexicalNameLookup(
       source: """
@@ -402,25 +402,27 @@ final class testNameLookup: XCTestCase {
         "7️⃣": [
           .fromScope(CodeBlockSyntax.self, expectedNames: ["4️⃣", "5️⃣"]),
           .fromScope(MemberBlockSyntax.self, expectedNames: ["1️⃣", "2️⃣", "3️⃣"]),
-          .fromFileScope(expectedNames: ["🔟"], nameIntroductionStrategy: .memberBlockUpToLastDecl)
+          .fromFileScope(expectedNames: ["🔟"], nameIntroductionStrategy: .memberBlockUpToLastDecl),
         ],
         "0️⃣": [
           .fromScope(CodeBlockSyntax.self, expectedNames: ["8️⃣", "9️⃣"]),
           .fromScope(IfExprSyntax.self, expectedNames: ["6️⃣"]),
           .fromScope(CodeBlockSyntax.self, expectedNames: ["4️⃣", "5️⃣"]),
           .fromScope(MemberBlockSyntax.self, expectedNames: ["1️⃣", "2️⃣", "3️⃣"]),
-          .fromFileScope(expectedNames: ["🔟"], nameIntroductionStrategy: .memberBlockUpToLastDecl)
+          .fromFileScope(expectedNames: ["🔟"], nameIntroductionStrategy: .memberBlockUpToLastDecl),
         ],
       ],
       expectedResultTypes: .all(
         IdentifierPatternSyntax.self,
-        except: ["3️⃣": FunctionDeclSyntax.self,
-                 "🔟": ClassDeclSyntax.self]
+        except: [
+          "3️⃣": FunctionDeclSyntax.self,
+          "🔟": ClassDeclSyntax.self,
+        ]
       ),
       useNilAsTheParameter: true
     )
   }
-  
+
   func testGuardLookup() {
     assertLexicalNameLookup(
       source: """
@@ -431,7 +433,7 @@ final class testNameLookup: XCTestCase {
             print(4️⃣a, 5️⃣b)
             return
           }
-        
+
           print(6️⃣a, 7️⃣b)
         }
         """,
@@ -446,7 +448,7 @@ final class testNameLookup: XCTestCase {
       )
     )
   }
-  
+
   func testGuardLookupInConditions() {
     assertLexicalNameLookup(
       source: """
@@ -465,24 +467,24 @@ final class testNameLookup: XCTestCase {
       )
     )
   }
-  
+
   func testSimpleFileScope() {
     assertLexicalNameLookup(
       source: """
         1️⃣class a {}
-        
+
         2️⃣class b {
           let x = 3️⃣a + 4️⃣b + 5️⃣c + 6️⃣d
         }
          
         let 8️⃣a = 0
-        
+
         7️⃣class c {}
-        
+
         if a == 0 {}
-        
+
         9️⃣class d {}
-        
+
         let x = 0️⃣d
         """,
       references: [
@@ -495,24 +497,24 @@ final class testNameLookup: XCTestCase {
       expectedResultTypes: .all(ClassDeclSyntax.self, except: ["8️⃣": IdentifierPatternSyntax.self])
     )
   }
-  
+
   func testFileScopeAsMember() {
     assertLexicalNameLookup(
       source: """
         1️⃣class a {}
-        
+
         2️⃣class b {
           let x = 3️⃣a + 4️⃣b + 5️⃣c + 6️⃣d
         }
          
         let 8️⃣a = 0
-        
+
         7️⃣class c {}
-        
+
         if a == 0 {}
-        
+
         9️⃣class d {}
-        
+
         let x = 0️⃣d
         """,
       references: [
@@ -526,24 +528,24 @@ final class testNameLookup: XCTestCase {
       config: [FileScopeNameIntroductionStrategy.memberBlock]
     )
   }
-  
+
   func testFileScopeAsCodeBlock() {
     assertLexicalNameLookup(
       source: """
         1️⃣class a {}
-        
+
         2️⃣class b {
           let x = 3️⃣a + 4️⃣b + 5️⃣c + 6️⃣d
         }
          
         let 8️⃣a = 0
-        
+
         7️⃣class c {}
-        
+
         if a == 0 {}
-        
+
         9️⃣class d {}
-        
+
         let x = 0️⃣d
         """,
       references: [