Add guard support to file scope.

Author: MAJKFL

Sources/SwiftLexicalLookup/Configurations/LookupConfig.swift

@@ -15,9 +15,17 @@ import Foundation
 @_spi(Experimental) public struct LookupConfig {
   /// Specifies behaviour of file scope.
   /// `memberBlockUpToLastDecl` by default.
-  public var fileScopeHandling: FileScopeHandlingConfig = .memberBlockUpToLastDecl
+  public var fileScopeHandling: FileScopeHandlingConfig
 
-  public init(fileScopeHandling: FileScopeHandlingConfig = .memberBlockUpToLastDecl) {
+  /// Specifies scopes that introduce names to their parent and
+  /// should be skipped during lookup in sequential scopes.
+  public var ignoreChildrenToParentIntroductionsFrom: [IntroducingToParentScopeSyntax]
+
+  public init(
+    fileScopeHandling: FileScopeHandlingConfig = .memberBlockUpToLastDecl,
+    ignoreChildrenToParentIntroductionsFrom: [IntroducingToParentScopeSyntax] = []
+  ) {
     self.fileScopeHandling = fileScopeHandling
+    self.ignoreChildrenToParentIntroductionsFrom = ignoreChildrenToParentIntroductionsFrom
   }
 }

Sources/SwiftLexicalLookup/IntroducingToParentScopeSyntax.swift

@@ -16,6 +16,6 @@ import SwiftSyntax
   func introducedToParent(
     for name: String?,
     at syntax: SyntaxProtocol,
-    with configDict: LookupConfigDictionary
+    with config: LookupConfig
   ) -> [LookupResult]
 }

Sources/SwiftLexicalLookup/ScopeImplementations.swift

@@ -23,7 +23,7 @@ extension SyntaxProtocol {
   }
 }
 
-@_spi(Experimental) extension SourceFileSyntax: ScopeSyntax {
+@_spi(Experimental) extension SourceFileSyntax: SequentialScopeSyntax {
   /// All names introduced in the file scope
   /// according to the default strategy: `memberBlockUpToLastDecl`.
   public var introducedNames: [LookupName] {
@@ -105,16 +105,58 @@ extension SyntaxProtocol {
     at syntax: SyntaxProtocol,
     with config: LookupConfig
   ) -> [LookupResult] {
-    let names = introducedNames(using: config.fileScopeHandling)
-      .filter { introducedName in
-        does(name: name, referTo: introducedName, at: syntax)
+    switch config.fileScopeHandling {
+    case .codeBlock:
+      return sequentialLookup(
+        in: statements,
+        for: name,
+        at: syntax,
+        with: config,
+        createResultsForThisScopeWith: { .fromFileScope(self, withNames: $0) }
+      )
+    case .memberBlock:
+      let names = introducedNames(using: .memberBlock)
+        .filter { lookupName in
+          does(name: name, referTo: lookupName, at: syntax)
+        }
+
+      return names.isEmpty ? [] : [.fromFileScope(self, withNames: names)]
+    case .memberBlockUpToLastDecl:
+      var members = [LookupName]()
+      var sequentialItems = [CodeBlockItemSyntax]()
+      var encounteredNonDeclaration = false
+
+      for codeBlockItem in statements {
+        let item = codeBlockItem.item
+
+        if encounteredNonDeclaration {
+          sequentialItems.append(codeBlockItem)
+        } else {
+          if item.is(DeclSyntax.self) || item.is(VariableDeclSyntax.self) {
+            let foundNames = LookupName.getNames(from: item)
+
+            members.append(contentsOf: foundNames.filter { does(name: name, referTo: $0, at: syntax) })
+          } else {
+            encounteredNonDeclaration = true
+            sequentialItems.append(codeBlockItem)
+          }
+        }
       }
 
-    return names.isEmpty ? [] : [.fromFileScope(self, withNames: names)]
+      let sequentialNames = sequentialLookup(
+        in: sequentialItems,
+        for: name,
+        at: syntax,
+        with: config,
+        createResultsForThisScopeWith: { .fromFileScope(self, withNames: $0) }
+      )
+
+      return (members.isEmpty ? [] : [.fromFileScope(self, withNames: members)]) + sequentialNames
+    }
   }
 }
 
-@_spi(Experimental) extension CodeBlockSyntax: ScopeSyntax {
+@_spi(Experimental) extension CodeBlockSyntax: SequentialScopeSyntax {
   /// Names introduced in the code block scope
   /// accessible after their declaration.
   public var introducedNames: [LookupName] {
@@ -123,43 +165,14 @@ extension SyntaxProtocol {
     }
   }
 
-  public func lookup(
-    for name: String?,
-    at syntax: SyntaxProtocol,
-    with configDict: LookupConfigDictionary
-  ) -> [LookupResult] {
-    var result = [LookupResult]()
-    var currentChunk = [LookupName]()
-
-    for codeBlockItem in statements {
-      if let introducingToParentScope = Syntax(codeBlockItem.item).asProtocol(SyntaxProtocol.self)
-        as? IntroducingToParentScopeSyntax
-      {
-        if !currentChunk.isEmpty {
-          result.append(.fromScope(self, withNames: currentChunk))
-          currentChunk = []
-        }
-
-        result.append(contentsOf: introducingToParentScope.introducedToParent(for: name, at: syntax, with: configDict))
-      } else {
-        currentChunk.append(
-          contentsOf:
-            LookupName.getNames(
-              from: codeBlockItem.item,
-              accessibleAfter: codeBlockItem.endPosition
-            ).filter { introducedName in
-              does(name: name, referTo: introducedName, at: syntax)
-            }
-        )
-      }
-    }
-
-    if !currentChunk.isEmpty {
-      result.append(.fromScope(self, withNames: currentChunk))
-      currentChunk = []
-    }
-
-    return result.reversed() + lookupInParent(for: name, at: syntax, with: configDict)
+  public func lookup(for name: String?, at syntax: SyntaxProtocol, with config: LookupConfig) -> [LookupResult] {
+    sequentialLookup(
+      in: statements,
+      for: name,
+      at: syntax,
+      with: config,
+      createResultsForThisScopeWith: { .fromScope(self, withNames: $0) }
+    )
   }
 }
 
@@ -300,7 +313,7 @@ extension SyntaxProtocol {
   public func introducedToParent(
     for name: String?,
     at syntax: SwiftSyntax.SyntaxProtocol,
-    with configDict: LookupConfigDictionary
+    with config: LookupConfig
   ) -> [LookupResult] {
     let names = conditions.flatMap { element in
       LookupName.getNames(from: element.condition, accessibleAfter: element.endPosition)
@@ -332,9 +345,11 @@ extension SyntaxProtocol {
     with config: LookupConfig
   ) -> [LookupResult] {
     if body.position <= syntax.position && body.endPosition >= syntax.position {
-      lookupInParent(for: name, at: self, with: config)
+      var newConfig = config
+      newConfig.ignoreChildrenToParentIntroductionsFrom.append(self)
+      return lookupInParent(for: name, at: syntax, with: newConfig)
     } else {
-      defaultLookupImplementation(for: name, at: syntax, with: config)
+      return defaultLookupImplementation(for: name, at: syntax, with: config)
     }
   }
 }

Sources/SwiftLexicalLookup/SequentialScopeSyntax.swift

@@ -0,0 +1,71 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+@_spi(Experimental) public protocol SequentialScopeSyntax: ScopeSyntax {
+  func sequentialLookup(
+    in codeBlockItems: any Collection<CodeBlockItemSyntax>,
+    for name: String?,
+    at syntax: SyntaxProtocol,
+    with config: LookupConfig,
+    createResultsForThisScopeWith getResults: ([LookupName]) -> (LookupResult)
+  ) -> [LookupResult]
+}
+
+@_spi(Experimental) extension SequentialScopeSyntax {
+  public func sequentialLookup(
+    in codeBlockItems: any Collection<CodeBlockItemSyntax>,
+    for name: String?,
+    at syntax: SyntaxProtocol,
+    with config: LookupConfig,
+    createResultsForThisScopeWith getResults: ([LookupName]) -> (LookupResult)
+  ) -> [LookupResult] {
+    var result = [LookupResult]()
+    var currentChunk = [LookupName]()
+
+    for codeBlockItem in codeBlockItems {
+      if let introducingToParentScope = Syntax(codeBlockItem.item).asProtocol(SyntaxProtocol.self)
+        as? IntroducingToParentScopeSyntax
+      {
+        guard !config.ignoreChildrenToParentIntroductionsFrom.contains(where: { $0.id == introducingToParentScope.id })
+        else {
+          continue
+        }
+
+        if !currentChunk.isEmpty {
+          result.append(getResults(currentChunk))
+          currentChunk = []
+        }
+
+        result.append(contentsOf: introducingToParentScope.introducedToParent(for: name, at: syntax, with: config))
+      } else {
+        currentChunk.append(
+          contentsOf:
+            LookupName.getNames(
+              from: codeBlockItem.item,
+              accessibleAfter: codeBlockItem.endPosition
+            ).filter { introducedName in
+              does(name: name, referTo: introducedName, at: syntax)
+            }
+        )
+      }
+    }
+
+    if !currentChunk.isEmpty {
+      result.append(getResults(currentChunk))
+      currentChunk = []
+    }
+
+    return (result.isEmpty ? [] : result.reversed()) + lookupInParent(for: name, at: syntax, with: config)
+  }
+}

Tests/SwiftLexicalLookupTest/Assertions.swift

@@ -66,6 +66,26 @@ enum ResultExpectation {
       expectedNames
     }
   }
+
+  var debugDescription: String {
+    switch self {
+    case .fromScope:
+      "fromScope"
+    case .fromFileScope:
+      "fromFileScope"
+    }
+  }
+}
+
+extension LookupResult {
+  var debugDescription: String {
+    switch self {
+    case .fromScope:
+      "fromScope"
+    case .fromFileScope:
+      "fromFileScope"
+    }
+  }
 }
 
 /// `methodUnderTest` is called with the token at every position marker in the keys of `expected`.
@@ -175,7 +195,9 @@ func assertLexicalNameLookup(
         case (.fromFileScope, .fromFileScope):
           break
         default:
-          XCTFail("For marker \(marker), result actual result kind \(actual) doesn't match expected \(expected)")
+          XCTFail(
+            "For marker \(marker), actual result kind \(actual.debugDescription) doesn't match expected \(expected.debugDescription)"
+          )
         }
       }
 

Tests/SwiftLexicalLookupTest/NameLookupTests.swift

@@ -150,7 +150,7 @@ final class testNameLookup: XCTestCase {
         "6️⃣": [
           .fromScope(ClosureExprSyntax.self, expectedNames: ["3️⃣"]),
           .fromScope(CodeBlockSyntax.self, expectedNames: ["1️⃣"]),
-        ],
+        ]
       ],
       expectedResultTypes: .all(
         ClosureCaptureSyntax.self,
@@ -567,4 +567,49 @@ final class testNameLookup: XCTestCase {
       config: LookupConfig(fileScopeHandling: .codeBlock)
     )
   }
+  
+  func testGuardOnFileScope() {
+    assertLexicalNameLookup(
+      source: """
+        let 1️⃣a = 0
+
+        class c {}
+
+        guard let 2️⃣a else { fatalError() }
+
+        3️⃣class a {}
+
+        let x = 4️⃣a
+        """,
+      references: [
+        "4️⃣": [.fromFileScope(expectedNames: ["1️⃣"]),
+                .fromFileScope(expectedNames: ["3️⃣"]),
+                .fromScope(GuardStmtSyntax.self, expectedNames: ["2️⃣"])],
+      ],
+      expectedResultTypes: .all(IdentifierPatternSyntax.self, except: ["3️⃣": ClassDeclSyntax.self])
+    )
+  }
+  
+  func testGuardOnFileScopeCodeBlock() {
+    assertLexicalNameLookup(
+      source: """
+        let 1️⃣a = 0
+
+        class c {}
+
+        guard let 2️⃣a else { fatalError() }
+
+        3️⃣class a {}
+
+        let x = 4️⃣a
+        """,
+      references: [
+        "4️⃣": [.fromFileScope(expectedNames: ["3️⃣"]),
+                .fromScope(GuardStmtSyntax.self, expectedNames: ["2️⃣"]),
+                .fromFileScope(expectedNames: ["1️⃣"]),],
+      ],
+      expectedResultTypes: .all(IdentifierPatternSyntax.self, except: ["3️⃣": ClassDeclSyntax.self]),
+      config: LookupConfig(fileScopeHandling: .codeBlock)
+    )
+  }
 }