Format.

Author: MAJKFL

Sources/SwiftLexicalLookup/IntroducingToParentScopeSyntax.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 SwiftSyntax
+
+@_spi(Experimental) public protocol IntroducingToParentScopeSyntax: ScopeSyntax {
+  func introducedToParent(
+    for name: String?,
+    at syntax: SyntaxProtocol,
+    with configDict: LookupConfigDictionary
+  ) -> [LookupResult]
+}

Sources/SwiftLexicalLookup/LookupName.swift

@@ -91,10 +91,6 @@ import SwiftSyntax
       functionCallExpr.arguments.flatMap { argument in
         getNames(from: argument.expression, accessibleAfter: accessibleAfter)
       }
-    case .guardStmt(let guardStmt):
-      guardStmt.conditions.flatMap { cond in
-        getNames(from: cond.condition, accessibleAfter: cond.endPosition)
-      }
     default:
       if let namedDecl = Syntax(syntax).asProtocol(SyntaxProtocol.self) as? NamedDeclSyntax {
         handle(namedDecl: namedDecl, accessibleAfter: accessibleAfter)

Sources/SwiftLexicalLookup/ScopeImplementations.swift

@@ -67,10 +67,11 @@ extension SyntaxProtocol {
 
     let names = introducedNames(using: nameIntroductionStrategy)
       .filter { introducedName in
-        introducedName.isAccessible(at: syntax) && (name == nil || introducedName.refersTo(name!))
+        does(name: name, referTo: introducedName, at: syntax)
       }
 
-    return [.fromFileScope(self, withNames: names, nameIntroductionStrategy: nameIntroductionStrategy)]
+    return names.isEmpty
+      ? [] : [.fromFileScope(self, withNames: names, nameIntroductionStrategy: nameIntroductionStrategy)]
   }
 }
 
@@ -80,6 +81,45 @@ extension SyntaxProtocol {
       LookupName.getNames(from: codeBlockItem.item, accessibleAfter: codeBlockItem.endPosition)
     }
   }
+
+  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)
+  }
 }
 
 @_spi(Experimental) extension ForStmtSyntax: ScopeSyntax {
@@ -171,7 +211,21 @@ extension SyntaxProtocol {
   }
 }
 
-@_spi(Experimental) extension GuardStmtSyntax: ScopeSyntax {
+@_spi(Experimental) extension GuardStmtSyntax: IntroducingToParentScopeSyntax {
+  public func introducedToParent(
+    for name: String?,
+    at syntax: SwiftSyntax.SyntaxProtocol,
+    with configDict: LookupConfigDictionary
+  ) -> [LookupResult] {
+    let names = conditions.flatMap { element in
+      LookupName.getNames(from: element.condition, accessibleAfter: element.endPosition)
+    }.filter { introducedName in
+      does(name: name, referTo: introducedName, at: syntax)
+    }
+
+    return names.isEmpty ? [] : [.fromScope(self, withNames: names)]
+  }
+
   public var introducedNames: [LookupName] {
     []
   }
@@ -182,7 +236,7 @@ extension SyntaxProtocol {
     with configDict: LookupConfigDictionary
   ) -> [LookupResult] {
     if body.position <= syntax.position && body.endPosition >= syntax.position {
-      lookupInParent(for: name, at: self, with: configDict)
+      lookupInParent(for: name, at: self, with: configDict) // Should we add a new config that will skip certain scopes in lookup? Could be more consistent.
     } else {
       defaultLookupImplementation(for: name, at: syntax, with: configDict)
     }

Sources/SwiftLexicalLookup/ScopeSyntax.swift

@@ -85,7 +85,7 @@ extension SyntaxProtocol {
     let filteredNames =
       introducedNames
       .filter { introducedName in
-        introducedName.isAccessible(at: syntax) && (name == nil || introducedName.refersTo(name!))
+        does(name: name, referTo: introducedName, at: syntax)
       }
 
     if filteredNames.isEmpty {
@@ -103,4 +103,8 @@ extension SyntaxProtocol {
   ) -> [LookupResult] {
     parentScope?.lookup(for: name, at: syntax, with: configDict) ?? []
   }
+
+  func does(name: String?, referTo introducedName: LookupName, at syntax: SyntaxProtocol) -> Bool {
+    introducedName.isAccessible(at: syntax) && (name == nil || introducedName.refersTo(name!))
+  }
 }

Tests/SwiftLexicalLookupTest/NameLookupTests.swift

@@ -440,8 +440,11 @@ final class testNameLookup: XCTestCase {
       references: [
         "4️⃣": [.fromScope(CodeBlockSyntax.self, expectedNames: ["1️⃣"])],
         "5️⃣": [],
-        "6️⃣": [.fromScope(CodeBlockSyntax.self, expectedNames: ["1️⃣", "2️⃣"])],
-        "7️⃣": [.fromScope(CodeBlockSyntax.self, expectedNames: ["3️⃣"])],
+        "6️⃣": [
+          .fromScope(GuardStmtSyntax.self, expectedNames: ["2️⃣"]),
+          .fromScope(CodeBlockSyntax.self, expectedNames: ["1️⃣"]),
+        ],
+        "7️⃣": [.fromScope(GuardStmtSyntax.self, expectedNames: ["3️⃣"])],
       ],
       expectedResultTypes: .all(
         IdentifierPatternSyntax.self
@@ -459,8 +462,14 @@ final class testNameLookup: XCTestCase {
         """,
       references: [
         "3️⃣": [.fromScope(CodeBlockSyntax.self, expectedNames: ["1️⃣"])],
-        "5️⃣": [.fromScope(CodeBlockSyntax.self, expectedNames: ["1️⃣", "2️⃣"])],
-        "6️⃣": [.fromScope(CodeBlockSyntax.self, expectedNames: ["1️⃣", "2️⃣", "4️⃣"])],
+        "5️⃣": [
+          .fromScope(GuardStmtSyntax.self, expectedNames: ["2️⃣"]),
+          .fromScope(CodeBlockSyntax.self, expectedNames: ["1️⃣"]),
+        ],
+        "6️⃣": [
+          .fromScope(GuardStmtSyntax.self, expectedNames: ["2️⃣", "4️⃣"]),
+          .fromScope(CodeBlockSyntax.self, expectedNames: ["1️⃣"]),
+        ],
       ],
       expectedResultTypes: .all(
         IdentifierPatternSyntax.self