Add inout arg support

Author: grynspan

Sources/Testing/Expectations/ExpectationContext.swift

@@ -198,6 +198,20 @@ extension __ExpectationContext {
     return value
   }
 #endif
+
+  /// Capture information about a value passed `inout` to a function call after
+  /// the function has returned.
+  ///
+  /// - Parameters:
+  ///   - value: The value that was passed `inout` (i.e. with the `&` operator.)
+  ///   - id: A value that uniquely identifies the represented expression in the
+  ///     context of the expectation currently being evaluated.
+  ///
+  /// - Warning: This function is used to implement the `#expect()` and
+  ///   `#require()` macros. Do not call it directly.
+  public mutating func __inoutAfter<T>(_ value: T, _ id: __ExpressionID) {
+    runtimeValues[id] = { Expression.Value(reflecting: value, timing: .after) }
+  }
 }
 
 // MARK: - Collection comparison and diffing

Sources/Testing/SourceAttribution/Expression.swift

@@ -69,6 +69,21 @@ public struct __Expression: Sendable {
     /// Information about the type of this value.
     public var typeInfo: TypeInfo
 
+    /// The timing when a runtime value was captured.
+    @_spi(Experimental)
+    public enum Timing: String, Sendable {
+      /// The value was captured after the containing expression was evaluated.
+      case after
+    }
+
+    /// When the value represented by this instance was captured.
+    ///
+    /// The value of this property is typically `nil`. It may be set to a
+    /// non-`nil` value if this instance represents some `inout` argument passed
+    /// to a function with the `&` operator.
+    @_spi(Experimental)
+    public var timing: Timing?
+
     /// The label associated with this value, if any.
     ///
     /// For non-child instances, or for child instances of members who do not
@@ -92,9 +107,10 @@ public struct __Expression: Sendable {
     ///
     /// - Parameters:
     ///   - subject: The subject this instance should describe.
-    init(reflecting subject: Any) {
+    ///   - timing: When the value represented by this instance was captured.
+    init(reflecting subject: Any, timing: Timing? = nil) {
       var seenObjects: [ObjectIdentifier: AnyObject] = [:]
-      self.init(_reflecting: subject, label: nil, seenObjects: &seenObjects)
+      self.init(_reflecting: subject, label: nil, timing: timing, seenObjects: &seenObjects)
     }
 
     /// Initialize an instance of this type describing the specified subject and
@@ -105,13 +121,15 @@ public struct __Expression: Sendable {
     ///   - label: An optional label for this value. This should be a non-`nil`
     ///     value when creating instances of this type which describe
     ///     substructural values.
+    ///   - timing: When the value represented by this instance was captured.
     ///   - seenObjects: The objects which have been seen so far while calling
     ///     this initializer recursively, keyed by their object identifiers.
     ///     This is used to halt further recursion if a previously-seen object
     ///     is encountered again.
     private init(
       _reflecting subject: Any,
       label: String?,
+      timing: Timing?,
       seenObjects: inout [ObjectIdentifier: AnyObject]
     ) {
       let mirror = Mirror(reflecting: subject)
@@ -160,6 +178,7 @@ public struct __Expression: Sendable {
       debugDescription = String(reflecting: subject)
       typeInfo = TypeInfo(describingTypeOf: subject)
       self.label = label
+      self.timing = timing
 
       isCollection = switch mirror.displayStyle {
       case .some(.collection),
@@ -172,7 +191,7 @@ public struct __Expression: Sendable {
 
       if shouldIncludeChildren && (!mirror.children.isEmpty || isCollection) {
         self.children = mirror.children.map { child in
-          Self(_reflecting: child.value, label: child.label, seenObjects: &seenObjects)
+          Self(_reflecting: child.value, label: child.label, timing: timing, seenObjects: &seenObjects)
         }
       }
     }
@@ -227,12 +246,19 @@ public struct __Expression: Sendable {
       let runtimeValueDescription = String(describingForTest: runtimeValue)
       // Hack: don't print string representations of function calls.
       if runtimeValueDescription != "(Function)" && runtimeValueDescription != result {
+        switch runtimeValue.timing {
+        case .after:
+          result = "\(result) (after)"
+        default:
+          break
+        }
         result = "\(result) → \(runtimeValueDescription)"
       }
     } else {
       result = "\(result) → <not evaluated>"
     }
 
+
     return result
   }
 
@@ -264,6 +290,7 @@ public struct __Expression: Sendable {
 extension __Expression: Codable {}
 extension __Expression.Kind: Codable {}
 extension __Expression.Value: Codable {}
+extension __Expression.Value.Timing: Codable {}
 
 // MARK: - CustomStringConvertible, CustomDebugStringConvertible
 

Sources/TestingMacros/ConditionMacro.swift

@@ -169,7 +169,7 @@ extension ConditionMacro {
             let uniqueName = context.makeUniqueName("")
             expressionContextName = .identifier("\(expressionContextName)\(uniqueName)")
           }
-          let (rewrittenArgumentExpr, rewrittenNodes) = insertCalls(
+          let (rewrittenArgumentExpr, rewrittenNodes, prefixCodeBlockItems) = insertCalls(
             toExpressionContextNamed: expressionContextName,
             into: originalArgumentExpr,
             for: macro,
@@ -195,11 +195,20 @@ extension ConditionMacro {
             argumentExpr = closureArguments.rewrittenNode.cast(ExprSyntax.self)
           }
 
+          // If we're inserting any additional code into the closure before the
+          // rewritten argument, we can't elide the return keyword for brevity.
+          var returnKeyword: TokenSyntax?
+          if !prefixCodeBlockItems.isEmpty {
+            returnKeyword = .keyword(.return)
+              .with(\.leadingTrivia, argumentExpr.leadingTrivia)
+            argumentExpr.leadingTrivia = .space
+          }
+
           // Enclose the expression in a closure into which we pass our local
           // context object.
           argumentExpr = """
           { \(closureArguments?.captureList) (\(expressionContextName): inout Testing.__ExpectationContext) in
-            \(argumentExpr)
+            \(prefixCodeBlockItems)\(returnKeyword)\(argumentExpr)
           }
           """
 

Sources/TestingMacros/Support/ConditionArgumentParsing.swift

@@ -111,6 +111,10 @@ private final class _ContextInserter<C, M>: SyntaxRewriter where C: MacroExpansi
   /// The nodes in this array are the _original_ nodes, not the rewritten nodes.
   var rewrittenNodes = Set<Syntax>()
 
+  /// Any postflight code the caller should insert into the closure containing
+  /// the rewritten syntax tree.
+  var teardownItems = [CodeBlockItemSyntax]()
+
   init(in context: C, for macro: M, rootedAt effectiveRootNode: Syntax, expressionContextName: TokenSyntax) {
     self.context = context
     self.macro = macro
@@ -123,12 +127,13 @@ private final class _ContextInserter<C, M>: SyntaxRewriter where C: MacroExpansi
   /// (or rather, its `callAsFunction(_:_:)` member).
   ///
   /// - Parameters:
-  ///   - functionNameExpr: If not `nil`, the name of the function to call (as a
-  ///     member of the expression context.)
   ///   - node: The node to rewrite.
   ///   - originalNode: The original node in the original syntax tree, if `node`
   ///     has already been partially rewritten or substituted. If `node` has not
   ///     been rewritten, this argument should equal it.
+  ///   - functionName: If not `nil`, the name of the function to call (as a
+  ///     member function of the expression context.)
+  ///   - additionalArguments: Any additional arguments to pass to the function.
   ///
   /// - Returns: A rewritten copy of `node` that calls into the expression
   ///   context when it is evaluated at runtime.
@@ -379,8 +384,24 @@ private final class _ContextInserter<C, M>: SyntaxRewriter where C: MacroExpansi
   }
 
   override func visit(_ node: InOutExprSyntax) -> ExprSyntax {
-    // inout arguments cannot be forwarded through functions. In the future, we
-    // could experiment with unsafe mutable pointers?
+    // Swift's Law of Exclusivity means that only one subexpression in the
+    // expectation ought to be interacting with `value` when it is passed
+    // `inout`, so it should be sufficient to capture it in a `defer` statement
+    // that runs after the expression is evaluated.
+
+    let teardownItem = CodeBlockItemSyntax(
+      item: .expr(
+        _rewrite(
+          node.expression,
+          originalWas: node,
+          calling: .identifier("__inoutAfter")
+        )
+      )
+    )
+    teardownItems.append(teardownItem)
+
+    // The argument should not be expanded in-place as we can't return an
+    // argument passed `inout` and expect it to remain semantically correct.
     return ExprSyntax(node)
   }
 
@@ -525,23 +546,42 @@ private final class _ContextInserter<C, M>: SyntaxRewriter where C: MacroExpansi
 ///     the purposes of generating expression ID values.
 ///   - context: The macro context in which the expression is being parsed.
 ///
-/// - Returns: A tuple containing the rewritten copy of `node` as well as a list
-///   of all the nodes within `node` (possibly including `node` itself) that
-///   were rewritten.
+/// - Returns: A tuple containing the rewritten copy of `node`, a list of all
+///   the nodes within `node` (possibly including `node` itself) that were
+///   rewritten, and a code block containing code that should be inserted into
+///   the lexical scope of `node` _before_ its rewritten equivalent.
 func insertCalls(
   toExpressionContextNamed expressionContextName: TokenSyntax,
   into node: some SyntaxProtocol,
   for macro: some FreestandingMacroExpansionSyntax,
   rootedAt effectiveRootNode: some SyntaxProtocol,
   in context: some MacroExpansionContext
-) -> (Syntax, rewrittenNodes: Set<Syntax>) {
+) -> (Syntax, rewrittenNodes: Set<Syntax>, prefixCodeBlockItems: CodeBlockItemListSyntax) {
   if let node = node.as(ExprSyntax.self) {
     _diagnoseTrivialBooleanValue(from: node, for: macro, in: context)
   }
 
   let contextInserter = _ContextInserter(in: context, for: macro, rootedAt: Syntax(effectiveRootNode), expressionContextName: expressionContextName)
   let result = contextInserter.rewrite(node)
-  return (result, contextInserter.rewrittenNodes)
+  let rewrittenNodes = contextInserter.rewrittenNodes
+
+  let prefixCodeBlockItems = CodeBlockItemListSyntax {
+    if !contextInserter.teardownItems.isEmpty {
+      CodeBlockItemSyntax(
+        item: .stmt(
+          StmtSyntax(
+            DeferStmtSyntax {
+              for teardownItem in contextInserter.teardownItems {
+                teardownItem
+              }
+            }
+          )
+        )
+      )
+    }
+  }.formatted().with(\.trailingTrivia, .newline).cast(CodeBlockItemListSyntax.self)
+
+  return (result, rewrittenNodes, prefixCodeBlockItems)
 }
 
 // MARK: - Finding optional chains

Tests/SubexpressionShowcase/SubexpressionShowcase.swift

@@ -20,6 +20,11 @@ func g() throws -> Int {
   22
 }
 
+func io(_ x: inout Int) -> Int {
+  x += 1
+  return x + 1
+}
+
 struct T {
   func h(_ i: Int) -> Bool { false }
   static func j(_ d: Double) -> Bool { false }
@@ -39,6 +44,12 @@ func subexpressionShowcase() async throws {
   #expect((123, 456) == (789, 0x12))
   #expect((try g() > 500) && true)
 
+  do {
+    let n = Int.random(in: 0 ..< 100)
+    var m = n
+    #expect(io(&m) == n)
+  }
+
   let closure: (Int) -> Void = {
     #expect($0 == 0x10)
   }