Remove name lookup method placeholder and test harness. Add missing cases for stopping walkParentTreeUpToFunctionBoundary. Format code.

Author: MAJKFL

Sources/SwiftLexicalScopes/LexicalScopes.swift

@@ -22,7 +22,8 @@ extension SyntaxProtocol {
 
   /// Given syntax node position, returns the current switch case and it's fallthrough destination.
   @_spi(Compiler) @_spi(Testing) public func lookupFallthroughSourceAndDest()
-  -> (source: SwitchCaseSyntax?, destination: SwitchCaseSyntax?) {
+    -> (source: SwitchCaseSyntax?, destination: SwitchCaseSyntax?)
+  {
     guard let scope else { return (nil, nil) }
     return scope.lookupFallthroughSourceAndDestination(at: self)
   }
@@ -32,10 +33,4 @@ extension SyntaxProtocol {
     guard let scope else { return nil }
     return scope.lookupCatchNode(at: Syntax(self))
   }
-
-  /// Given name and syntax node position, return referenced declaration.
-  @_spi(Compiler) @_spi(Testing) public func lookupDeclarationsFor(name: String) -> [Syntax] {
-    guard let scope else { return [] }
-    return scope.getDeclarationsFor(name: name, at: self)
-  }
 }

Sources/SwiftLexicalScopes/Scope.swift

@@ -32,9 +32,6 @@ protocol Scope {
 
   /// Syntax node that introduces this protocol.
   var sourceSyntax: SyntaxProtocol { get }
-
-  /// Returns the declaration `name` refers to at a particular syntax node location.
-  func getDeclarationsFor(name: String, at syntax: SyntaxProtocol) -> [Syntax]
 }
 
 extension Scope {
@@ -46,33 +43,41 @@ extension Scope {
       return syntax?.scope
     }
   }
-  
+
   // MARK: - lookupLabeledStmts
-  
+
   /// Given syntax node position, returns all available labeled statements.
   func lookupLabeledStmts(at syntax: SyntaxProtocol) -> [LabeledStmtSyntax] {
-    return walkParentTreeUpToFunctionBoundary(at: syntax.parent, collect: LabeledStmtSyntax.self)
+    return walkParentTreeUpToFunctionBoundary(
+      at: syntax.parent,
+      collect: LabeledStmtSyntax.self
+    )
   }
-  
+
   // MARK: - lookupFallthroughSourceAndDest
-  
+
   /// Given syntax node position, returns the current switch case and it's fallthrough destination.
   func lookupFallthroughSourceAndDestination(at syntax: SyntaxProtocol) -> (SwitchCaseSyntax?, SwitchCaseSyntax?) {
-    guard let originalSwitchCase = walkParentTreeUpToFunctionBoundary(at: Syntax(syntax), collect: SwitchCaseSyntax.self) else {
+    guard
+      let originalSwitchCase = walkParentTreeUpToFunctionBoundary(
+        at: Syntax(syntax),
+        collect: SwitchCaseSyntax.self
+      )
+    else {
       return (nil, nil)
     }
-    
+
     let nextSwitchCase = lookupNextSwitchCase(at: originalSwitchCase)
-    
+
     return (originalSwitchCase, nextSwitchCase)
   }
-  
+
   /// Given a switch case, returns the case that follows according to the parent.
   private func lookupNextSwitchCase(at switchCaseSyntax: SwitchCaseSyntax) -> SwitchCaseSyntax? {
     guard let switchCaseListSyntax = switchCaseSyntax.parent?.as(SwitchCaseListSyntax.self) else { return nil }
-    
+
     var visitedOriginalCase = false
-    
+
     for child in switchCaseListSyntax.children(viewMode: .sourceAccurate) {
       if let thisCase = child.as(SwitchCaseSyntax.self) {
         if thisCase.id == switchCaseSyntax.id {
@@ -82,21 +87,21 @@ extension Scope {
         }
       }
     }
-    
+
     return nil
   }
-  
+
   // MARK: - lookupCatchNode
-  
+
   /// Given syntax node position, returns the closest ancestor catch node.
   func lookupCatchNode(at syntax: Syntax) -> Syntax? {
     return lookupCatchNodeHelper(at: syntax, traversedCatchClause: false)
   }
-  
+
   /// Given syntax node location, finds where an error could be caught. If set to `true`, `traverseCatchClause`lookup will skip the next do statement.
   private func lookupCatchNodeHelper(at syntax: Syntax?, traversedCatchClause: Bool) -> Syntax? {
     guard let syntax else { return nil }
-    
+
     switch syntax.as(SyntaxEnum.self) {
     case .doStmt:
       if traversedCatchClause {
@@ -118,41 +123,63 @@ extension Scope {
       return lookupCatchNodeHelper(at: syntax.parent, traversedCatchClause: traversedCatchClause)
     }
   }
-  
+
   /// Callect the first syntax node matching the collection type up to a function boundary.
-  func walkParentTreeUpToFunctionBoundary<T: SyntaxProtocol>(at syntax: Syntax?,
-                                                             collect: T.Type) -> T? {
+  func walkParentTreeUpToFunctionBoundary<T: SyntaxProtocol>(
+    at syntax: Syntax?,
+    collect: T.Type
+  ) -> T? {
     walkParentTreeUpToFunctionBoundary(at: syntax, collect: collect, stopWithFirstMatch: true).first
   }
-  
+
   /// Callect syntax nodes matching the collection type up to a function boundary.
-  func walkParentTreeUpToFunctionBoundary<T: SyntaxProtocol>(at syntax: Syntax?,
-                                                             collect: T.Type,
-                                                             stopWithFirstMatch: Bool = false) -> [T] {
-    walkParentTree(upTo: [MemberBlockSyntax.self,
-                          FunctionDeclSyntax.self,
-                          InitializerDeclSyntax.self,
-                          ClosureExprSyntax.self],
-                   at: syntax,
-                   collect: collect,
-                   stopWithFirstMatch: stopWithFirstMatch
+  func walkParentTreeUpToFunctionBoundary<T: SyntaxProtocol>(
+    at syntax: Syntax?,
+    collect: T.Type,
+    stopWithFirstMatch: Bool = false
+  ) -> [T] {
+    walkParentTree(
+      upTo: [
+        MemberBlockSyntax.self,
+        FunctionDeclSyntax.self,
+        InitializerDeclSyntax.self,
+        DeinitializerDeclSyntax.self,
+        AccessorDeclSyntax.self,
+        ClosureExprSyntax.self,
+      ],
+      at: syntax,
+      collect: collect,
+      stopWithFirstMatch: stopWithFirstMatch
     )
   }
-  
+
   /// Callect syntax nodes matching the collection type up until encountering one of the specified syntax nodes.
-  func walkParentTree<T: SyntaxProtocol>(upTo stopAt: [SyntaxProtocol.Type],
-                                         at syntax: Syntax?,
-                                         collect: T.Type,
-                                         stopWithFirstMatch: Bool = false) -> [T] {
+  func walkParentTree<T: SyntaxProtocol>(
+    upTo stopAt: [SyntaxProtocol.Type],
+    at syntax: Syntax?,
+    collect: T.Type,
+    stopWithFirstMatch: Bool = false
+  ) -> [T] {
     guard let syntax, !stopAt.contains(where: { syntax.is($0) }) else { return [] }
     if let matchedSyntax = syntax.as(T.self) {
       if stopWithFirstMatch {
         return [matchedSyntax]
       } else {
-        return [matchedSyntax] + walkParentTree(upTo: stopAt, at: syntax.parent, collect: collect, stopWithFirstMatch: stopWithFirstMatch)
+        return [matchedSyntax]
+          + walkParentTree(
+            upTo: stopAt,
+            at: syntax.parent,
+            collect: collect,
+            stopWithFirstMatch: stopWithFirstMatch
+          )
       }
     } else {
-      return walkParentTree(upTo: stopAt, at: syntax.parent, collect: collect, stopWithFirstMatch: stopWithFirstMatch)
+      return walkParentTree(
+        upTo: stopAt,
+        at: syntax.parent,
+        collect: collect,
+        stopWithFirstMatch: stopWithFirstMatch
+      )
     }
   }
 }

Sources/SwiftLexicalScopes/ScopeConcreteImplementations.swift

@@ -21,9 +21,4 @@ class FileScope: Scope {
   init(syntax: SyntaxProtocol) {
     self.sourceSyntax = syntax
   }
-
-  func getDeclarationsFor(name: String, at syntax: SyntaxProtocol) -> [Syntax] {
-    // TODO: Implement the method
-    return []
-  }
 }

Tests/SwiftLexicalScopesTest/Assertions.swift

@@ -81,25 +81,3 @@ func assertLexicalScopeQuery(
     }
   }
 }
-
-/// Parse `source` and check if the lexical name lookup matches results passed as `expected`.
-///
-/// - Parameters:
-///   - expected: A dictionary of markers with reference location as keys and expected declaration as values.
-func assertLexicalNameLookup(
-  source: String,
-  references: [String: [String]]
-) {
-  assertLexicalScopeQuery(
-    source: source,
-    methodUnderTest: { argument in
-      // Extract reference name and use it for lookup
-      guard let name = argument.firstToken(viewMode: .sourceAccurate)?.text else {
-        XCTFail("Couldn't find a token at \(argument)")
-        return []
-      }
-      return argument.lookupDeclarationsFor(name: name)
-    },
-    expected: references
-  )
-}

Tests/SwiftLexicalScopesTest/SimpleQueryTests.swift

@@ -68,7 +68,7 @@ final class testSimpleQueries: XCTestCase {
       expected: ["3️⃣": ["2️⃣"], "4️⃣": ["1️⃣"]]
     )
   }
-  
+
   func testLabeledStmtLookupClosureNestedWithinLoop() {
     assertLexicalScopeQuery(
       source: """
@@ -87,7 +87,7 @@ final class testSimpleQueries: XCTestCase {
       expected: ["3️⃣": ["2️⃣"], "4️⃣": ["1️⃣"]]
     )
   }
-  
+
   func testLabeledStmtLookupFunctionNestedWithinLoop() {
     assertLexicalScopeQuery(
       source: """