Infer a display name for tests and suites which have a raw identifier name consisting of a single token

Author: stmontgomery

Sources/TestingMacros/Support/Additions/FunctionDeclSyntaxAdditions.swift

@@ -11,6 +11,7 @@
 import SwiftSyntax
 import SwiftSyntaxBuilder
 import SwiftSyntaxMacros
+import SwiftParser
 
 extension FunctionDeclSyntax {
   /// Whether or not this function a `static` or `class` function.
@@ -38,7 +39,7 @@ extension FunctionDeclSyntax {
   /// colons.
   var completeName: DeclReferenceExprSyntax {
     func possiblyRaw(_ token: TokenSyntax) -> TokenSyntax {
-      if let rawIdentifier = token.rawIdentifier {
+      if let rawIdentifier = token.rawIdentifier, !rawIdentifier.isValidSwiftIdentifier(for: .memberAccess) {
         return .identifier("`\(rawIdentifier)`")
       }
       return .identifier(token.textWithoutBackticks)

Sources/TestingMacros/Support/Additions/TokenSyntaxAdditions.swift

@@ -35,7 +35,7 @@ extension TokenSyntax {
   /// token, or `nil` if it does not represent one.
   var rawIdentifier: String? {
     let (textWithoutBackticks, backticksRemoved) = _textWithoutBackticks
-    if backticksRemoved, !textWithoutBackticks.isValidSwiftIdentifier(for: .memberAccess) {
+    if backticksRemoved {
       return textWithoutBackticks
     }
 

Sources/TestingMacros/Support/AttributeDiscovery.swift

@@ -11,6 +11,7 @@
 import SwiftSyntax
 import SwiftSyntaxBuilder
 import SwiftSyntaxMacros
+import SwiftParser
 
 /// A syntax rewriter that removes leading `Self.` tokens from member access
 /// expressions in a syntax tree.
@@ -138,11 +139,17 @@ struct AttributeInfo {
       }
     }
 
-    // Disallow an explicit display name for tests and suites with raw
-    // identifier names as it's redundant and potentially confusing.
+    // If this declaration has a raw identifier name, implicitly use the content
+    // of that raw identifier as its display name.
     if let namedDecl = declaration.asProtocol((any NamedDeclSyntax).self),
        let rawIdentifier = namedDecl.name.rawIdentifier {
-      if let displayName, let displayNameArgument {
+      // Disallow having an explicit display name for tests and suites with raw
+      // identifier names as it's redundant and potentially confusing. An
+      // exception to this rule is if the content of the raw identifier is not a
+      // valid identifier on its own. For example:
+      //
+      //   @Test("...") func `subscript`() { ... }
+      if let displayName, let displayNameArgument, !rawIdentifier.isValidSwiftIdentifier(for: .memberAccess) {
         context.diagnose(.declaration(namedDecl, hasExtraneousDisplayName: displayName, fromArgument: displayNameArgument, using: attribute))
       } else {
         displayName = StringLiteralExprSyntax(content: rawIdentifier)

Tests/TestingMacrosTests/TestDeclarationMacroTests.swift

@@ -263,19 +263,26 @@ struct TestDeclarationMacroTests {
     }
   }
 
+  @Test("No diagnostics are emitted for tests with both a raw identifier name and explicit display name when deemed non-redundant", arguments: [
+    #"@Test("Class") func `class`()"#,
+    #"@Test("Struct") func `struct`()"#,
+    #"@Test("Subscript") func `subscript`()"#,
+  ])
+  func nonRedundantRawIdentifierDisplayName(input: String) throws {
+    let (_, diagnostics) = try parse(input)
+    #expect(diagnostics.isEmpty)
+  }
+
   @Test("Raw identifier is detected")
   func rawIdentifier() {
-    #expect(TokenSyntax.identifier("`hello`").rawIdentifier == nil)
-    #expect(TokenSyntax.identifier("`helloworld`").rawIdentifier == nil)
-    #expect(TokenSyntax.identifier("`hélloworld`").rawIdentifier == nil)
-    #expect(TokenSyntax.identifier("`hello_world`").rawIdentifier == nil)
+    #expect(TokenSyntax.identifier("hello").rawIdentifier == nil)
+    #expect(TokenSyntax.identifier("`hello").rawIdentifier == nil)
+    #expect(TokenSyntax.identifier("hello`").rawIdentifier == nil)
+    #expect(TokenSyntax.identifier("hélloworld").rawIdentifier == nil)
+    #expect(TokenSyntax.identifier("hello_world").rawIdentifier == nil)
     #expect(TokenSyntax.identifier("`hello world`").rawIdentifier != nil)
     #expect(TokenSyntax.identifier("`hello/world`").rawIdentifier != nil)
     #expect(TokenSyntax.identifier("`hello\tworld`").rawIdentifier != nil)
-
-    #expect(TokenSyntax.identifier("`class`").rawIdentifier == nil)
-    #expect(TokenSyntax.identifier("`struct`").rawIdentifier == nil)
-    #expect(TokenSyntax.identifier("`class struct`").rawIdentifier != nil)
   }
 
   @Test("Raw function name components")

Tests/TestingTests/MiscellaneousTests.swift

@@ -28,6 +28,10 @@ private import Foundation
 
 @Sendable func freeSyncFunctionParameterized2(_ i: Int, _ j: String) {}
 
+#if compiler(>=6.2) && hasFeature(RawIdentifiers)
+@Test(.hidden, arguments: [0]) func `ValidSingleCapitalizedToken`(someLengthyParameterName: Int) {}
+#endif
+
 // This type ensures the parser can correctly infer that f() is a member
 // function even though @Test is preceded by another attribute or is embedded in
 // a #if statement.
@@ -320,6 +324,12 @@ struct MiscellaneousTests {
   func `Test with raw identifier and raw identifier parameter labels can compile`(`argument name` i: Int) {
     #expect(i == 0)
   }
+
+  @Test func singleValidTokenRawIdentifiers() async throws {
+    let test = try #require(await Test.all.first { $0.name.contains("ValidSingleCapitalizedToken") })
+    #expect(test.name == "ValidSingleCapitalizedToken(someLengthyParameterName:)")
+    #expect(test.displayName == "ValidSingleCapitalizedToken")
+  }
 #endif
 
   @Test("Free functions are runnable")