Add Identifier wrapper that strips backticks from token text

Sources/SwiftSyntax/Identifier.swift

@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+/// An abstraction for sanitized values on a token.
+public struct Identifier: Equatable, Hashable, Sendable {
+    /// The sanitized `text` of a token.
+    public var name: String {
+        String(syntaxText: rawIdentifier.name)
+    }
+
+    @_spi(RawSyntax)
+    public let rawIdentifier: RawIdentifier
+
+    let arena: RetainedSyntaxArena
+
+    public init?(_ token: TokenSyntax) {
+        guard case .identifier(let text) = token.tokenKind else {
+            return nil
+        }
+
+        var rawText = text.contains("`") ? text.trimmingCharacters(in: "`") : Substring(text)
+
+        let syntaxArena = SyntaxArena()
+
+        let name = rawText.withUTF8 {
+            syntaxArena.intern(
+                SyntaxText(buffer: SyntaxArenaAllocatedBufferPointer<UInt8>($0))
+            )
+        }
+
+        self.rawIdentifier = RawIdentifier(name: name)
+        self.arena = RetainedSyntaxArena(syntaxArena)
+    }
+
+    public static func == (lhs: Identifier, rhs: Identifier) -> Bool {
+        lhs.rawIdentifier == rhs.rawIdentifier
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(rawIdentifier)
+    }
+}
+
+@_spi(RawSyntax) 
+public struct RawIdentifier: Equatable, Hashable, Sendable {
+    public let name: SyntaxText
+}

Sources/SwiftSyntax/TokenSyntax.swift

@@ -153,6 +153,11 @@ public struct TokenSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
 
+  /// An identifier created from `self`.
+  public var identifier: Identifier? {
+    Identifier(self)
+  }
+
   /// A token by itself has no structure, so we represent its structure by an
   /// empty layout node.
   ///

Sources/SwiftSyntax/Utils.swift

@@ -120,3 +120,29 @@ extension RawUnexpectedNodesSyntax {
     self.init(raw: raw)
   }
 }
+
+extension String {
+  func trimmingCharacters(in charactersToTrim: any BidirectionalCollection<Character>) -> Substring {
+    let leadingCharacters = countOfSequentialCharacters(charactersToTrim, in: self)
+    let trailingCharacters = countOfSequentialCharacters(charactersToTrim, in: reversed())
+
+    return dropFirst(leadingCharacters).dropLast(trailingCharacters)
+  }
+}
+
+private func countOfSequentialCharacters(
+  _ charactersToCount: any BidirectionalCollection<Character>,
+  in characters: any BidirectionalCollection<Character>
+) -> Int {
+  var count = 0
+
+  for character in characters {
+    if charactersToCount.contains(character) {
+      count += 1
+    } else {
+      break
+    }
+  }
+
+  return count
+}

Tests/SwiftSyntaxTest/IdentifierTests.swift

@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+@_spi(RawSyntax) import SwiftSyntax
+import XCTest
+
+class IdentifierTests: XCTestCase {
+    public func testIdentifierInit() {
+        let someToken = TokenSyntax(stringLiteral: "someToken")
+        XCTAssertNotNil(Identifier(someToken))
+
+        let nonIdentifierToken = DeclSyntax("let a = 1").firstToken(viewMode: .all)!
+        XCTAssertNil(Identifier(nonIdentifierToken))
+    }
+
+    public func testName() {
+        let basicToken = TokenSyntax(stringLiteral: "basicToken")
+        XCTAssertEqual(Identifier(basicToken)?.name, "basicToken")
+
+        let backtickedToken = TokenSyntax(stringLiteral: "`backtickedToken`")
+        XCTAssertEqual(Identifier(backtickedToken)?.name, "backtickedToken")
+
+        let multiBacktickedToken = TokenSyntax(stringLiteral: "```multiBacktickedToken```")
+        XCTAssertEqual(Identifier(multiBacktickedToken)?.name, "multiBacktickedToken")
+
+        let unicodeNormalizedToken = TokenSyntax(stringLiteral: "\u{e0}") // "a`"
+        XCTAssertEqual(Identifier(unicodeNormalizedToken)?.name, "\u{61}\u{300}") // "à"
+    }
+
+    public func testRawIdentifier() {
+        let rawIdentifier = TokenSyntax(stringLiteral: "sometoken").identifier?.rawIdentifier
+        XCTAssertEqual(rawIdentifier?.name, SyntaxText("sometoken"))
+    }
+
+    public func testTokenSyntaxIdentifier() {
+        let tokenSyntax = TokenSyntax(stringLiteral: "sometoken")
+        XCTAssertEqual(tokenSyntax.identifier, Identifier(tokenSyntax))
+
+        let nonIdentifierToken = DeclSyntax("let a = 1").firstToken(viewMode: .all)!
+        XCTAssertNil(nonIdentifierToken.identifier)
+    }
+}