Use @_rawLayout and ~Copyable to ensure bounds variables don't move.

Author: grynspan

Diff for: Documentation/Porting.md

@@ -136,8 +136,8 @@ emits section information into the resource fork on Classic, you would use the
 to load that information:
 
 ```diff
---- a/Sources/Testing/Discovery+Platform.swift
-+++ b/Sources/Testing/Discovery+Platform.swift
+--- a/Sources/_TestDiscovery/SectionBounds.swift
++++ b/Sources/_TestDiscovery/SectionBounds.swift
 
  // ...
 +#elseif os(Classic)
@@ -209,38 +209,44 @@ start with `"SWT_"`).
 ## Runtime test discovery with static linkage
 
 If your platform does not support dynamic linking and loading, you will need to
-use static linkage instead. Define the `"SWT_NO_DYNAMIC_LINKING"` compiler
-conditional for your platform in both `Package.swift` and
-`CompilerSettings.cmake`, then define the symbols `testContentSectionBegin`,
-`testContentSectionEnd`, `typeMetadataSectionBegin`, and
-`typeMetadataSectionEnd` in `Discovery.cpp`.
+use static linkage instead. To enable static linkage in Swift Testing, add your
+platform to the `BuildSettingCondition.whenStaticallyLinked` definition in
+`Package.swift` and to the `SWT_STATICALLY_LINKED_LIST` definition in
+`CompilerSettings.cmake`, then define the symbols `_testContentSectionBegin`,
+`_testContentSectionEnd`, `_typeMetadataSectionBegin`, and
+`_typeMetadataSectionEnd` in `SectionBounds.swift`:
 
 ```diff
-diff --git a/Sources/_TestingInternals/Discovery.cpp b/Sources/_TestingInternals/Discovery.cpp
+--- a/Sources/_TestDiscovery/SectionBounds.swift
++++ b/Sources/_TestDiscovery/SectionBounds.swift
  // ...
-+#elif defined(macintosh)
-+extern "C" const char testContentSectionBegin __asm__("...");
-+extern "C" const char testContentSectionEnd __asm__("...");
-+#if !defined(SWT_NO_LEGACY_TEST_DISCOVERY)
-+extern "C" const char typeMetadataSectionBegin __asm__("...");
-+extern "C" const char typeMetadataSectionEnd __asm__("...");
++#elseif os(Classic)
++@_silgen_name(raw: "...") private let _testContentSectionBegin: _SectionBound
++@_silgen_name(raw: "...") private let _testContentSectionEnd: _SectionBound
++#if !SWT_NO_LEGACY_TEST_DISCOVERY
++@_silgen_name(raw: "...") private let _typeMetadataSectionBegin: _SectionBound
++@_silgen_name(raw: "...") private let _typeMetadataSectionEnd: _SectionBound
 +#endif
  #else
- #warning Platform-specific implementation missing: Runtime test discovery unavailable (static)
- static const char testContentSectionBegin = 0;
- static const char& testContentSectionEnd = testContentSectionBegin;
- #if !defined(SWT_NO_LEGACY_TEST_DISCOVERY)
- static const char typeMetadataSectionBegin = 0;
- static const char& typeMetadataSectionEnd = typeMetadataSectionBegin;
- #endif
+ #warning("Platform-specific implementation missing: Runtime test discovery unavailable (static)")
+ private let _testContentSectionBegin = _SectionBound()
+ private var _testContentSectionEnd: _SectionBound { ... }
+ #if !SWT_NO_LEGACY_TEST_DISCOVERY
+ private let _typeMetadataSectionBegin = _SectionBound()
+ private var _typeMetadataSectionEnd: _SectionBound { ... }
  #endif
+ // ...
 ```
 
 These symbols must have unique addresses corresponding to the first byte of the
 test content section and the first byte _after_ the test content section,
 respectively. Their linker-level names will be platform-dependent: refer to the
 linker documentation for your platform to determine what names to place in the
-`__asm__` attribute applied to each.
+`@_silgen_name` attribute applied to each.
+
+If your target platform statically links Swift Testing but the linker does not
+provide section bounds symbols for it, please reach out to us in the Swift
+forums for advice.
 
 ## C++ stub implementations
 
@@ -332,7 +338,7 @@ to include the necessary linker flags.
 ## Adding CI jobs for the new platform
 
 The Swift project maintains a set of CI jobs that target various platforms. To
-add CI jobs for Swift Testing or the Swift toolchain, please contain the CI
+add CI jobs for Swift Testing or the Swift toolchain, please contact the CI
 maintainers on the Swift forums.
 
 If you wish to host your own CI jobs, let us know: we'd be happy to run them as

Diff for: Package.swift

@@ -185,6 +185,18 @@ package.targets.append(contentsOf: [
 ])
 #endif
 
+extension BuildSettingCondition {
+  /// A build setting condition matching all Apple platforms.
+  static var whenApple: Self {
+    .when(platforms: [.macOS, .iOS, .macCatalyst, .watchOS, .tvOS, .visionOS])
+  }
+
+  /// A build setting condition matching platforms that use static linkage.
+  static var whenStaticallyLinked: Self {
+    .when(platforms: [.wasi])
+  }
+}
+
 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.
@@ -208,17 +220,18 @@ extension Array where Element == PackageDescription.SwiftSetting {
       // (via CMake). Enabling it is dependent on acceptance of the @section
       // proposal via Swift Evolution.
       .enableExperimentalFeature("SymbolLinkageMarkers"),
+      .enableExperimentalFeature("RawLayout", .whenStaticallyLinked),
 
       // When building as a package, the macro plugin always builds as an
       // executable rather than a library.
       .define("SWT_NO_LIBRARY_MACRO_PLUGINS"),
 
-      .define("SWT_TARGET_OS_APPLE", .when(platforms: [.macOS, .iOS, .macCatalyst, .watchOS, .tvOS, .visionOS])),
+      .define("SWT_TARGET_OS_APPLE", .whenApple),
 
       .define("SWT_NO_EXIT_TESTS", .when(platforms: [.iOS, .watchOS, .tvOS, .visionOS, .wasi, .android])),
       .define("SWT_NO_PROCESS_SPAWNING", .when(platforms: [.iOS, .watchOS, .tvOS, .visionOS, .wasi, .android])),
       .define("SWT_NO_SNAPSHOT_TYPES", .when(platforms: [.linux, .custom("freebsd"), .openbsd, .windows, .wasi, .android])),
-      .define("SWT_NO_DYNAMIC_LINKING", .when(platforms: [.wasi])),
+      .define("SWT_NO_DYNAMIC_LINKING", .whenStaticallyLinked),
       .define("SWT_NO_PIPES", .when(platforms: [.wasi])),
     ]
 
@@ -256,7 +269,7 @@ extension Array where Element == PackageDescription.SwiftSetting {
     if buildingForDevelopment {
       var condition: BuildSettingCondition?
       if applePlatformsOnly {
-        condition = .when(platforms: [.macOS, .iOS, .macCatalyst, .watchOS, .tvOS, .visionOS])
+        condition = .whenApple
       }
       result.append(.unsafeFlags(["-enable-library-evolution"], condition))
     }
@@ -275,7 +288,7 @@ extension Array where Element == PackageDescription.CXXSetting {
       .define("SWT_NO_EXIT_TESTS", .when(platforms: [.iOS, .watchOS, .tvOS, .visionOS, .wasi, .android])),
       .define("SWT_NO_PROCESS_SPAWNING", .when(platforms: [.iOS, .watchOS, .tvOS, .visionOS, .wasi, .android])),
       .define("SWT_NO_SNAPSHOT_TYPES", .when(platforms: [.linux, .custom("freebsd"), .openbsd, .windows, .wasi, .android])),
-      .define("SWT_NO_DYNAMIC_LINKING", .when(platforms: [.wasi])),
+      .define("SWT_NO_DYNAMIC_LINKING", .whenStaticallyLinked),
       .define("SWT_NO_PIPES", .when(platforms: [.wasi])),
     ]
 

Diff for: Sources/_TestDiscovery/SectionBounds.swift

@@ -23,7 +23,7 @@ struct SectionBounds: Sendable {
 
   /// An enumeration describing the different sections discoverable by the
   /// testing library.
-  enum Kind: Int, Equatable, Hashable, CaseIterable {
+  enum Kind: Equatable, Hashable, CaseIterable {
     /// The test content metadata section.
     case testContent
 
@@ -297,14 +297,57 @@ private func _sectionBounds(_ kind: SectionBounds.Kind) -> some Sequence<Section
 ///   - kind: Ignored.
 ///
 /// - Returns: The empty array.
-private func _sectionBounds(_ kind: SectionBounds.Kind) -> [SectionBounds] {
+private func _sectionBounds(_ kind: SectionBounds.Kind) -> EmptyCollection<SectionBounds> {
   #warning("Platform-specific implementation missing: Runtime test discovery unavailable (dynamic)")
-  return []
+  return EmptyCollection()
 }
 #endif
 #else
 // MARK: - Statically-linked implementation
 
+/// A type representing the upper or lower bound of a metadata section.
+///
+/// This type uses the experimental `@_rawLayout` attribute to ensure that
+/// instances have fixed addresses. Use the `unsafeAddress` property to get the
+/// address of an instance of this type.
+///
+/// On platforms that use static linkage and have well-defined bounds symbols,
+/// those symbols are imported into Swift below using `@_silgen_name`, another
+/// experimental attribute.
+@_rawLayout(like: CChar) private struct _SectionBound: @unchecked Sendable, ~Copyable {
+  static func ..<(lhs: borrowing Self, rhs: borrowing Self) -> UnsafeRawBufferPointer {
+    withUnsafePointer(to: lhs) { lhs in
+      withUnsafePointer(to: rhs) { rhs in
+        UnsafeRawBufferPointer(start: lhs, count: UnsafeRawPointer(rhs) - UnsafeRawPointer(lhs))
+      }
+    }
+  }
+}
+
+#if SWT_TARGET_OS_APPLE
+@_silgen_name(raw: "section$start$__DATA_CONST$__swift5_tests") private let _testContentSectionBegin: _SectionBound
+@_silgen_name(raw: "section$end$__DATA_CONST$__swift5_tests") private let _testContentSectionEnd: _SectionBound
+#if !SWT_NO_LEGACY_TEST_DISCOVERY
+@_silgen_name(raw: "section$start$__TEXT$__swift5_types") private let _typeMetadataSectionBegin: _SectionBound
+@_silgen_name(raw: "section$end$__TEXT$__swift5_types") private let _typeMetadataSectionEnd: _SectionBound
+#endif
+#elseif os(WASI)
+@_silgen_name(raw: "__start_swift5_tests") private let _testContentSectionBegin: _SectionBound
+@_silgen_name(raw: "__stop_swift5_tests") private let _testContentSectionEnd: _SectionBound
+#if !SWT_NO_LEGACY_TEST_DISCOVERY
+@_silgen_name(raw: "__start_swift5_type_metadata") private let _typeMetadataSectionBegin: _SectionBound
+@_silgen_name(raw: "__stop_swift5_type_metadata") private let _typeMetadataSectionEnd: _SectionBound
+#endif
+#else
+#warning("Platform-specific implementation missing: Runtime test discovery unavailable (static)")
+private let _testContentSectionBegin = _SectionBound()
+private var _testContentSectionEnd: _SectionBound { _read { yield _testContentSectionBegin } }
+#if !SWT_NO_LEGACY_TEST_DISCOVERY
+private let _typeMetadataSectionBegin = _SectionBound()
+private var _typeMetadataSectionEnd: _SectionBound { _read { yield _typeMetadataSectionBegin } }
+#endif
+#endif
+
 /// The common implementation of ``SectionBounds/all(_:)`` for platforms that do
 /// not support dynamic linking.
 ///
@@ -314,9 +357,12 @@ private func _sectionBounds(_ kind: SectionBounds.Kind) -> [SectionBounds] {
 /// - Returns: A structure describing the bounds of the type metadata section
 ///   contained in the same image as the testing library itself.
 private func _sectionBounds(_ kind: SectionBounds.Kind) -> CollectionOfOne<SectionBounds> {
-  var (baseAddress, count): (UnsafeRawPointer?, Int) = (nil, 0)
-  swt_getStaticallyLinkedSectionBounds(kind.rawValue, &baseAddress, &count)
-  let buffer = UnsafeRawBufferPointer(start: baseAddress, count: count)
+  let buffer = switch kind {
+  case .testContent:
+    _testContentSectionBegin ..< _testContentSectionEnd
+  case .typeMetadata:
+    _typeMetadataSectionBegin ..< _typeMetadataSectionEnd
+  }
   let sb = SectionBounds(imageAddress: nil, buffer: buffer)
   return CollectionOfOne(sb)
 }

Diff for: Sources/_TestDiscovery/TestContentRecord.swift

@@ -276,7 +276,8 @@ extension DiscoverableAsTestContent where Self: ~Copyable {
     }
 
     let result = SectionBounds.all(.typeMetadata).lazy.flatMap { sb in
-      stride(from: sb.buffer.baseAddress!, to: sb.buffer.baseAddress! + sb.buffer.count, by: SWTTypeMetadataRecordByteCount).lazy
+      stride(from: 0, to: sb.buffer.count, by: SWTTypeMetadataRecordByteCount).lazy
+        .map { sb.buffer.baseAddress! + $0 }
         .compactMap { swt_getType(fromTypeMetadataRecord: $0, ifNameContains: typeNameHint) }
         .map { unsafeBitCast($0, to: Any.Type.self) }
         .compactMap(loader)

Diff for: Sources/_TestingInternals/Discovery.cpp

@@ -1,7 +1,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2023 Apple Inc. and the Swift project authors
+// Copyright (c) 2023–2025 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
@@ -10,54 +10,12 @@
 
 #include "Discovery.h"
 
-#include <algorithm>
 #if !defined(SWT_NO_LEGACY_TEST_DISCOVERY)
 #include <cstdint>
 #include <cstring>
 #include <type_traits>
 #endif
 
-#if defined(SWT_NO_DYNAMIC_LINKING)
-#pragma mark - Statically-linked section bounds
-
-#if defined(__APPLE__)
-extern "C" const char testContentSectionBegin __asm("section$start$__DATA_CONST$__swift5_tests");
-extern "C" const char testContentSectionEnd __asm("section$end$__DATA_CONST$__swift5_tests");
-#if !defined(SWT_NO_LEGACY_TEST_DISCOVERY)
-extern "C" const char typeMetadataSectionBegin __asm__("section$start$__TEXT$__swift5_types");
-extern "C" const char typeMetadataSectionEnd __asm__("section$end$__TEXT$__swift5_types");
-#endif
-#elif defined(__wasi__)
-extern "C" const char testContentSectionBegin __asm__("__start_swift5_tests");
-extern "C" const char testContentSectionEnd __asm__("__stop_swift5_tests");
-#if !defined(SWT_NO_LEGACY_TEST_DISCOVERY)
-extern "C" const char typeMetadataSectionBegin __asm__("__start_swift5_type_metadata");
-extern "C" const char typeMetadataSectionEnd __asm__("__stop_swift5_type_metadata");
-#endif
-#else
-#warning Platform-specific implementation missing: Runtime test discovery unavailable (static)
-static const char testContentSectionBegin = 0;
-static const char& testContentSectionEnd = testContentSectionBegin;
-#if !defined(SWT_NO_LEGACY_TEST_DISCOVERY)
-static const char typeMetadataSectionBegin = 0;
-static const char& typeMetadataSectionEnd = typeMetadataSectionBegin;
-#endif
-#endif
-
-static constexpr const char *const staticallyLinkedSectionBounds[][2] = {
-  { &testContentSectionBegin, &testContentSectionEnd },
-#if !defined(SWT_NO_LEGACY_TEST_DISCOVERY)
-  { &typeMetadataSectionBegin, &typeMetadataSectionEnd },
-#endif
-};
-
-void swt_getStaticallyLinkedSectionBounds(size_t kind, const void **outSectionBegin, size_t *outByteCount) {
-  auto [sectionBegin, sectionEnd] = staticallyLinkedSectionBounds[kind];
-  *outSectionBegin = sectionBegin;
-  *outByteCount = std::distance(sectionBegin, sectionEnd);
-}
-#endif
-
 #if !defined(SWT_NO_LEGACY_TEST_DISCOVERY)
 #pragma mark - Swift ABI
 

Diff for: Sources/_TestingInternals/include/Discovery.h

@@ -1,7 +1,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2023 Apple Inc. and the Swift project authors
+// Copyright (c) 2023–2025 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
@@ -30,21 +30,6 @@ SWT_IMPORT_FROM_STDLIB void swift_enumerateAllMetadataSections(
 );
 #endif
 
-#pragma mark - Statically-linked section bounds
-
-/// Get the bounds of a statically linked section in this image.
-///
-/// - Parameters:
-///   - kind: The value of `SectionBounds.Kind.rawValue` for the given section.
-///   - outSectionBegin: On return, a pointer to the first byte of the section.
-///   - outByteCount: On return, the number of bytes in the section.
-///
-/// - Note: This symbol is _declared_, but not _defined_, on platforms with
-///   dynamic linking because the `SWT_NO_DYNAMIC_LINKING` C++ macro (not the
-///   Swift compiler conditional of the same name) is not consistently declared
-///   when Swift files import the `_TestingInternals` C++ module.
-SWT_EXTERN void swt_getStaticallyLinkedSectionBounds(size_t kind, const void *_Nullable *_Nonnull outSectionBegin, size_t *outByteCount);
-
 #pragma mark - Legacy test discovery
 
 /// The size, in bytes, of a Swift type metadata record.

Diff for: cmake/modules/shared/CompilerSettings.cmake

@@ -36,6 +36,12 @@ if(NOT APPLE)
   add_compile_definitions("SWT_NO_SNAPSHOT_TYPES")
 endif()
 if(CMAKE_SYSTEM_NAME STREQUAL "WASI")
-  add_compile_definitions("SWT_NO_DYNAMIC_LINKING")
   add_compile_definitions("SWT_NO_PIPES")
 endif()
+
+set(SWT_STATICALLY_LINKED_LIST "WASI")
+if(CMAKE_SYSTEM_NAME IN_LIST SWT_STATICALLY_LINKED_LIST)
+  add_compile_definitions("SWT_NO_DYNAMIC_LINKING")
+  add_compile_options(
+    "SHELL:$<$<COMPILE_LANGUAGE:Swift>:-Xfrontend -enable-experimental-feature -Xfrontend RawLayout>")
+endif()