Add catch clause implicit error. Fix declaration name hoisting in sequential scopes. Fix partitioning with non matching results from guard scopes.

Author: MAJKFL

Sources/SwiftLexicalLookup/ScopeImplementations.swift

@@ -355,7 +355,7 @@ import SwiftSyntax
 
 @_spi(Experimental) extension AccessorDeclSyntax: ScopeSyntax {
   /// Implicit and/or explicit names introduced
-  /// withing the accessor..
+  /// within the accessor.
   @_spi(Experimental) public var introducedNames: [LookupName] {
     if let parameters {
       return LookupName.getNames(from: parameters)
@@ -371,3 +371,10 @@ import SwiftSyntax
     }
   }
 }
+
+@_spi(Experimental) extension CatchClauseSyntax: ScopeSyntax {
+  /// Implicit `error` when there are no catch items.
+  public var introducedNames: [LookupName] {
+    return catchItems.isEmpty ? [.implicit(.error(self))] : []
+  }
+}

Sources/SwiftLexicalLookup/SequentialScopeSyntax.swift

@@ -48,8 +48,22 @@ extension SequentialScopeSyntax {
   ) -> [LookupResult] {
     var result: [LookupResult] = []
     var currentChunk: [LookupName] = []
+    var itemsWithoutNamedDecl: [CodeBlockItemSyntax] = []
 
     for codeBlockItem in codeBlockItems {
+      if Syntax(codeBlockItem.item).isProtocol(NamedDeclSyntax.self) {
+        currentChunk += LookupName.getNames(
+          from: codeBlockItem.item,
+          accessibleAfter: codeBlockItem.endPosition
+        ).filter { introducedName in
+          checkName(identifier, refersTo: introducedName, at: origin)
+        }
+      } else {
+        itemsWithoutNamedDecl.append(codeBlockItem)
+      }
+    }
+
+    for codeBlockItem in itemsWithoutNamedDecl {
       if let introducingToParentScope = Syntax(codeBlockItem.item).asProtocol(SyntaxProtocol.self)
         as? IntroducingToSequentialParentScopeSyntax
       {
@@ -60,19 +74,24 @@ extension SequentialScopeSyntax {
           continue
         }
 
+        // Get results from encountered scope.
+        let introducedResults = introducingToParentScope.introducesToSequentialParent(
+          for: identifier,
+          at: origin,
+          with: config,
+          state: state
+        )
+
+        // Skip, if no results were found.
+        guard !introducedResults.isEmpty else { 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 += introducingToParentScope.introducesToSequentialParent(
-          for: identifier,
-          at: origin,
-          with: config,
-          state: state
-        )
+        result += introducedResults
       } else {
         // Extract new names from encountered node.
         currentChunk += LookupName.getNames(

Tests/SwiftLexicalLookupTest/NameLookupTests.swift

@@ -596,8 +596,8 @@ final class testNameLookup: XCTestCase {
       references: [
         "4️⃣": [
           .fromFileScope(expectedNames: ["1️⃣"]),
-          .fromFileScope(expectedNames: ["3️⃣"]),
           .fromScope(GuardStmtSyntax.self, expectedNames: ["2️⃣"]),
+          .fromFileScope(expectedNames: ["3️⃣"]),
         ]
       ],
       expectedResultTypes: .all(IdentifierPatternSyntax.self, except: ["3️⃣": ClassDeclSyntax.self])
@@ -733,4 +733,96 @@ final class testNameLookup: XCTestCase {
       ]
     )
   }
+
+  func testImplicitErrorInCatchClause() {
+    assertLexicalNameLookup(
+      source: """
+        func foo() {
+          let 1️⃣error = 0
+
+          do {
+            try x.bar()
+            2️⃣error
+          } catch SomeError {
+            3️⃣error
+          } 4️⃣catch {
+            5️⃣error
+          }
+        }
+        """,
+      references: [
+        "2️⃣": [.fromScope(CodeBlockSyntax.self, expectedNames: [NameExpectation.identifier("1️⃣")])],
+        "3️⃣": [.fromScope(CodeBlockSyntax.self, expectedNames: [NameExpectation.identifier("1️⃣")])],
+        "5️⃣": [
+          .fromScope(CatchClauseSyntax.self, expectedNames: [NameExpectation.implicit(.error("4️⃣"))]),
+          .fromScope(CodeBlockSyntax.self, expectedNames: [NameExpectation.identifier("1️⃣")]),
+        ],
+      ]
+    )
+  }
+
+  func testTypeDeclAvaialabilityInSequentialScope() {
+    let declExpectation: [ResultExpectation] = [
+      .fromScope(
+        CodeBlockSyntax.self,
+        expectedNames: [
+          NameExpectation.declaration("2️⃣"),
+          NameExpectation.declaration("5️⃣"),
+          NameExpectation.declaration("8️⃣"),
+        ]
+      )
+    ]
+
+    assertLexicalNameLookup(
+      source: """
+        func foo() {
+          1️⃣a
+          2️⃣class a {}
+          3️⃣a
+          guard let x else { return }
+          4️⃣a
+          5️⃣actor a {}
+          6️⃣a
+          guard let x else { return }
+          7️⃣a
+          8️⃣struct a {}
+          9️⃣a
+        }
+        """,
+      references: [
+        "1️⃣": declExpectation,
+        "3️⃣": declExpectation,
+        "4️⃣": declExpectation,
+        "6️⃣": declExpectation,
+        "7️⃣": declExpectation,
+        "9️⃣": declExpectation,
+      ]
+    )
+  }
+
+  func testNonMatchingGuardScopeDoesntPartitionResult() {
+    assertLexicalNameLookup(
+      source: """
+        func foo() {
+          let 1️⃣a = 1
+          let 2️⃣b = 2
+
+          guard let 3️⃣b = a else { return }
+
+          let 4️⃣a = 3
+          let 5️⃣b = 4
+
+          print(6️⃣a, 7️⃣b)
+        }
+        """,
+      references: [
+        "6️⃣": [.fromScope(CodeBlockSyntax.self, expectedNames: ["1️⃣", "4️⃣"])],
+        "7️⃣": [
+          .fromScope(CodeBlockSyntax.self, expectedNames: ["5️⃣"]),
+          .fromScope(GuardStmtSyntax.self, expectedNames: ["3️⃣"]),
+          .fromScope(CodeBlockSyntax.self, expectedNames: ["2️⃣"]),
+        ],
+      ]
+    )
+  }
 }

Tests/SwiftLexicalLookupTest/ResultExpectation.swift

@@ -38,6 +38,11 @@ enum ResultExpectation {
   }
 
   static func assertResult(marker: String, result: [LookupResult], expectedValues: [ResultExpectation]) {
+    XCTAssert(
+      result.count == expectedValues.count,
+      "For marker \(marker), actual result count \(result.count) doesn't match expected \(expectedValues.count)"
+    )
+
     for (actual, expected) in zip(result, expectedValues) {
       switch (actual, expected) {
       case (