Try to clean up pointers

Author: grynspan

Sources/Testing/Expectations/ExpectationContext.swift

@@ -463,72 +463,9 @@ extension __ExpectationContext {
   ///
   /// - Warning: This function is used to implement the `#expect()` and
   ///   `#require()` macros. Do not call it directly.
-  @_disfavoredOverload
-  public mutating func callAsFunction<P, T>(_ value: P, _ id: __ExpressionID) -> UnsafePointer<T> where P: _Pointer, P.Pointee == T {
-    self(value as P?, id)!
-  }
-
-  /// Convert some pointer to an immutable one and capture information about it
-  /// for use if the expectation currently being evaluated fails.
-  ///
-  /// - Parameters:
-  ///   - value: The pointer to make immutable.
-  ///   - id: A value that uniquely identifies the represented expression in the
-  ///     context of the expectation currently being evaluated.
-  ///
-  /// - Returns: `value`, cast to an immutable pointer.
-  ///
-  /// This overload of `callAsFunction(_:_:)` handles the implicit conversions
-  /// between various pointer types that are normally provided by the compiler.
-  ///
-  /// - Warning: This function is used to implement the `#expect()` and
-  ///   `#require()` macros. Do not call it directly.
-  @_disfavoredOverload
-  public mutating func callAsFunction<P, T>(_ value: P?, _ id: __ExpressionID) -> UnsafePointer<T>? where P: _Pointer, P.Pointee == T {
-    value.flatMap { value in
-      UnsafePointer<T>(bitPattern: Int(bitPattern: self(value, id) as P))
-    }
-  }
-
-  /// Convert some pointer to an immutable one and capture information about it
-  /// for use if the expectation currently being evaluated fails.
-  ///
-  /// - Parameters:
-  ///   - value: The pointer to make immutable.
-  ///   - id: A value that uniquely identifies the represented expression in the
-  ///     context of the expectation currently being evaluated.
-  ///
-  /// - Returns: `value`, cast to an immutable pointer.
-  ///
-  /// This overload of `callAsFunction(_:_:)` handles the implicit conversions
-  /// between various pointer types that are normally provided by the compiler.
-  ///
-  /// - Warning: This function is used to implement the `#expect()` and
-  ///   `#require()` macros. Do not call it directly.
-  @_disfavoredOverload
-  public mutating func callAsFunction<P>(_ value: P, _ id: __ExpressionID) -> UnsafeRawPointer where P: _Pointer {
-    self(value as P?, id)!
-  }
-
-  /// Convert some pointer to an immutable one and capture information about it
-  /// for use if the expectation currently being evaluated fails.
-  ///
-  /// - Parameters:
-  ///   - value: The pointer to make immutable.
-  ///   - id: A value that uniquely identifies the represented expression in the
-  ///     context of the expectation currently being evaluated.
-  ///
-  /// - Returns: `value`, cast to an immutable pointer.
-  ///
-  /// This overload of `callAsFunction(_:_:)` handles the implicit conversions
-  /// between various pointer types that are normally provided by the compiler.
-  ///
-  /// - Warning: This function is used to implement the `#expect()` and
-  ///   `#require()` macros. Do not call it directly.
-  @_disfavoredOverload
-  public mutating func callAsFunction<P>(_ value: P?, _ id: __ExpressionID) -> UnsafeRawPointer? where P: _Pointer {
-    value.flatMap { value in
-      UnsafeRawPointer(bitPattern: Int(bitPattern: self(value, id) as P))
+  public mutating func callAsFunction<P1, P2>(_ value: P1?, _ id: __ExpressionID) -> P2! where P1: _Pointer, P2: _Pointer {
+    self(value as P1?, id).flatMap { value in
+      P2(bitPattern: Int(bitPattern: value))
     }
   }
 }
@@ -550,35 +487,50 @@ extension __ExpectationContext {
   ///   context is destroyed.
   ///
   /// This overload of `callAsFunction(_:_:)` is necessary because Swift allows
-  /// passing string literals directly to functions that take C strings. At
-  /// compile time, the compiler generates code that makes a temporary UTF-8
-  /// copy of the string, then frees that copy on return. That logic does not
-  /// work correctly when strings are passed to intermediate functions such as
-  /// this one, and the compiler will fail to extend the lifetime of the C
-  /// strings to the appropriate point. ([122011759](rdar://122011759))
+  /// passing string literals directly to functions that take C strings. The
+  /// default overload of `callAsFunction(_:_:)` does not trigger this implicit
+  /// cast and causes a compile-time error. ([122011759](rdar://122011759))
   ///
   /// - Warning: This function is used to implement the `#expect()` and
   ///   `#require()` macros. Do not call it directly.
-  public mutating func callAsFunction<P>(_ value: String, _ id: __ExpressionID) -> P where P: _Pointer, P.Pointee == CChar {
+  public mutating func callAsFunction<P>(_ value: String, _ id: __ExpressionID) -> P where P: _Pointer {
     // Perform the normal value capture.
-    let result = self(value, id) as String
+    let value = self(value as String, id)
 
     // Create a C string copy of `value`.
+    let valueCString = value.withCString { value in
 #if os(Windows)
-    let resultCString = _strdup(result)!
+      _strdup(value)
 #else
-    let resultCString = strdup(result)!
+      strdup(value)
 #endif
+    }
+
+    let result = valueCString.flatMap { valueCString in
+      // Store the C string pointer so we can free it later when this context is
+      // torn down.
+      if _transformedCStrings.capacity == 0 {
+        _transformedCStrings.reserveCapacity(2)
+      }
+      _transformedCStrings.append(valueCString)
 
-    // Store the C string pointer so we can free it later when this context is
-    // torn down.
-    if _transformedCStrings.capacity == 0 {
-      _transformedCStrings.reserveCapacity(2)
+      // Return the C string as whatever pointer type the caller wants.
+      return P(bitPattern: Int(bitPattern: valueCString))
     }
-    _transformedCStrings.append(resultCString)
 
-    // Return the C string as whatever pointer type the caller wants.
-    return P(bitPattern: Int(bitPattern: resultCString)).unsafelyUnwrapped
+    return result!
+  }
+
+  /// Capture information about a value for use if the expectation currently
+  /// being evaluated fails.
+  ///
+  /// This overload of `callAsFunction(_:_:)` helps the compiler disambiguate
+  /// optional string values.
+  ///
+  /// - Warning: This function is used to implement the `#expect()` and
+  ///   `#require()` macros. Do not call it directly.
+  public mutating func callAsFunction(_ value: String?, _ id: __ExpressionID) -> String! {
+    self(value as String?, id)
   }
 }
 #endif

Sources/TestingMacros/Support/ConditionArgumentParsing.swift

@@ -735,7 +735,12 @@ func findEffectKeywords(in node: some SyntaxProtocol) -> Set<Keyword> {
 ///
 /// - Returns: A copy of `token` as an identifier token.
 private func _rewriteDollarIdentifier(_ token: TokenSyntax) -> TokenSyntax {
-  .identifier("__renamedCapture__\(token.trimmedDescription)")
+  var result = TokenSyntax.identifier("__renamedCapture__\(token.trimmedDescription)")
+
+  result.leadingTrivia = token.leadingTrivia
+  result.trailingTrivia = token.trailingTrivia
+
+  return result
 }
 
 /// A syntax rewriter that replaces _numeric_ dollar identifiers (e.g. `$0`)

Sources/_TestingInternals/include/TestSupport.h

@@ -37,6 +37,10 @@ static inline bool swt_pointersNotEqual4(const char *a, const char *b, const cha
   return a != b && b != c && c != d;
 }
 
+static inline bool swt_nullableCString(const char *_Nullable string) {
+  return string != 0;
+}
+
 SWT_ASSUME_NONNULL_END
 
 #endif

Tests/SubexpressionShowcase/SubexpressionShowcase.swift

@@ -50,7 +50,7 @@ func subexpressionShowcase() async throws {
   }
 
   let closure: (Int) -> Void = {
-    #expect(($0 + $0 + $0) == 0x10)
+    #expect((($0 + $0 + $0) as Int) == 0x10)
   }
   closure(11)
 
@@ -114,9 +114,4 @@ func subexpressionShowcase() async throws {
 
   let n = 1 as Any
   _ = try #require(n as? String)
-
-  let utf16 = [UTF16.CodeUnit](repeating: 0, count: 16)
-  _ = try utf16.withUnsafeBufferPointer { utf16 in
-    try #require(String.decodeCString(utf16.baseAddress, as: UTF16.self)?.result)
-  }
 }

Tests/TestingTests/Support/CartesianProductTests.swift

@@ -59,8 +59,9 @@ struct CartesianProductTests {
 
     // NOTE: we need to break out the tuple elements because tuples aren't
     // directly equatable.
-    #expect(Array(product).map(\.0) == possibleValues.map(\.0))
-    #expect(Array(product).map(\.1) == possibleValues.map(\.1))
+    let productArray = Array(product)
+    #expect(productArray.map(\.0) == possibleValues.map(\.0))
+    #expect(productArray.map(\.1) == possibleValues.map(\.1))
   }
 
   @Test("Cartesian product with empty first input is empty")

Tests/TestingTests/VariadicGenericTests.swift

@@ -12,14 +12,21 @@ import Testing
 private import _TestingInternals
 
 @Test func variadicCStringArguments() async throws {
-  #expect(0 == strcmp("abc", "abc"))
-  #expect(0 != strcmp("abc", "123"))
-  #expect(swt_pointersNotEqual2("abc", "123"))
-  #expect(swt_pointersNotEqual3("abc", "123", "def"))
-  #expect(swt_pointersNotEqual4("abc", "123", "def", "456"))
+  let abc = "abc"
+  let _123 = "123"
+  let def = "def"
+  let _456 = "456"
+  #expect(0 == strcmp(abc, abc))
+  #expect(0 != strcmp(abc, _123))
+  #expect(swt_pointersNotEqual2(abc, _123))
+  #expect(swt_pointersNotEqual3(abc, _123, def))
+  #expect(swt_pointersNotEqual4(abc, _123, def, _456))
 
-  let lhs = "abc"
-  let rhs = "123"
+  let nilString: String? = nil
+  #expect(swt_nullableCString(nilString) == false)
+
+  let lhs: String? = "abc"
+  let rhs: String? = "123"
   #expect(0 != strcmp(lhs, rhs))
 }
 
@@ -33,3 +40,15 @@ private import _TestingInternals
     #expect(endptr?.pointee == 0)
   }
 }
+
+@Test func utf16PointerConversions() throws {
+  _ = try withUnsafeTemporaryAllocation(of: UTF16.CodeUnit.self, capacity: 1) { buffer in
+    func f(_ p: UnsafeRawPointer?) -> Bool { true }
+    func g(_ p: UnsafeMutableRawPointer?) -> Bool { true }
+    func h(_ p: UnsafeMutablePointer<UTF16.CodeUnit>?) -> Bool { true }
+    #expect(f(buffer.baseAddress))
+    #expect(g(buffer.baseAddress))
+    #expect(h(buffer.baseAddress))
+    return try #require(String.decodeCString(buffer.baseAddress, as: UTF16.self)?.result)
+  }
+}