Merge pull request swiftlang#2192 from hamishknight/tic-tac-toe-two-6.2

Author: hamishknight

Sources/SourceKitLSP/Swift/SwiftTestingScanner.swift

@@ -237,6 +237,9 @@ final class SyntacticSwiftTestingTestScanner: SyntaxVisitor {
       return .skipChildren
     }
 
+    let displayName = attributeData?.displayName ?? typeNames.last!
+    let typeNames = typeNames.map { backtickIfNeeded($0).name }
+
     let memberScanner = SyntacticSwiftTestingTestScanner(
       snapshot: snapshot,
       allTestsDisabled: attributeData?.isDisabled ?? false,
@@ -256,7 +259,7 @@ final class SyntacticSwiftTestingTestScanner: SyntaxVisitor {
     let testItem = AnnotatedTestItem(
       testItem: TestItem(
         id: (parentTypeNames + typeNames).joined(separator: "/"),
-        label: attributeData?.displayName ?? typeNames.last!,
+        label: displayName,
         disabled: (attributeData?.isDisabled ?? false) || allTestsDisabled,
         style: TestStyle.swiftTesting,
         location: Location(uri: snapshot.uri, range: range),
@@ -305,15 +308,13 @@ final class SyntacticSwiftTestingTestScanner: SyntaxVisitor {
     return visitTypeOrExtensionDecl(node, typeNames: [identifier.name])
   }
 
-  /// If the given identifier requires backticks to be a valid decl identifier,
+  /// If the given name requires backticks to be a valid decl identifier,
   /// applies backticks and returns `true` along with the new name. Otherwise
-  /// returns `false` with the original name.
-  func backtickIfNeeded(_ ident: Identifier) -> (backticked: Bool, name: String) {
-    let name = ident.name
-    if name == "``" {
-      // Special case: `` stays as ``. Any other backticked name will have
-      // been stripped by Identifier.
-      return (true, name)
+  /// returns `false` with the name.
+  func backtickIfNeeded(_ name: String) -> (backticked: Bool, name: String) {
+    var name = name
+    if name.first == "`" && name.last == "`" {
+      name = String(name.dropFirst().dropLast())
     }
     let needsBackticks = !name.isValidSwiftIdentifier(for: .variableName)
     return (needsBackticks, needsBackticks ? "`\(name)`" : name)
@@ -335,16 +336,30 @@ final class SyntacticSwiftTestingTestScanner: SyntaxVisitor {
     let parameters = node.signature.parameterClause.parameters.map { param in
       let result =
         if let identifier = param.firstName.identifier {
-          backtickIfNeeded(identifier).name
+          backtickIfNeeded(identifier.name).name
         } else {
           // Something like `_`, leave as-is.
           param.firstName.text
         }
       return "\(result):"
     }.joined()
 
-    let (hasBackticks, baseName) = backtickIfNeeded(identifier)
+    let (hasBackticks, baseName) = backtickIfNeeded(identifier.name)
     let fullName = "\(baseName)(\(parameters))"
+
+    // If we have a display name provided by the attribute, use it, otherwise
+    // we can infer the display name from a raw identifier if we have one.
+    //
+    // A raw identifier is considered an alternative way of spelling the display
+    // name, so e.g these have the same display name:
+    //
+    // ```
+    // @Test("foo bar") func foo() {}
+    // @Test func `foo bar`() {}
+    // ```
+    //
+    // as such it shouldn't include any parameters. If we just have a regular
+    // name then we use the full name as the display name.
     let displayName = attributeData.displayName ?? (hasBackticks ? identifier.name : fullName)
 
     let range = snapshot.absolutePositionRange(

Tests/SourceKitLSPTests/DocumentTestDiscoveryTests.swift

@@ -783,6 +783,131 @@ final class DocumentTestDiscoveryTests: XCTestCase {
     )
   }
 
+  func testSwiftTestingTestWithNestedRawIdentifiers() async throws {
+    let testClient = try await TestSourceKitLSPClient()
+    let uri = DocumentURI(for: .swift)
+
+    let positions = testClient.openDocument(
+      """
+      import Testing
+
+      1️⃣struct `A B` {
+        2️⃣struct `C` {
+          3️⃣struct `D.E` {
+            4️⃣@Test
+            func `foo bar`() {
+              #expect(1 == 2)
+            }5️⃣
+          }6️⃣
+        }7️⃣
+      }8️⃣
+      """,
+      uri: uri
+    )
+
+    let tests = try await testClient.send(DocumentTestsRequest(textDocument: TextDocumentIdentifier(uri)))
+    XCTAssertEqual(
+      tests,
+      [
+        TestItem(
+          id: "`A B`",
+          label: "A B",
+          style: TestStyle.swiftTesting,
+          location: Location(uri: uri, range: positions["1️⃣"]..<positions["8️⃣"]),
+          children: [
+            TestItem(
+              id: "`A B`/C",
+              label: "C",
+              style: TestStyle.swiftTesting,
+              location: Location(uri: uri, range: positions["2️⃣"]..<positions["7️⃣"]),
+              children: [
+                TestItem(
+                  id: "`A B`/C/`D.E`",
+                  label: "D.E",
+                  style: TestStyle.swiftTesting,
+                  location: Location(uri: uri, range: positions["3️⃣"]..<positions["6️⃣"]),
+                  children: [
+                    TestItem(
+                      id: "`A B`/C/`D.E`/`foo bar`()",
+                      label: "foo bar",
+                      style: TestStyle.swiftTesting,
+                      location: Location(uri: uri, range: positions["4️⃣"]..<positions["5️⃣"])
+                    )
+                  ]
+                )
+              ]
+            )
+          ]
+        )
+      ]
+    )
+  }
+
+  func testSwiftTestingTestWithNestedRawIdentifiersExtension() async throws {
+    let testClient = try await TestSourceKitLSPClient()
+    let uri = DocumentURI(for: .swift)
+
+    let positions = testClient.openDocument(
+      """
+      import Testing
+
+      struct `A.B` {
+        struct `C` {
+          struct `D E` {}
+        }
+      }
+      1️⃣extension `A.B`.`C`.`D E` {
+        2️⃣@Test
+        func `foo bar`() {
+          #expect(1 == 2)
+        }3️⃣
+      }4️⃣
+      5️⃣extension `A.B` {
+        6️⃣@Test
+        func `bar baz`() {
+          #expect(1 == 2)
+        }7️⃣
+      }8️⃣
+      """,
+      uri: uri
+    )
+
+    let tests = try await testClient.send(DocumentTestsRequest(textDocument: TextDocumentIdentifier(uri)))
+    XCTAssertEqual(
+      tests,
+      [
+        TestItem(
+          id: "`A.B`/C/`D E`",
+          label: "D E",
+          style: TestStyle.swiftTesting,
+          location: Location(uri: uri, range: positions["1️⃣"]..<positions["4️⃣"]),
+          children: [
+            TestItem(
+              id: "`A.B`/C/`D E`/`foo bar`()",
+              label: "foo bar",
+              style: TestStyle.swiftTesting,
+              location: Location(uri: uri, range: positions["2️⃣"]..<positions["3️⃣"])
+            )
+          ]
+        ),
+        TestItem(
+          id: "`A.B`",
+          label: "A.B",
+          style: TestStyle.swiftTesting,
+          location: Location(uri: uri, range: positions["5️⃣"]..<positions["8️⃣"]),
+          children: [
+            TestItem(
+              id: "`A.B`/`bar baz`()",
+              label: "bar baz",
+              style: TestStyle.swiftTesting,
+              location: Location(uri: uri, range: positions["6️⃣"]..<positions["7️⃣"])
+            )
+          ]
+        ),
+      ]
+    )
+  }
+
   func testSwiftTestingTestWithSlashRawIdentifiers() async throws {
     let testClient = try await TestSourceKitLSPClient()
     let uri = DocumentURI(for: .swift)