Merge branch 'identifier-based-lookup' into guard-and-implicit-name-lookup

Author: MAJKFL

Sources/SwiftLexicalLookup/IntroducingToSequentialParentScopeSyntax.swift

@@ -16,7 +16,7 @@ protocol IntroducingToSequentialParentScopeSyntax: ScopeSyntax {
   /// Returns names matching lookup that should be
   /// handled by it's parent sequential scope.
   func introducesToSequentialParent(
-    for name: String?,
+    for identifier: Identifier?,
     at syntax: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState

Sources/SwiftLexicalLookup/LookupName.swift

@@ -40,8 +40,8 @@ import SwiftSyntax
     }
   }
 
-  /// Used for name comparison.
-  var name: String {
+  /// Name associated with implicit name kind.
+  private var name: String {
     switch self {
     case .self:
       "self"
@@ -55,6 +55,11 @@ import SwiftSyntax
       "oldValue"
     }
   }
+  
+  /// Identifier used for name comparison.
+  var identifier: Identifier {
+    Identifier(name)
+  }
 }
 
 @_spi(Experimental) public enum LookupName {
@@ -79,15 +84,15 @@ import SwiftSyntax
     }
   }
 
-  /// Introduced name.
+  /// Identifier used for name comparison.
   @_spi(Experimental) public var identifier: Identifier? {
     switch self {
     case .identifier(let syntax, _):
       Identifier(syntax.identifier)
     case .declaration(let syntax):
       Identifier(syntax.name)
-    default:
-      nil
+    case .implicit(let kind):
+      kind.identifier
     }
   }
 
@@ -102,26 +107,16 @@ import SwiftSyntax
     }
   }
 
-  /// Used for name comparison.
-  var name: String? {
-    switch self {
-    case .identifier, .declaration:
-      identifier?.name
-    case .implicit(let implicitName):
-      implicitName.name
-    }
-  }
-
   /// Checks if this name was introduced before the syntax used for lookup.
   func isAccessible(at lookedUpSyntax: SyntaxProtocol) -> Bool {
     guard let accessibleAfter else { return true }
     return accessibleAfter <= lookedUpSyntax.position
   }
 
   /// Checks if this name refers to the looked up phrase.
-  func refersTo(_ lookedUpName: String) -> Bool {
-    guard let name else { return false }
-    return name == lookedUpName
+  func refersTo(_ lookedUpIdentifier: Identifier) -> Bool {
+    guard let identifier else { return false }
+    return identifier == lookedUpIdentifier
   }
 
   /// Extracts names introduced by the given `syntax` structure.

Sources/SwiftLexicalLookup/ScopeImplementations.swift

@@ -97,7 +97,7 @@ import SwiftSyntax
   /// - for `memberBlock` - a, b, c, d, e, f
   /// - for `codeBlock` - a
   @_spi(Experimental) public func lookup(
-    for name: String?,
+    for identifier: Identifier?,
     at syntax: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
@@ -134,7 +134,7 @@ import SwiftSyntax
 
       let sequentialNames = sequentialLookup(
         in: sequentialItems,
-        for: name,
+        for: identifier,
         at: syntax,
         with: config,
         state: state,
@@ -156,14 +156,14 @@ import SwiftSyntax
   }
 
   @_spi(Experimental) public func lookup(
-    for name: String?,
+    for identifier: Identifier?,
     at syntax: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
   ) -> [LookupResult] {
     sequentialLookup(
       in: statements,
-      for: name,
+      for: identifier,
       at: syntax,
       with: config,
       state: state,
@@ -278,7 +278,7 @@ import SwiftSyntax
   /// }
   /// ```
   @_spi(Experimental) public func lookup(
-    for name: String?,
+    for identifier: Identifier?,
     at syntax: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
@@ -302,7 +302,7 @@ import SwiftSyntax
 
 @_spi(Experimental) extension GuardStmtSyntax: IntroducingToSequentialParentScopeSyntax {
   @_spi(Experimental) public func introducesToSequentialParent(
-    for name: String?,
+    for identifier: Identifier?,
     at syntax: SwiftSyntax.SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
@@ -332,17 +332,17 @@ import SwiftSyntax
   /// // a is visible here
   /// ```
   @_spi(Experimental) public func lookup(
-    for name: String?,
+    for identifier: Identifier?,
     at syntax: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
   ) -> [LookupResult] {
     if body.position <= syntax.position && body.endPosition >= syntax.position {
       var newState = state
       newState.skipSequentialIntroductionFrom = self
-      return lookupInParent(for: name, at: syntax, with: config, state: newState)
+      return lookupInParent(for: identifier, at: syntax, with: config, state: newState)
     } else {
-      return defaultLookupImplementation(for: name, at: syntax, with: config, state: state)
+      return defaultLookupImplementation(for: identifier, at: syntax, with: config, state: state)
     }
   }
 }

Sources/SwiftLexicalLookup/ScopeSyntax.swift

@@ -16,8 +16,8 @@ extension SyntaxProtocol {
   /// Returns all names that `for` refers to at this syntax node.
   /// Optional configuration can be passed as `config` to customize the lookup behavior.
   ///
-  /// - Returns: An array of `LookupResult` for `name`  at this syntax node,
-  /// ordered by visibility. If `name` is set to `nil`, returns all available names ordered by visibility.
+  /// - Returns: An array of `LookupResult` for `identifier`  at this syntax node,
+  /// ordered by visibility. If `identifier` is set to `nil`, returns all available names ordered by visibility.
   /// The order is from the innermost to the outermost scope,
   /// and within each result, names are ordered by their introduction
   /// in the source code.
@@ -44,10 +44,10 @@ extension SyntaxProtocol {
   /// in this exact order. The constant declaration within the function body is omitted
   /// due to the ordering rules that prioritize visibility within the function body.
   @_spi(Experimental) public func lookup(
-    for name: String?,
+    for identifier: Identifier?,
     with config: LookupConfig = LookupConfig()
   ) -> [LookupResult] {
-    scope?.lookup(for: name, at: self, with: config, state: LookupState()) ?? []
+    scope?.lookup(for: identifier, at: self, with: config, state: LookupState()) ?? []
   }
 }
 
@@ -59,7 +59,7 @@ extension SyntaxProtocol {
   /// Finds all declarations `name` refers to. `syntax` specifies the node lookup was triggered with.
   /// If `name` set to `nil`, returns all available names at the given node.
   func lookup(
-    for name: String?,
+    for identifier: Identifier?,
     at syntax: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
@@ -75,19 +75,19 @@ extension SyntaxProtocol {
   /// 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.
   @_spi(Experimental) public func lookup(
-    for name: String?,
+    for identifier: Identifier?,
     at syntax: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
   ) -> [LookupResult] {
-    defaultLookupImplementation(for: name, at: syntax, with: config, state: state)
+    defaultLookupImplementation(for: identifier, at: syntax, with: config, state: state)
   }
 
   /// 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.
   func defaultLookupImplementation(
-    for name: String?,
+    for identifier: Identifier?,
     at syntax: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
@@ -99,21 +99,21 @@ extension SyntaxProtocol {
       }
 
     if filteredNames.isEmpty {
-      return lookupInParent(for: name, at: syntax, with: config, state: state)
+      return lookupInParent(for: identifier, at: syntax, with: config, state: state)
     } else {
       return [.fromScope(self, withNames: filteredNames)]
-        + lookupInParent(for: name, at: syntax, with: config, state: state)
+        + lookupInParent(for: identifier, at: syntax, with: config, state: state)
     }
   }
 
   /// Looks up in parent scope.
   func lookupInParent(
-    for name: String?,
+    for identifier: Identifier?,
     at syntax: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
   ) -> [LookupResult] {
-    parentScope?.lookup(for: name, at: syntax, with: config, state: state) ?? []
+    parentScope?.lookup(for: identifier, at: syntax, with: config, state: state) ?? []
   }
 
   func checkName(_ name: String?, refersTo introducedName: LookupName, at syntax: SyntaxProtocol) -> Bool {

Sources/SwiftLexicalLookup/SequentialScopeSyntax.swift

@@ -21,7 +21,7 @@ protocol SequentialScopeSyntax: ScopeSyntax {
   /// scopes that match the lookup.
   func sequentialLookup(
     in codeBlockItems: any Collection<CodeBlockItemSyntax>,
-    for name: String?,
+    for identifier: Identifier?,
     at syntax: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState,
@@ -32,7 +32,7 @@ protocol SequentialScopeSyntax: ScopeSyntax {
 extension SequentialScopeSyntax {
   func sequentialLookup(
     in codeBlockItems: any Collection<CodeBlockItemSyntax>,
-    for name: String?,
+    for identifier: Identifier?,
     at syntax: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState,
@@ -61,7 +61,7 @@ extension SequentialScopeSyntax {
         // Add names introduced by the encountered scope.
         result.append(
           contentsOf: introducingToParentScope.introducesToSequentialParent(
-            for: name,
+            for: identifier,
             at: syntax,
             with: config,
             state: state
@@ -87,6 +87,6 @@ extension SequentialScopeSyntax {
       currentChunk = []
     }
 
-    return (result.isEmpty ? [] : result.reversed()) + lookupInParent(for: name, at: syntax, with: config, state: state)
+    return (result.isEmpty ? [] : result.reversed()) + lookupInParent(for: identifier, at: syntax, with: config, state: state)
   }
 }

Sources/SwiftSyntax/Identifier.swift

@@ -12,23 +12,58 @@
 
 /// A canonicalized representation of an identifier that strips away backticks.
 public struct Identifier: Equatable, Hashable, Sendable {
-  /// The sanitized `text` of a token.
+  enum IdentifierKind: Hashable {
+    case token(raw: RawIdentifier, arena: SyntaxArenaRef)
+    case string(String)
+    
+    static func sanitize(string: String) -> IdentifierKind {
+      let backtick = "`"
+      if string.count > 2 && string.hasPrefix(backtick) && string.hasSuffix(backtick) {
+        let startIndex = string.index(after: string.startIndex)
+        let endIndex = string.index(before: string.endIndex)
+        return .string(String(string[startIndex..<endIndex]))
+      } else {
+        return .string(string)
+      }
+    }
+  }
+  
+  /// The sanitized name of the identifier.
   public var name: String {
-    String(syntaxText: raw.name)
+    switch identifier {
+    case .token(let raw, _):
+      String(syntaxText: raw.name)
+    case .string(let string):
+      string
+    }
   }
-
+  
   @_spi(RawSyntax)
-  public let raw: RawIdentifier
+  public var raw: RawIdentifier? {
+    switch identifier {
+    case .token(let raw, _):
+      raw
+    default:
+      nil
+    }
+  }
 
-  private let arena: SyntaxArenaRef
+  let identifier: IdentifierKind
 
   public init?(_ token: TokenSyntax) {
     guard case .identifier = token.tokenKind else {
       return nil
     }
-
-    self.raw = RawIdentifier(token.tokenView)
-    self.arena = token.tokenView.raw.arenaReference
+    
+    self.identifier = .token(raw: RawIdentifier(token.tokenView), arena: token.tokenView.raw.arenaReference)
+  }
+  
+  public init(_ string: String) {
+    self.identifier = IdentifierKind.sanitize(string: string)
+  }
+  
+  public static func == (lhs: Self, rhs: Self) -> Bool {
+    lhs.name == rhs.name
   }
 }
 

Tests/SwiftLexicalLookupTest/Assertions.swift

@@ -92,7 +92,9 @@ func assertLexicalNameLookup(
   assertLexicalScopeQuery(
     source: source,
     methodUnderTest: { marker, tokenAtMarker in
-      let result = tokenAtMarker.lookup(for: useNilAsTheParameter ? nil : tokenAtMarker.text, with: config)
+      let lookupIdentifier = Identifier(tokenAtMarker) ?? Identifier(tokenAtMarker.text)
+      
+      let result = tokenAtMarker.lookup(for: useNilAsTheParameter ? nil : lookupIdentifier, with: config)
 
       guard let expectedValues = references[marker] else {
         XCTFail("For marker \(marker), couldn't find result expectation")

Tests/SwiftLexicalLookupTest/NameLookupTests.swift

@@ -668,4 +668,43 @@ final class testNameLookup: XCTestCase {
       ]
     )
   }
+  
+  func testBacktickCompatibility() {
+    assertLexicalNameLookup(
+      source: """
+        1️⃣struct Foo {
+          func test() {
+            let 2️⃣`self` = 1
+            print(3️⃣self)
+            print(4️⃣`self`)
+          }
+        }
+        
+        5️⃣struct Bar {
+          func test() {
+            print(6️⃣self)
+            let 7️⃣`self` = 1
+            print(8️⃣`self`)
+          }
+        }
+        """,
+      references: [
+        "3️⃣": [
+          .fromScope(CodeBlockSyntax.self, expectedNames: [NameExpectation.identifier("2️⃣")]),
+          .fromScope(StructDeclSyntax.self, expectedNames: [NameExpectation.implicit(.self("1️⃣"))])
+        ],
+        "4️⃣": [
+          .fromScope(CodeBlockSyntax.self, expectedNames: [NameExpectation.identifier("2️⃣")]),
+          .fromScope(StructDeclSyntax.self, expectedNames: [NameExpectation.implicit(.self("1️⃣"))])
+        ],
+        "6️⃣": [
+          .fromScope(StructDeclSyntax.self, expectedNames: [NameExpectation.implicit(.self("5️⃣"))])
+        ],
+        "8️⃣": [
+          .fromScope(CodeBlockSyntax.self, expectedNames: [NameExpectation.identifier("7️⃣")]),
+          .fromScope(StructDeclSyntax.self, expectedNames: [NameExpectation.implicit(.self("5️⃣"))])
+        ],
+      ]
+    )
+  }
 }