Don't use #_sourceLocation in the fallback event handler. (#1609)

We can't use our own macros in the Testing target because they aren't
available when we build the toolchain.

Update the expansion of `#_sourceLocation` to detect it's being used in
one of our own library targets and emit an error.

Resolves rdar://171774246.

### Checklist:

- [x] Code and documentation should follow the style of the [Style
Guide](https://github.com/apple/swift-testing/blob/main/Documentation/StyleGuide.md).
- [x] If public symbols are renamed or modified, DocC references should
be updated.

Author: grynspan

Package.swift

@@ -140,8 +140,8 @@ let package = Package(
         "TestingMacros",
       ],
       exclude: ["CMakeLists.txt", "Testing.swiftcrossimport"],
-      cxxSettings: .packageSettings,
-      swiftSettings: .packageSettings + .enableLibraryEvolution() + .moduleABIName("Testing"),
+      cxxSettings: .packageSettings(),
+      swiftSettings: .packageSettings() + .enableLibraryEvolution() + .moduleABIName("Testing"),
       linkerSettings: [
         .linkedLibrary("execinfo", .when(platforms: [.custom("freebsd"), .openbsd])),
         .linkedLibrary("_TestingInterop"),
@@ -159,7 +159,7 @@ let package = Package(
         "_Testing_WinSDK",
         "MemorySafeTestingTests",
       ],
-      swiftSettings: .packageSettings,
+      swiftSettings: .packageSettings(isTestTarget: true),
       linkerSettings: [
         .linkedLibrary("util", .when(platforms: [.openbsd]))
       ]
@@ -176,7 +176,7 @@ let package = Package(
         "Testing",
       ],
       path: "Tests/_MemorySafeTestingTests",
-      swiftSettings: .packageSettings + [.strictMemorySafety()]
+      swiftSettings: .packageSettings(isTestTarget: true) + [.strictMemorySafety()]
     ),
 
     .macro(
@@ -190,7 +190,7 @@ let package = Package(
         .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
       ],
       exclude: ["CMakeLists.txt"],
-      swiftSettings: .packageSettings + [
+      swiftSettings: .packageSettings() + [
         // The only target which needs the ability to import this macro
         // implementation target's module is its unit test target. Users of the
         // macros this target implements use them via their declarations in the
@@ -206,14 +206,14 @@ let package = Package(
     .target(
       name: "_TestingInternals",
       exclude: ["CMakeLists.txt"],
-      cxxSettings: .packageSettings
+      cxxSettings: .packageSettings()
     ),
     .target(
       name: "_TestDiscovery",
       dependencies: ["_TestingInternals",],
       exclude: ["CMakeLists.txt"],
-      cxxSettings: .packageSettings,
-      swiftSettings: .packageSettings + .enableLibraryEvolution() + .moduleABIName("_TestDiscovery")
+      cxxSettings: .packageSettings(),
+      swiftSettings: .packageSettings() + .enableLibraryEvolution() + .moduleABIName("_TestDiscovery")
     ),
     .target(
       // Build _TestingInterop for debugging/testing purposes only. It is
@@ -222,8 +222,8 @@ let package = Package(
       dependencies: ["_TestingInternals",],
       path: "Sources/_TestingInterop",
       exclude: ["CMakeLists.txt"],
-      cxxSettings: .packageSettings,
-      swiftSettings: .packageSettings + .moduleABIName("_TestingInterop")
+      cxxSettings: .packageSettings(),
+      swiftSettings: .packageSettings() + .moduleABIName("_TestingInterop")
     ),
 
     // Cross-import overlays (not supported by Swift Package Manager)
@@ -235,7 +235,7 @@ let package = Package(
       ],
       path: "Sources/Overlays/_Testing_AppKit",
       exclude: ["CMakeLists.txt"],
-      swiftSettings: .packageSettings + .enableLibraryEvolution() + .moduleABIName("Testing")
+      swiftSettings: .packageSettings() + .enableLibraryEvolution() + .moduleABIName("Testing")
     ),
     .target(
       name: "_Testing_CoreGraphics",
@@ -244,7 +244,7 @@ let package = Package(
       ],
       path: "Sources/Overlays/_Testing_CoreGraphics",
       exclude: ["CMakeLists.txt"],
-      swiftSettings: .packageSettings + .enableLibraryEvolution() + .moduleABIName("_Testing_CoreGraphics")
+      swiftSettings: .packageSettings() + .enableLibraryEvolution() + .moduleABIName("_Testing_CoreGraphics")
     ),
     .target(
       name: "_Testing_CoreImage",
@@ -254,7 +254,7 @@ let package = Package(
       ],
       path: "Sources/Overlays/_Testing_CoreImage",
       exclude: ["CMakeLists.txt"],
-      swiftSettings: .packageSettings + .enableLibraryEvolution() + .moduleABIName("_Testing_CoreImage")
+      swiftSettings: .packageSettings() + .enableLibraryEvolution() + .moduleABIName("_Testing_CoreImage")
     ),
     .target(
       name: "_Testing_Foundation",
@@ -267,7 +267,7 @@ let package = Package(
       // The Foundation module only has Library Evolution enabled on Apple
       // platforms, and since this target's module publicly imports Foundation,
       // it can only enable Library Evolution itself on those platforms.
-      swiftSettings: .packageSettings + .enableLibraryEvolution(.whenApple()) + .moduleABIName("_Testing_Foundation")
+      swiftSettings: .packageSettings() + .enableLibraryEvolution(.whenApple()) + .moduleABIName("_Testing_Foundation")
     ),
     .target(
       name: "_Testing_UIKit",
@@ -278,7 +278,7 @@ let package = Package(
       ],
       path: "Sources/Overlays/_Testing_UIKit",
       exclude: ["CMakeLists.txt"],
-      swiftSettings: .packageSettings + .enableLibraryEvolution() + .moduleABIName("_Testing_UIKit")
+      swiftSettings: .packageSettings() + .enableLibraryEvolution() + .moduleABIName("_Testing_UIKit")
     ),
     .target(
       name: "_Testing_WinSDK",
@@ -287,7 +287,7 @@ let package = Package(
       ],
       path: "Sources/Overlays/_Testing_WinSDK",
       exclude: ["CMakeLists.txt"],
-      swiftSettings: .packageSettings + .enableLibraryEvolution() + .moduleABIName("_Testing_WinSDK")
+      swiftSettings: .packageSettings() + .enableLibraryEvolution() + .moduleABIName("_Testing_WinSDK")
     ),
 
     // Utility targets: These are utilities intended for use when developing
@@ -297,7 +297,7 @@ let package = Package(
       dependencies: [
         "Testing",
       ],
-      swiftSettings: .packageSettings
+      swiftSettings: .packageSettings()
     ),
   ],
 
@@ -313,7 +313,7 @@ package.targets.append(contentsOf: [
       "Testing",
       "TestingMacros",
     ],
-    swiftSettings: .packageSettings
+    swiftSettings: .packageSettings(isTestTarget: true)
   )
 ])
 #endif
@@ -362,7 +362,7 @@ extension BuildSettingCondition {
 extension Array where Element == PackageDescription.SwiftSetting {
   /// Settings intended to be applied to every Swift target in this package.
   /// Analogous to project-level build settings in an Xcode project.
-  static var packageSettings: Self {
+  static func packageSettings(isTestTarget: Bool = false) -> Self {
     var result = availabilityMacroSettings
 
     // treatWarning(..., as: .warning) cannot be used in packages which are
@@ -376,6 +376,14 @@ extension Array where Element == PackageDescription.SwiftSetting {
       result.append(.enableExperimentalFeature("Embedded"))
     }
 
+    // Define a compiler condition so we can discover at macro expansion time if
+    // we're accidentally expanding our own macros in Swift Testing.
+    if !isTestTarget {
+      result += [
+        .define("SWT_BUILDING_SWIFT_TESTING_CONTENT"),
+      ]
+    }
+
     result += [
       .enableUpcomingFeature("ExistentialAny"),
 
@@ -474,9 +482,17 @@ extension Array where Element == PackageDescription.SwiftSetting {
 extension Array where Element == PackageDescription.CXXSetting {
   /// Settings intended to be applied to every C++ target in this package.
   /// Analogous to project-level build settings in an Xcode project.
-  static var packageSettings: Self {
+  static func packageSettings(isTestTarget: Bool = false) -> Self {
     var result = Self()
 
+    // Define a compiler condition so we can discover at macro expansion time if
+    // we're accidentally expanding our own macros in Swift Testing.
+    if !isTestTarget {
+      result += [
+        .define("SWT_BUILDING_SWIFT_TESTING_CONTENT"),
+      ]
+    }
+
     result += [
       .define("SWT_NO_EXIT_TESTS", .whenEmbedded(or: .when(platforms: [.iOS, .watchOS, .tvOS, .visionOS, .wasi, .android]))),
       .define("SWT_NO_PROCESS_SPAWNING", .whenEmbedded(or: .when(platforms: [.iOS, .watchOS, .tvOS, .visionOS, .wasi, .android]))),

Sources/Testing/Events/Event+FallbackEventHandler.swift

@@ -108,22 +108,41 @@ extension Event {
     warnForXCTestUsageIssue.record()
   }
 
+  /// Get the best available source location to use when diagnosing an issue
+  /// decoding a bad record JSON blob.
+  ///
+  /// - Parameters:
+  ///   - recordJSON: The undecodable JSON.
+  ///
+  /// - Returns: A source location to use when reporting an issue about
+  ///   `recordJSON`.
+  private static func _bestAvailableSourceLocation(forInvalidRecordJSON recordJSON: UnsafeRawBufferPointer) -> SourceLocation {
+    // TODO: try to actually extract a source location from arbitrary JSON?
+
+    // If there's a test associated with the current task, it should have a
+    // source location associated with it.
+    if let test = Test.current {
+      return test.sourceLocation
+    }
+
+    return SourceLocation(fileID: "<unknown>/<unknown>", filePath: "<unknown>", line: 1, column: 1)
+  }
+
 #if !SWT_NO_INTEROP
   /// The fallback event handler to install when Swift Testing is the active
   /// testing library.
   private static let _ourFallbackEventHandler: SWTFallbackEventHandler = {
     recordJSONSchemaVersionNumber, recordJSONBaseAddress, recordJSONByteCount, _ in
     let version = String(validatingCString: recordJSONSchemaVersionNumber)
       .flatMap(VersionNumber.init)
-      .flatMap { ABI.version(forVersionNumber: $0) }
-    if let version {
-      let recordJSON = UnsafeRawBufferPointer(
-        start: recordJSONBaseAddress, count: recordJSONByteCount)
-      do {
-        try Self.handle(recordJSON, encodedWith: version)
-      } catch {
-        // Surface otherwise "unhandleable" records instead of dropping them silently
-        let errorContext: Comment = """
+      .flatMap { ABI.version(forVersionNumber: $0) } ?? ABI.v0.self
+    let recordJSON = UnsafeRawBufferPointer(
+      start: recordJSONBaseAddress, count: recordJSONByteCount)
+    do {
+      try Self.handle(recordJSON, encodedWith: version)
+    } catch {
+      // Surface otherwise "unhandleable" records instead of dropping them silently
+      let errorContext: Comment = """
         Another test library reported a test event that Swift Testing could not decode. Inspect the payload to determine if this was a test assertion failure.
 
         Error:
@@ -132,8 +151,19 @@ extension Event {
         Raw payload:
         \(recordJSON)
         """
-        Issue.record(errorContext)
-      }
+
+      // Try to figure out a reasonable source context for this issue.
+      let sourceContext = SourceContext(
+        backtrace: .current(),
+        sourceLocation: _bestAvailableSourceLocation(forInvalidRecordJSON: recordJSON)
+      )
+
+      // Record the issue.
+      Issue(
+        kind: .system,
+        comments: [errorContext],
+        sourceContext: sourceContext
+      ).record()
     }
   }
 #endif

Sources/TestingMacros/SourceLocationMacro.swift

@@ -20,7 +20,8 @@ public struct SourceLocationMacro: ExpressionMacro, Sendable {
     of macro: some FreestandingMacroExpansionSyntax,
     in context: some MacroExpansionContext
   ) throws -> ExprSyntax {
-    createSourceLocationExpr(of: macro, context: context)
+    diagnoseExpansionInLibraryTarget(of: macro, in: context)
+    return createSourceLocationExpr(of: macro, context: context)
   }
 
   public static var formatMode: FormatMode {

Sources/TestingMacros/Support/DiagnosticMessage+Diagnosing.swift

@@ -9,6 +9,7 @@
 //
 
 import SwiftDiagnostics
+import SwiftIfConfig
 import SwiftParser
 import SwiftSyntax
 import SwiftSyntaxBuilder
@@ -314,3 +315,33 @@ func declarationInheritsFromXCTestClass(_ decl: some DeclSyntaxProtocol) -> Bool
   // We couldn't tell either way.
   return nil
 }
+
+// MARK: -
+
+/// Check if the given macro is being expanded in one of the testing library's
+/// production targets.
+///
+/// - Parameters:
+///   - macro: The macro being expanded.
+///   - context: The macro context in which the expression is being parsed.
+///
+/// If `macro` is being expanded in one of our production targets (as opposed to
+/// test targets), a diagnostic is emitted.
+///
+/// This function has no effect in release builds.
+func diagnoseExpansionInLibraryTarget(of macro: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext) {
+#if DEBUG
+  guard let buildConfiguration = context.buildConfiguration,
+        let isBuildingSwiftTestingContent = try? buildConfiguration.isCustomConditionSet(name: "SWT_BUILDING_SWIFT_TESTING_CONTENT"),
+        isBuildingSwiftTestingContent else {
+    return
+  }
+
+  var targetName = "<unknown>"
+  if let fileID = context.location(of: macro, at: .afterLeadingTrivia, filePathMode: .fileID)?.file.trimmedDescription,
+     let slashIndex = fileID.firstIndex(of: "/") {
+    targetName = String(fileID[..<slashIndex])
+  }
+  context.diagnose(.macroExpansionNotAllowed(macro, inLibraryTargetNamed: targetName))
+#endif
+}

Sources/TestingMacros/Support/DiagnosticMessage.swift

@@ -18,6 +18,24 @@ import SwiftSyntaxMacroExpansion
 /// A type describing diagnostic messages emitted by this module's macro during
 /// evaluation.
 struct DiagnosticMessage: SwiftDiagnostics.DiagnosticMessage {
+#if DEBUG
+  /// Create a diagnostic message for the given macro stating it cannot be used
+  /// when building the testing library itself.
+  ///
+  /// - Parameters:
+  ///   - macro: The macro that cannot be used.
+  ///   - targetName: The name of the target being built.
+  ///
+  /// - Returns: A diagnostic message.
+  static func macroExpansionNotAllowed(_ macro: some FreestandingMacroExpansionSyntax, inLibraryTargetNamed targetName: String) -> Self {
+    Self(
+      syntax: Syntax(macro),
+      message: "\(_macroName(macro)) cannot be used within the target '\(targetName)' because it will not be available when building the Swift toolchain",
+      severity: .error
+    )
+  }
+#endif
+
   /// Create a diagnostic message for the macro with the specified name
   /// stating that its condition will always pass or fail.
   ///

Tests/TestingTests/EventHandlingInteropTests.swift

@@ -176,7 +176,7 @@ struct EventHandlingInteropTests {
 
       // Assert that we record an issue with a helpful debug message
       let expectedPrefix =
-        "Issue recorded (error): Another test library reported a test event that Swift Testing could not decode. Inspect the payload to determine if this was a test assertion failure."
+        "A system failure occurred (error): Another test library reported a test event that Swift Testing could not decode. Inspect the payload to determine if this was a test assertion failure."
       let actualMessages = issues.rawValue.map { $0.description }
       #expect(actualMessages.count == 1)
       #expect(

cmake/modules/shared/CompilerSettings.cmake

@@ -23,6 +23,9 @@ add_compile_options(
   "SHELL:$<$<COMPILE_LANGUAGE:Swift>:-Xfrontend -enable-upcoming-feature -Xfrontend MemberImportVisibility>"
   "SHELL:$<$<COMPILE_LANGUAGE:Swift>:-Xfrontend -enable-upcoming-feature -Xfrontend InferIsolatedConformances>")
 
+# We don't build test targets with CMake, so everything is content.
+add_compile_definitions("SWT_BUILDING_SWIFT_TESTING_CONTENT")
+
 # Platform-specific definitions.
 if(APPLE)
   add_compile_definitions("SWT_TARGET_OS_APPLE")