Ensure tests representing containing types of suite types are synthesized if necessary

Resolves rdar://127770218

Author: stmontgomery

Sources/Testing/Parameterization/TypeInfo.swift

@@ -45,11 +45,33 @@ public struct TypeInfo: Sendable {
     return nil
   }
 
-  init(fullyQualifiedName: String, unqualifiedName: String, mangledName: String?) {
+  /// Initialize an instance of this type with the specified names.
+  ///
+  /// - Parameters:
+  ///   - fullyQualifiedComponents: The fully-qualified name components of the
+  ///     type.
+  ///   - unqualified: The unqualified name of the type.
+  ///   - mangled: The mangled name of the type, if available.
+  init(fullyQualifiedNameComponents: [String], unqualifiedName: String, mangledName: String? = nil) {
     _kind = .nameOnly(
-      fullyQualifiedComponents: fullyQualifiedName.split(separator: ".").map(String.init),
+      fullyQualifiedComponents: fullyQualifiedNameComponents,
       unqualified: unqualifiedName,
-      mangled: mangledName
+      mangled: mangledName,
+    )
+  }
+
+  /// Initialize an instance of this type with the specified names.
+  ///
+  /// - Parameters:
+  ///   - fullyQualifiedName: The fully-qualified name of the type, with its
+  ///     components separated by a period character (`"."`).
+  ///   - unqualified: The unqualified name of the type.
+  ///   - 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),
+      unqualifiedName: unqualifiedName,
+      mangledName: mangledName
     )
   }
 
@@ -246,44 +268,6 @@ func isClass(_ subclass: AnyClass, subclassOf superclass: AnyClass) -> Bool {
   }
 }
 
-// MARK: - Containing types
-
-extension TypeInfo {
-  /// An instance of this type representing the type immediately containing the
-  /// described type.
-  ///
-  /// For instance, given the following declaration in the `Example` module:
-  ///
-  /// ```swift
-  /// struct A {
-  ///   struct B {}
-  /// }
-  /// ```
-  ///
-  /// The value of this property for the type `A.B` would describe `A`, while
-  /// the value for `A` would be `nil` because it has no enclosing type.
-  var containingTypeInfo: Self? {
-    let fqnComponents = fullyQualifiedNameComponents
-    if fqnComponents.count > 2 { // the module is not a type
-      let fqn = fqnComponents.dropLast().joined(separator: ".")
-#if false // currently non-functional
-      if let type = _typeByName(fqn) {
-        return Self(describing: type)
-      }
-#endif
-      let name = fqnComponents[fqnComponents.count - 2]
-      return Self(fullyQualifiedName: fqn, unqualifiedName: name, mangledName: nil)
-    }
-    return nil
-  }
-
-  /// A sequence of instances of this type representing the types that
-  /// recursively contain it, starting with the immediate parent (if any.)
-  var allContainingTypeInfo: some Sequence<Self> {
-    sequence(first: self, next: \.containingTypeInfo).dropFirst()
-  }
-}
-
 // MARK: - CustomStringConvertible, CustomDebugStringConvertible, CustomTestStringConvertible
 
 extension TypeInfo: CustomStringConvertible, CustomDebugStringConvertible {

Sources/Testing/Running/Runner.Plan.swift

@@ -154,6 +154,52 @@ extension Runner.Plan {
     }
   }
 
+  /// Recursively synthesize test instances representing suites for all missing
+  /// values in the specified test graph.
+  ///
+  /// - Parameters:
+  ///   - graph: The graph in which suites should be synthesized.
+  ///   - nameComponents: The name components of the suite to synthesize, based
+  ///     on the key path from the root node of the test graph to `graph`.
+  private static func _recursivelySynthesizeSuites(in graph: inout Graph<String, Test?>, nameComponents: [String] = []) {
+    // The recursive function. This is a local function to simplify the initial
+    // call which does not need to pass the `sourceLocation:` inout argument.
+    func synthesizeSuites(in graph: inout Graph<String, Test?>, nameComponents: [String] = [], sourceLocation: inout SourceLocation?) {
+      for (key, var childGraph) in graph.children {
+        synthesizeSuites(in: &childGraph, nameComponents: nameComponents + [key], sourceLocation: &sourceLocation)
+        graph.children[key] = childGraph
+      }
+
+      if let test = graph.value {
+        sourceLocation = test.sourceLocation
+      } else if let unqualifiedName = nameComponents.last, let sourceLocation {
+        // Don't synthesize suites representing modules.
+        if nameComponents.count <= 1 {
+          return
+        }
+
+        // Don't synthesize suites for nodes in the graph which are the
+        // immediate ancestor of a test function. That level of the hierarchy is
+        // used to disambiguate test functions which have equal names but
+        // different source locations.
+        if let firstChildTest = graph.children.values.first?.value, !firstChildTest.isSuite {
+          return
+        }
+
+        let typeInfo = TypeInfo(fullyQualifiedNameComponents: nameComponents, unqualifiedName: unqualifiedName)
+
+        // Note: When a suite is synthesized, it does not have an accurate
+        // source location, so we use the source location of a close descendant
+        // test. We do this instead of falling back to some "unknown"
+        // placeholder in an attempt to preserve the correct sort ordering.
+        graph.value = Test(traits: [], sourceLocation: sourceLocation, containingTypeInfo: typeInfo)
+      }
+    }
+
+    var sourceLocation: SourceLocation?
+    synthesizeSuites(in: &graph, sourceLocation: &sourceLocation)
+  }
+
   /// Construct a graph of runner plan steps for the specified tests.
   ///
   /// - Parameters:
@@ -198,6 +244,9 @@ extension Runner.Plan {
       // and that is already guarded earlier in the SwiftPM entry point.
     }
 
+    // Synthesize suites for nodes in the test graph for which they are missing.
+    _recursivelySynthesizeSuites(in: &testGraph)
+
     // Recursively apply all recursive suite traits to children.
     //
     // This must be done _before_ calling `prepare(for:)` on the traits below.

Sources/Testing/Test+Discovery.swift

@@ -28,24 +28,7 @@ extension Test {
   /// All available ``Test`` instances in the process, according to the runtime.
   ///
   /// The order of values in this sequence is unspecified.
-  static var all: some Sequence<Test> {
-    get async {
-      // Convert the raw sequence of tests to a dictionary keyed by ID.
-      var result = await testsByID(_all)
-
-      // Ensure test suite types that don't have the @Suite attribute are still
-      // represented in the result.
-      _synthesizeSuiteTypes(into: &result)
-
-      return result.values
-    }
-  }
-
-  /// All available ``Test`` instances in the process, according to the runtime.
-  ///
-  /// The order of values in this sequence is unspecified. This sequence may
-  /// contain duplicates; callers should use ``all`` instead.
-  private static var _all: some Sequence<Self> {
+  static var all: some Sequence<Self> {
     get async {
       await withTaskGroup(of: [Self].self) { taskGroup in
         enumerateTypes(withNamesContaining: _testContainerTypeNameMagic) { _, type, _ in
@@ -60,53 +43,6 @@ extension Test {
       }
     }
   }
-
-  /// Create a dictionary mapping the IDs of a sequence of tests to those tests.
-  ///
-  /// - Parameters:
-  ///   - tests: The sequence to convert to a dictionary.
-  ///
-  /// - Returns: A dictionary containing `tests` keyed by those tests' IDs.
-  static func testsByID(_ tests: some Sequence<Self>) -> [ID: Self] {
-    [ID: Self](
-      tests.lazy.map { ($0.id, $0) },
-      uniquingKeysWith: { existing, _ in existing }
-    )
-  }
-
-  /// Synthesize any missing test suite types (that is, types containing test
-  /// content that do not have the `@Suite` attribute) and add them to a
-  /// dictionary of tests.
-  ///
-  /// - Parameters:
-  ///   - tests: A dictionary of tests to amend.
-  ///
-  /// - Returns: The number of key-value pairs added to `tests`.
-  @discardableResult private static func _synthesizeSuiteTypes(into tests: inout [ID: Self]) -> Int {
-    let originalCount = tests.count
-
-    // Find any instances of Test in the input that are *not* suites. We'll be
-    // checking the containing types of each one.
-    for test in tests.values where !test.isSuite {
-      guard let suiteTypeInfo = test.containingTypeInfo else {
-        continue
-      }
-      let suiteID = ID(typeInfo: suiteTypeInfo)
-      if tests[suiteID] == nil {
-        tests[suiteID] = Test(traits: [], sourceLocation: test.sourceLocation, containingTypeInfo: suiteTypeInfo, isSynthesized: true)
-
-        // Also synthesize any ancestral suites that don't have tests.
-        for ancestralSuiteTypeInfo in suiteTypeInfo.allContainingTypeInfo {
-          let ancestralSuiteID = ID(typeInfo: ancestralSuiteTypeInfo)
-          if tests[ancestralSuiteID] == nil {
-            tests[ancestralSuiteID] = Test(traits: [], sourceLocation: test.sourceLocation, containingTypeInfo: ancestralSuiteTypeInfo, isSynthesized: true)
-          }
-        }
-      }
-    }
-
-    return tests.count - originalCount
-  }
 }
 
 // MARK: -

Sources/Testing/Test.swift

@@ -192,29 +192,18 @@ public struct Test: Sendable {
     containingTypeInfo != nil && testCasesState == nil
   }
 
-  /// Whether or not this instance was synthesized at runtime.
-  ///
-  /// During test planning, suites that are not explicitly marked with the
-  /// `@Suite` attribute are synthesized from available type information before
-  /// being added to the plan. For such suites, the value of this property is
-  /// `true`.
-  @_spi(ForToolsIntegrationOnly)
-  public var isSynthesized = false
-
   /// Initialize an instance of this type representing a test suite type.
   init(
     displayName: String? = nil,
     traits: [any Trait],
     sourceLocation: SourceLocation,
     containingTypeInfo: TypeInfo,
-    isSynthesized: Bool = false
   ) {
     self.name = containingTypeInfo.unqualifiedName
     self.displayName = displayName
     self.traits = traits
     self.sourceLocation = sourceLocation
     self.containingTypeInfo = containingTypeInfo
-    self.isSynthesized = isSynthesized
   }
 
   /// Initialize an instance of this type representing a test function.

Tests/TestingTests/MiscellaneousTests.swift

@@ -552,17 +552,6 @@ struct MiscellaneousTests {
     #expect(id.keyPathRepresentation == [""])
   }
 
-  @Test("Test.all deduping")
-  func allTestDeduping() {
-    let tests = [Test(name: "A") {}, Test(name: "B") {}, Test(name: "C") {}, Test(name: "D") {}, Test(name: "E") {}, Test(name: "F") {}, Test(name: "G") {},]
-    var duplicatedTests = tests
-    duplicatedTests += tests
-    duplicatedTests.shuffle()
-    let mappedTests = Test.testsByID(duplicatedTests)
-    #expect(mappedTests.count == tests.count)
-    #expect(mappedTests.values.allSatisfy { tests.contains($0) })
-  }
-
   @Test("failureBreakpoint() call")
   func failureBreakpointCall() {
     failureBreakpointValue = 1