[ST-0019] Augment JSON ABI

Enhance Swift Testing's JSON event ABI by exposing test metadata that is
currently unavailable to external tools. By including test tags, bug
associations, and time limits in the JSON output, this allows
third-party tools to provide richer insights and more sophisticated test
management capabilities.

Motivation:

Swift Testing's JSON event stream provides data for external tooling,
enabling developers to build test analysis and reporting tools. However,
the current implementation lacks access to some test metadata that
developers may want to use to organize and manage their test suites.

Currently missing from the JSON output are:
  - **Test tags**: Used for categorization
  - **Bug associations**: Tracks bugs associated with tests
  - **Time limits**: Useful for performance monitoring and timeout
    management

This missing metadata limits the capabilities of external tools. For
example:
  - IDE extensions cannot provide tag-based test filtering
  - CI/CD systems cannot generate reports grouped by test categories
  - Performance monitoring tools cannot track tests with specific time
    constraints
  - Bug tracking integrations cannot correlate test failures with known
    issues

Author: bkhouri

Documentation/ABI/JSON.md

@@ -160,10 +160,21 @@ additional `"testCases"` field describing the individual test cases.
   ["displayName": <string>,] ; the user-supplied custom display name
   "sourceLocation": <source-location>, ; where the test is defined
   "id": <test-id>,
-  "isParameterized": <bool> ; is this a parameterized test function or not?
+  "isParameterized": <bool>, ; is this a parameterized test function or not?
+  ["tags": <array:tag>,] ; the tags associated with this test function
+  ["bugs": <array:bug>,] ; the bugs associated with this test function
+  ["timeLimit": <number>] ; the time limit associated with this test function
 }
 
 <test-id> ::= <string> ; an opaque string representing the test case
+
+<tag> ::= <string> ; a string representation of a tag
+
+<bug> ::= {
+  ["url": <string>,] ; the bug URL
+  ["id": <string>,] ; the bug id
+  ["title": <string>] ; the human readable bug title
+}
 ```
 
 <!--

Sources/Testing/ABI/ABI.swift

@@ -43,11 +43,11 @@ extension ABI {
   }
 
   /// The current supported ABI version (ignoring any experimental versions.)
-  typealias CurrentVersion = v6_3
+  typealias CurrentVersion = v6_4
 
   /// The highest defined and supported ABI version (including any experimental
   /// versions.)
-  typealias HighestVersion = v6_3
+  typealias HighestVersion = v6_4
 
 #if !hasFeature(Embedded)
   /// Get the type representing a given ABI version.
@@ -85,6 +85,8 @@ extension ABI {
     }
 
     return switch versionNumber {
+    case ABI.v6_4.versionNumber...:
+      ABI.v6_4.self
     case ABI.v6_3.versionNumber...:
       ABI.v6_3.self
     case ABI.v0.versionNumber...:
@@ -167,6 +169,18 @@ extension ABI {
     }
   }
 
+  /// A namespace and type for ABI version 6.4 symbols.
+  ///
+  /// @Metadata {
+  ///   @Available(Swift, introduced: 6.4).
+  /// }
+  @_spi(Experimental)
+  public enum v6_4: Sendable, Version {
+    static var versionNumber: VersionNumber {
+      VersionNumber(6, 4)
+    }
+  }
+
   /// A namespace and type representing the ABI version whose symbols are
   /// considered experimental.
   enum ExperimentalVersion: Sendable, Version {

Sources/Testing/ABI/Encoded/ABI.EncodedTest.swift

@@ -1,7 +1,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2024 Apple Inc. and the Swift project authors
+// Copyright (c) 2024-2026 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
@@ -73,10 +73,30 @@ extension ABI {
     /// is `nil`.
     var isParameterized: Bool?
 
+
+    /// An equivalent of ``tags`` that preserved ABIv6.3 support.
+    var _tags: [String]?
+
     /// The tags associated with the test.
     ///
-    /// - Warning: Tags are not yet part of the JSON schema.
-    var _tags: [String]?
+    /// @Metadata {
+    ///   @Available(Swift, introduced: 6.4)
+    /// }
+    var tags: [String]?
+
+    /// The bugs associated with the test.
+    ///
+    /// @Metadata {
+    ///   @Available(Swift, introduced: 6.4)
+    /// }
+    var bugs: [Bug]?
+
+    /// The time limits associated with the test.
+    ///
+    /// @Metadata {
+    ///   @Available(Swift, introduced: 6.4)
+    /// }
+    var timeLimit: Double?
 
     init(encoding test: borrowing Test) {
       if test.isSuite {
@@ -95,11 +115,25 @@ extension ABI {
         if isParameterized == true {
           _testCases = test.uncheckedTestCases?.map(EncodedTestCase.init(encoding:))
         }
-
         let tags = test.tags
         if !tags.isEmpty {
-          _tags = tags.map(String.init(describing:))
+          self._tags = tags.map(String.init(describing:))
+        }
+      }
+
+      if V.versionNumber >= ABI.v6_4.versionNumber {
+        self.tags = test.tags.sorted().map { tag in
+          switch tag.kind {
+            case .staticMember(let value): value
+          }
+        }
+        let bugs = test.associatedBugs
+        if !bugs.isEmpty {
+          self.bugs = bugs
         }
+        self.timeLimit = test.timeLimit
+          .map(TimeValue.init)
+          .map(Double.init)
       }
     }
   }

Tests/TestingTests/EventHandlingInteropTests.swift

@@ -63,7 +63,7 @@ struct EventHandlingInteropTests {
       try Self.handlerContents.withLock {
         let contents = try #require(
           $0, "Fallback should have been called with non nil contents")
-        #expect(contents.version == "6.3")
+        #expect(contents.version == "\(ABI.CurrentVersion.versionNumber)")
         #expect(contents.record?.contains("A system failure occurred") ?? false)
       }
     }

Tests/TestingTests/SwiftPMTests.swift

@@ -367,6 +367,8 @@ struct SwiftPMTests {
           ("--event-stream-output-path", "--event-stream-version", ABI.v0.versionNumber),
           ("--experimental-event-stream-output", "--experimental-event-stream-version", ABI.v0.versionNumber),
           ("--experimental-event-stream-output", "--experimental-event-stream-version", ABI.v6_3.versionNumber),
+          ("--experimental-event-stream-output", "--experimental-event-stream-version", ABI.v6_4.versionNumber),
+          ("--event-stream-output-path", "--event-stream-version", ABI.v6_4.versionNumber),
         ])
   func eventStreamOutput(outputArgumentName: String, versionArgumentName: String, version: VersionNumber) async throws {
     let version = try #require(ABI.version(forVersionNumber: version))
@@ -381,9 +383,19 @@ struct SwiftPMTests {
     defer {
       _ = remove(temporaryFilePath)
     }
+    let testTimeLimit = 3
+    let expectedArgs = ["argument1", "argument2"]
     do {
       let configuration = try configurationForEntryPoint(withArguments: ["PATH", outputArgumentName, temporaryFilePath, versionArgumentName, "\(version.versionNumber)"])
-      let test = Test(.tags(.blue)) {}
+      let test = Test(
+        .tags(.blue),
+        .bug("https://my.defect.com/1234"),
+        .bug("other defect"),
+        .timeLimit(Swift.Duration.seconds(testTimeLimit + 100)),
+        .timeLimit(Swift.Duration.seconds(testTimeLimit)),
+        .timeLimit(Swift.Duration.seconds(testTimeLimit + 10)),
+        arguments: expectedArgs as [String]
+      ) {_ in}
       let eventContext = Event.Context(test: test, testCase: nil, configuration: nil)
 
       configuration.handleEvent(Event(.testDiscovered, testID: test.id, testCaseID: nil), in: eventContext)
@@ -407,10 +419,26 @@ struct SwiftPMTests {
     #expect(testRecords.count == 1)
     for testRecord in testRecords {
       if version.includesExperimentalFields {
+        let actualTestCases = testRecord._testCases
+        let testCases = try #require(actualTestCases)
+        #expect(testCases.count == expectedArgs.count)
         #expect(testRecord._tags != nil)
       } else {
-        #expect(testRecord._tags == nil)
+        #expect(testRecord._testCases == nil)
       }
+
+      if version.versionNumber >= ABI.v6_4.versionNumber {
+        let testTags = try #require(testRecord.tags)
+        #expect(testTags.count >= 1)
+        for tag in testTags {
+          #expect(!tag.starts(with: "."))
+        }
+        let bugs = try #require(testRecord.bugs)
+        #expect(bugs.count == 2)
+        let timeLimit = try #require(testRecord.timeLimit)
+        #expect(timeLimit == Double(testTimeLimit))
+      }
+
     }
     let eventRecords = decodedRecords.compactMap { record in
       if case let .event(event) = record.kind {