Derive a display name from a raw identifier and disallow raw IDs with explicit display name string literals

Author: grynspan

Sources/TestingMacros/Support/Additions/TokenSyntaxAdditions.swift

@@ -11,11 +11,39 @@
 import SwiftSyntax
 
 extension TokenSyntax {
+  /// A tuple containing the text of this instance with enclosing backticks
+  /// removed and whether or not they were removed.
+  private var _textWithoutBackticks: (String, backticksRemoved: Bool) {
+    let text = text
+    if case .identifier = tokenKind, text.first == "`" && text.last == "`" && text.count >= 2 {
+      return (String(text.dropFirst().dropLast()), true)
+    }
+
+    return (text, false)
+  }
+
   /// The text of this instance with all backticks removed.
   ///
   /// - Bug: This property works around the presence of backticks in `text.`
   ///   ([swift-syntax-#1936](https://github.com/swiftlang/swift-syntax/issues/1936))
   var textWithoutBackticks: String {
-    text.filter { $0 != "`" }
+    _textWithoutBackticks.0
+  }
+
+  /// The raw identifier, not including enclosing backticks, represented by this
+  /// token, or `nil` if it does not represent one.
+  var rawIdentifier: String? {
+    let (textWithoutBackticks, backticksRemoved) = _textWithoutBackticks
+    if backticksRemoved, textWithoutBackticks.contains(where: \.isWhitespace) {
+      return textWithoutBackticks
+    }
+
+    // TODO: remove this mock path once the toolchain fully supports raw IDs.
+    let mockPrefix = "__raw__$"
+    if backticksRemoved, textWithoutBackticks.starts(with: mockPrefix) {
+      return String(textWithoutBackticks.dropFirst(mockPrefix.count))
+    }
+
+    return nil
   }
 }

Sources/TestingMacros/Support/AttributeDiscovery.swift

@@ -100,6 +100,7 @@ struct AttributeInfo {
   init(byParsing attribute: AttributeSyntax, on declaration: some SyntaxProtocol, in context: some MacroExpansionContext) {
     self.attribute = attribute
 
+    var displayNameArgument: LabeledExprListSyntax.Element?
     var nonDisplayNameArguments: [Argument] = []
     if let arguments = attribute.arguments, case let .argumentList(argumentList) = arguments {
       // If the first argument is an unlabelled string literal, it's the display
@@ -109,15 +110,27 @@ struct AttributeInfo {
         let firstArgumentHasLabel = (firstArgument.label != nil)
         if !firstArgumentHasLabel, let stringLiteral = firstArgument.expression.as(StringLiteralExprSyntax.self) {
           displayName = stringLiteral
+          displayNameArgument = firstArgument
           nonDisplayNameArguments = argumentList.dropFirst().map(Argument.init)
         } else if !firstArgumentHasLabel, firstArgument.expression.is(NilLiteralExprSyntax.self) {
+          displayNameArgument = firstArgument
           nonDisplayNameArguments = argumentList.dropFirst().map(Argument.init)
         } else {
           nonDisplayNameArguments = argumentList.map(Argument.init)
         }
       }
     }
 
+    // Disallow an explicit display name for tests and suites with raw
+    // identifier names as it's redundant and potentially confusing.
+    if let namedDecl = declaration.asProtocol((any NamedDeclSyntax).self),
+       let rawIdentifier = namedDecl.name.rawIdentifier {
+      if let displayName, let displayNameArgument {
+        context.diagnose(.declaration(namedDecl, hasExtraneousDisplayName: displayName, fromArgument: displayNameArgument, using: attribute))
+      }
+      displayName = StringLiteralExprSyntax(content: rawIdentifier)
+    }
+
     // Remove leading "Self." expressions from the arguments of the attribute.
     // See _SelfRemover for more information. Rewriting a syntax tree discards
     // location information from the copy, so only invoke the rewriter if the

Sources/TestingMacros/Support/DiagnosticMessage.swift

@@ -645,6 +645,34 @@ struct DiagnosticMessage: SwiftDiagnostics.DiagnosticMessage {
     )
   }
 
+  /// Create a diagnostic message stating that a declaration has two display
+  /// names.
+  ///
+  /// - Returns: A diagnostic message.
+  static func declaration(
+    _ decl: some NamedDeclSyntax,
+    hasExtraneousDisplayName displayNameFromAttribute: StringLiteralExprSyntax,
+    fromArgument argumentContainingDisplayName: LabeledExprListSyntax.Element,
+    using attribute: AttributeSyntax
+  ) -> Self {
+    // FIXME: implement fixits
+    Self(
+      syntax: Syntax(decl),
+      message: "Attribute \(_macroName(attribute)) specifies display name '\(displayNameFromAttribute.representedLiteralValue!)' for \(_kindString(for: decl)) with implicit display name '\(decl.name.rawIdentifier!)'",
+      severity: .error,
+      fixIts: [
+        FixIt(
+          message: MacroExpansionFixItMessage("Remove '\(displayNameFromAttribute.representedLiteralValue!)'"),
+          changes: [.replace(oldNode: Syntax(argumentContainingDisplayName), newNode: Syntax("" as ExprSyntax))]
+        ),
+        FixIt(
+          message: MacroExpansionFixItMessage("Rename '\(decl.name.textWithoutBackticks)'"),
+          changes: [.replace(oldNode: Syntax(decl.name), newNode: Syntax(EditorPlaceholderExprSyntax("name")))]
+        ),
+      ]
+    )
+  }
+
   /// Create a diagnostic messages stating that the expression passed to
   /// `#require()` is ambiguous.
   ///

Tests/TestingMacrosTests/TestDeclarationMacroTests.swift

@@ -209,6 +209,21 @@ struct TestDeclarationMacroTests {
             ),
           ]
         ),
+
+      #"@Test("Goodbye world") func `__raw__$helloWorld`()"#:
+        (
+          message: "Attribute 'Test' specifies display name 'Goodbye world' for function with implicit display name 'helloWorld'",
+          fixIts: [
+            ExpectedFixIt(
+              message: "Remove 'Goodbye world'",
+              changes: [.replace(oldSourceCode: #""Goodbye world""#, newSourceCode: "")]
+            ),
+            ExpectedFixIt(
+              message: "Rename '__raw__$helloWorld'",
+              changes: [.replace(oldSourceCode: "`__raw__$helloWorld`", newSourceCode: "\(EditorPlaceholderExprSyntax("name"))")]
+            ),
+          ]
+        ),
     ]
   }
 

Tests/TestingTests/MiscellaneousTests.swift

@@ -286,6 +286,11 @@ struct MiscellaneousTests {
     #expect(testType.displayName == "Named Sendable test type")
   }
 
+  @Test func `__raw__$raw_identifier_provides_a_display_name`() throws {
+    let test = try #require(Test.current)
+    #expect(test.displayName == "raw_identifier_provides_a_display_name")
+  }
+
   @Test("Free functions are runnable")
   func freeFunction() async throws {
     await Test(testFunction: freeSyncFunction).run()