Add identifier based 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

@@ -101,7 +101,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
@@ -110,7 +110,7 @@ import SwiftSyntax
     case .codeBlock:
       return sequentialLookup(
         in: statements,
-        for: name,
+        for: identifier,
         at: syntax,
         with: config,
         state: state,
@@ -119,7 +119,7 @@ import SwiftSyntax
     case .memberBlock:
       let names = introducedNames(using: .memberBlock)
         .filter { lookupName in
-          does(name: name, referTo: lookupName, at: syntax)
+          does(identifier: identifier, referTo: lookupName, at: syntax)
         }
 
       return names.isEmpty ? [] : [.fromFileScope(self, withNames: names)]
@@ -137,7 +137,7 @@ import SwiftSyntax
           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) })
+            members.append(contentsOf: foundNames.filter { does(identifier: identifier, referTo: $0, at: syntax) })
           } else {
             encounteredNonDeclaration = true
             sequentialItems.append(codeBlockItem)
@@ -147,7 +147,7 @@ import SwiftSyntax
 
       let sequentialNames = sequentialLookup(
         in: sequentialItems,
-        for: name,
+        for: identifier,
         at: syntax,
         with: config,
         state: state,
@@ -169,14 +169,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,
@@ -291,15 +291,15 @@ import SwiftSyntax
   /// }
   /// ```
   @_spi(Experimental) public func lookup(
-    for name: String?,
+    for identifier: Identifier?,
     at syntax: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
   ) -> [LookupResult] {
     if let elseBody, elseBody.position <= syntax.position, elseBody.endPosition >= syntax.position {
-      lookupInParent(for: name, at: syntax, with: config, state: state)
+      lookupInParent(for: identifier, at: syntax, with: config, state: state)
     } else {
-      defaultLookupImplementation(for: name, at: syntax, with: config, state: state)
+      defaultLookupImplementation(for: identifier, at: syntax, with: config, state: state)
     }
   }
 }
@@ -315,15 +315,15 @@ 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
   ) -> [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)
+      does(identifier: identifier, referTo: introducedName, at: syntax)
     }
 
     return names.isEmpty ? [] : [.fromScope(self, withNames: names)]
@@ -345,17 +345,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,48 +75,48 @@ 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
   ) -> [LookupResult] {
     let filteredNames =
       introducedNames
       .filter { introducedName in
-        does(name: name, referTo: introducedName, at: syntax)
+        does(identifier: identifier, referTo: introducedName, at: syntax)
       }
 
     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 does(name: String?, referTo introducedName: LookupName, at syntax: SyntaxProtocol) -> Bool {
-    introducedName.isAccessible(at: syntax) && (name == nil || introducedName.refersTo(name!))
+  func does(identifier: Identifier?, referTo introducedName: LookupName, at syntax: SyntaxProtocol) -> Bool {
+    introducedName.isAccessible(at: syntax) && (identifier == nil || introducedName.refersTo(identifier!))
   }
 }

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
@@ -75,7 +75,7 @@ extension SequentialScopeSyntax {
               from: codeBlockItem.item,
               accessibleAfter: codeBlockItem.endPosition
             ).filter { introducedName in
-              does(name: name, referTo: introducedName, at: syntax)
+              does(identifier: identifier, referTo: introducedName, at: syntax)
             }
         )
       }
@@ -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

@@ -14,13 +14,14 @@
 public struct Identifier: Equatable, Hashable, Sendable {
   /// The sanitized `text` of a token.
   public var name: String {
-    String(syntaxText: raw.name)
+    string?.name ?? String(syntaxText: raw!.name)
   }
 
   @_spi(RawSyntax)
-  public let raw: RawIdentifier
+  public let raw: RawIdentifier?
+  public let string: StringIdentifier?
 
-  private let arena: SyntaxArenaRef
+  private let arena: SyntaxArenaRef?
 
   public init?(_ token: TokenSyntax) {
     guard case .identifier = token.tokenKind else {
@@ -29,6 +30,24 @@ public struct Identifier: Equatable, Hashable, Sendable {
 
     self.raw = RawIdentifier(token.tokenView)
     self.arena = token.tokenView.raw.arenaReference
+    self.string = nil
+  }
+  
+  public init(_ string: String) {
+    self.string = StringIdentifier(string)
+    self.raw = nil
+    self.arena = nil
+  }
+  
+  public static func == (lhs: Self, rhs: Self) -> Bool {
+    if let lhsRaw = lhs.raw,
+       let rhsRaw = rhs.raw,
+       let lhsArena = lhs.arena,
+       let rhsArena = rhs.arena {
+      return lhsRaw == rhsRaw && lhsArena == rhsArena
+    } else {
+      return lhs.name == rhs.name
+    }
   }
 }
 
@@ -48,3 +67,18 @@ public struct RawIdentifier: Equatable, Hashable, Sendable {
     }
   }
 }
+
+public struct StringIdentifier: Equatable, Hashable, Sendable {
+  public let name: String
+
+  fileprivate init(_ string: String) {
+    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)
+      self.name = String(string[startIndex..<endIndex])
+    } else {
+      self.name = string
+    }
+  }
+}