Add support for raw identifiers.

grynspan · grynspan · commit 8640814ab32d · 2025-01-07T18:23:53.000-05:00
This PR adds support for the raw identifiers feature introduced with [SE-0451](https://forums.swift.org/t/accepted-with-revision-se-0451-raw-identifiers/76387). At this time, I _think_ I don't need to make any changes to our macro expansion code for it to compile and run, however I may need to revisit later in order to treat functions with raw identifiers as having "display names" and to synthesize test IDs for them that are concise (CRC-32 to the rescue?) We'll cross that bridge when we come to it, after the feature has landed in the toolchain. Resolves #842.
diff --git a/Sources/Testing/Parameterization/TypeInfo.swift b/Sources/Testing/Parameterization/TypeInfo.swift
@@ -69,7 +69,7 @@ public struct TypeInfo: Sendable {
   ///   - mangled: The mangled name of the type, if available.
   init(fullyQualifiedName: String, unqualifiedName: String, mangledName: String?) {
     self.init(
-      fullyQualifiedNameComponents: fullyQualifiedName.split(separator: ".").map(String.init),
+      fullyQualifiedNameComponents: Self.fullyQualifiedNameComponents(ofTypeWithName: fullyQualifiedName),
       unqualifiedName: unqualifiedName,
       mangledName: mangledName
     )
@@ -99,6 +99,48 @@ extension TypeInfo {
   /// An in-memory cache of fully-qualified type name components.
   private static let _fullyQualifiedNameComponentsCache = Locked<[ObjectIdentifier: [String]]>()
 
+  /// Split the given fully-qualified type name into its components.
+  ///
+  /// - Parameters:
+  ///   - fullyQualifiedName: The string to split.
+  ///
+  /// - Returns: The components of `fullyQualifiedName` as substrings thereof.
+  static func fullyQualifiedNameComponents(ofTypeWithName fullyQualifiedName: String) -> [String] {
+    var components = [Substring]()
+
+    var inRawIdentifier = false
+    var componentStartIndex = fullyQualifiedName.startIndex
+    for i in fullyQualifiedName.indices {
+      let c = fullyQualifiedName[i]
+      if c == "`" {
+        inRawIdentifier.toggle()
+      } else if c == "." && !inRawIdentifier {
+        components.append(fullyQualifiedName[componentStartIndex ..< i])
+        componentStartIndex = fullyQualifiedName.index(after: i)
+      }
+    }
+    components.append(fullyQualifiedName[componentStartIndex...])
+
+    // If a type is extended in another module and then referenced by name,
+    // its name according to the String(reflecting:) API will be prefixed with
+    // "(extension in MODULE_NAME):". For our purposes, we never want to
+    // preserve that prefix.
+    if let firstComponent = components.first, firstComponent.starts(with: "(extension in "),
+       let moduleName = firstComponent.split(separator: ":", maxSplits: 1).last {
+      // NOTE: even if the module name is a raw identifier, it comprises a
+      // single identifier (no splitting required) so we don't need to process
+      // it any further.
+      components[0] = moduleName
+    }
+
+    // If a type is private or embedded in a function, its fully qualified
+    // name may include "(unknown context at $xxxxxxxx)" as a component. Strip
+    // those out as they're uninteresting to us.
+    components = components.filter { !$0.starts(with: "(unknown context at") }
+
+    return components.map(String.init)
+  }
+
   /// The complete name of this type, with the names of all referenced types
   /// fully-qualified by their module names when possible.
   ///
@@ -121,22 +163,7 @@ extension TypeInfo {
         return cachedResult
       }
 
-      var result = String(reflecting: type)
-        .split(separator: ".")
-        .map(String.init)
-
-      // If a type is extended in another module and then referenced by name,
-      // its name according to the String(reflecting:) API will be prefixed with
-      // "(extension in MODULE_NAME):". For our purposes, we never want to
-      // preserve that prefix.
-      if let firstComponent = result.first, firstComponent.starts(with: "(extension in ") {
-        result[0] = String(firstComponent.split(separator: ":", maxSplits: 1).last!)
-      }
-
-      // If a type is private or embedded in a function, its fully qualified
-      // name may include "(unknown context at $xxxxxxxx)" as a component. Strip
-      // those out as they're uninteresting to us.
-      result = result.filter { !$0.starts(with: "(unknown context at") }
+      let result = Self.fullyQualifiedNameComponents(ofTypeWithName: String(reflecting: type))
 
       Self._fullyQualifiedNameComponentsCache.withLock { fullyQualifiedNameComponentsCache in
         fullyQualifiedNameComponentsCache[ObjectIdentifier(type)] = result
diff --git a/Sources/Testing/SourceAttribution/SourceLocation.swift b/Sources/Testing/SourceAttribution/SourceLocation.swift
@@ -46,7 +46,7 @@ public struct SourceLocation: Sendable {
   /// - ``moduleName``
   public var fileName: String {
     let lastSlash = fileID.lastIndex(of: "/")!
-    return String(fileID[fileID.index(after: lastSlash)...])
+    return String(fileID[lastSlash...].dropFirst())
   }
 
   /// The name of the module containing the source file.
@@ -67,8 +67,18 @@ public struct SourceLocation: Sendable {
   /// - ``fileName``
   /// - [`#fileID`](https://developer.apple.com/documentation/swift/fileID())
   public var moduleName: String {
-    let firstSlash = fileID.firstIndex(of: "/")!
-    return String(fileID[..<firstSlash])
+    var inRawIdentifier = false
+    for i in fileID.indices {
+      let c = fileID[i]
+      if c == "`" {
+        inRawIdentifier.toggle()
+      } else if c == "/" && !inRawIdentifier {
+        return String(fileID[..<i])
+      }
+    }
+
+    // Normally unreachable.
+    fatalError("Could not find the end of the module name of Swift file ID '\(fileID)'.")
   }
 
   /// The path to the source file.
diff --git a/Tests/TestingTests/SourceLocationTests.swift b/Tests/TestingTests/SourceLocationTests.swift
@@ -44,6 +44,20 @@ struct SourceLocationTests {
     #expect(sourceLocation.moduleName == "FakeModule")
   }
 
+  @Test("SourceLocation.moduleName property with raw identifier",
+    arguments: [
+      ("Foo/Bar.swift", "Foo", "Bar.swift"),
+      ("`Foo`/Bar.swift", "`Foo`", "Bar.swift"),
+      ("`Foo.Bar`/Quux.swift", "`Foo.Bar`", "Quux.swift"),
+      ("`Foo./.Bar`/Quux.swift", "`Foo./.Bar`", "Quux.swift"),
+    ]
+  )
+  func sourceLocationModuleNameWithRawIdentifier(fileID: String, expectedModuleName: String, expectedFileName: String) throws {
+    let sourceLocation = SourceLocation(fileID: fileID, filePath: "", line: 1, column: 1)
+    #expect(sourceLocation.moduleName == expectedModuleName)
+    #expect(sourceLocation.fileName == expectedFileName)
+  }
+
   @Test("SourceLocation.fileID property ignores middle components")
   func sourceLocationFileIDMiddleIgnored() {
     let sourceLocation = SourceLocation(fileID: "A/B/C/D.swift", filePath: "", line: 1, column: 1)
diff --git a/Tests/TestingTests/TypeInfoTests.swift b/Tests/TestingTests/TypeInfoTests.swift
@@ -50,6 +50,56 @@ struct TypeInfoTests {
     #expect(TypeInfo(describing: T.self).fullyQualifiedName == "(Swift.Int, Swift.String) -> Swift.Bool")
   }
 
+  @Test("Splitting raw identifiers",
+    arguments: [
+      ("Foo.Bar", ["Foo", "Bar"]),
+      ("`Foo`.Bar", ["`Foo`", "Bar"]),
+      ("`Foo`.`Bar`", ["`Foo`", "`Bar`"]),
+      ("Foo.`Bar`", ["Foo", "`Bar`"]),
+      ("Foo.`Bar`.Quux", ["Foo", "`Bar`", "Quux"]),
+      ("Foo.`B.ar`.Quux", ["Foo", "`B.ar`", "Quux"]),
+
+      // These have substrings we intentionally strip out.
+      ("Foo.`B.ar`.(unknown context at $0).Quux", ["Foo", "`B.ar`", "Quux"]),
+      ("(extension in Module):Foo.`B.ar`.(unknown context at $0).Quux", ["Foo", "`B.ar`", "Quux"]),
+      ("(extension in `Module`):Foo.`B.ar`.(unknown context at $0).Quux", ["Foo", "`B.ar`", "Quux"]),
+      ("(extension in `Module`):`Foo`.`B.ar`.(unknown context at $0).Quux", ["`Foo`", "`B.ar`", "Quux"]),
+
+      // These aren't syntactically valid, but we should at least not crash.
+      ("Foo.`B.ar`.Quux.`Alpha`..Beta", ["Foo", "`B.ar`", "Quux", "`Alpha`", "", "Beta"]),
+      ("Foo.`B.ar`.Quux.`Alpha", ["Foo", "`B.ar`", "Quux", "`Alpha"]),
+      ("Foo.`B.ar`.Quux.`Alpha``", ["Foo", "`B.ar`", "Quux", "`Alpha``"]),
+      ("Foo.`B.ar`.Quux.`Alpha...", ["Foo", "`B.ar`", "Quux", "`Alpha..."]),
+    ]
+  )
+  func rawIdentifiers(fqn: String, expectedComponents: [String]) throws {
+    let actualComponents = TypeInfo.fullyQualifiedNameComponents(ofTypeWithName: fqn)
+    #expect(expectedComponents == actualComponents)
+  }
+
+  // As above, but round-tripping through .fullyQualifiedName.
+  @Test("Round-tripping raw identifiers",
+    arguments: [
+      ("Foo.Bar", ["Foo", "Bar"]),
+      ("`Foo`.Bar", ["`Foo`", "Bar"]),
+      ("`Foo`.`Bar`", ["`Foo`", "`Bar`"]),
+      ("Foo.`Bar`", ["Foo", "`Bar`"]),
+      ("Foo.`Bar`.Quux", ["Foo", "`Bar`", "Quux"]),
+      ("Foo.`B.ar`.Quux", ["Foo", "`B.ar`", "Quux"]),
+
+      // These aren't syntactically valid, but we should at least not crash.
+      ("Foo.`B.ar`.Quux.`Alpha`..Beta", ["Foo", "`B.ar`", "Quux", "`Alpha`", "", "Beta"]),
+      ("Foo.`B.ar`.Quux.`Alpha", ["Foo", "`B.ar`", "Quux", "`Alpha"]),
+      ("Foo.`B.ar`.Quux.`Alpha``", ["Foo", "`B.ar`", "Quux", "`Alpha``"]),
+      ("Foo.`B.ar`.Quux.`Alpha...", ["Foo", "`B.ar`", "Quux", "`Alpha..."]),
+    ]
+  )
+  func roundTrippedRawIdentifiers(fqn: String, expectedComponents: [String]) throws {
+    let typeInfo = TypeInfo(fullyQualifiedName: fqn, unqualifiedName: "", mangledName: "")
+    #expect(typeInfo.fullyQualifiedName == fqn)
+    #expect(typeInfo.fullyQualifiedNameComponents == expectedComponents)
+  }
+
   @available(_mangledTypeNameAPI, *)
   @Test func mangledTypeName() {
     #expect(_mangledTypeName(String.self) == TypeInfo(describing: String.self).mangledName)
