Tweaks to how we generate the capturing function calls

Author: grynspan

Sources/Testing/Expectations/ExpectationContext.swift

@@ -269,12 +269,12 @@ extension __ExpectationContext {
   /// - Warning: This function is used to implement the `#expect()` and
   ///   `#require()` macros. Do not call it directly.
   public mutating func __cmp<T, U, R>(
+    _ op: (T, U) throws -> R,
+    _ opID: __ExpressionID,
     _ lhs: T,
     _ lhsID: __ExpressionID,
     _ rhs: U,
-    _ rhsID: __ExpressionID,
-    _ op: (T, U) throws -> R,
-    _ opID: __ExpressionID
+    _ rhsID: __ExpressionID
   ) rethrows -> R {
     try self(op(self(lhs, lhsID), self(rhs, rhsID)), opID)
   }
@@ -287,12 +287,12 @@ extension __ExpectationContext {
   /// - Warning: This function is used to implement the `#expect()` and
   ///   `#require()` macros. Do not call it directly.
   public mutating func __cmp<C>(
+    _ op: (C, C) -> Bool,
+    _ opID: __ExpressionID,
     _ lhs: C,
     _ lhsID: __ExpressionID,
     _ rhs: C,
-    _ rhsID: __ExpressionID,
-    _ op: (C, C) -> Bool,
-    _ opID: __ExpressionID
+    _ rhsID: __ExpressionID
   ) -> Bool where C: BidirectionalCollection, C.Element: Equatable {
     let result = self(op(self(lhs, lhsID), self(rhs, rhsID)), opID)
 
@@ -309,17 +309,17 @@ extension __ExpectationContext {
   ///
   /// This overload of `__cmp()` does _not_ perform a diffing operation on `lhs`
   /// and `rhs`. Range expressions are not usefully diffable the way other kinds
-  /// of collections are. ([139222774](rdar://139222774))
+  /// of collections are. ([#639](https://github.com/swiftlang/swift-testing/issues/639))
   ///
   /// - Warning: This function is used to implement the `#expect()` and
   ///   `#require()` macros. Do not call it directly.
   public mutating func __cmp<R>(
+    _ op: (R, R) -> Bool,
+    _ opID: __ExpressionID,
     _ lhs: R,
     _ lhsID: __ExpressionID,
     _ rhs: R,
-    _ rhsID: __ExpressionID,
-    _ op: (R, R) -> Bool,
-    _ opID: __ExpressionID
+    _ rhsID: __ExpressionID
   ) -> Bool where R: RangeExpression & BidirectionalCollection, R.Element: Equatable {
     self(op(self(lhs, lhsID), self(rhs, rhsID)), opID)
   }
@@ -333,12 +333,12 @@ extension __ExpectationContext {
   /// - Warning: This function is used to implement the `#expect()` and
   ///   `#require()` macros. Do not call it directly.
   public mutating func __cmp<S>(
+    _ op: (S, S) -> Bool,
+    _ opID: __ExpressionID,
     _ lhs: S,
     _ lhsID: __ExpressionID,
     _ rhs: S,
-    _ rhsID: __ExpressionID,
-    _ op: (S, S) -> Bool,
-    _ opID: __ExpressionID
+    _ rhsID: __ExpressionID
   ) -> Bool where S: StringProtocol {
     let result = self(op(self(lhs, lhsID), self(rhs, rhsID)), opID)
 
@@ -376,9 +376,11 @@ extension __ExpectationContext {
   ///
   /// - Parameters:
   ///   - value: The value to cast.
+  ///   - valueID: A value that uniquely identifies the expression represented
+  ///     by `value` in the context of the expectation being evaluated.
   ///   - type: The type to cast `value` to.
-  ///   - typeID: The ID chain of the `type` expression as emitted during
-  ///     expansion of the `#expect()` or `#require()` macro.
+  ///   - valueID: A value that uniquely identifies the expression represented
+  ///     by `type` in the context of the expectation being evaluated.
   ///
   /// - Returns: The result of the expression `value as? type`.
   ///
@@ -388,12 +390,12 @@ extension __ExpectationContext {
   ///
   /// - Warning: This function is used to implement the `#expect()` and
   ///   `#require()` macros. Do not call it directly.
-  public mutating func __as<T, U>(_ value: T, _ type: U.Type, _ typeID: __ExpressionID) -> U? {
-    let result = value as? U
+  public mutating func __as<T, U>(_ value: T, _ valueID: __ExpressionID, _ type: U.Type, _ typeID: __ExpressionID) -> U? {
+    let result = self(value, valueID) as? U
 
     if result == nil {
       let correctType = Swift.type(of: value as Any)
-      runtimeValues[typeID] = { Expression.Value(reflecting: correctType) }
+      _ = self(correctType, typeID)
     }
 
     return result
@@ -403,9 +405,11 @@ extension __ExpectationContext {
   ///
   /// - Parameters:
   ///   - value: The value to cast.
+  ///   - valueID: A value that uniquely identifies the expression represented
+  ///     by `value` in the context of the expectation being evaluated.
   ///   - type: The type `value` is expected to be.
-  ///   - typeID: The ID chain of the `type` expression as emitted during
-  ///     expansion of the `#expect()` or `#require()` macro.
+  ///   - valueID: A value that uniquely identifies the expression represented
+  ///     by `type` in the context of the expectation being evaluated.
   ///
   /// - Returns: The result of the expression `value as? type`.
   ///
@@ -415,12 +419,12 @@ extension __ExpectationContext {
   ///
   /// - Warning: This function is used to implement the `#expect()` and
   ///   `#require()` macros. Do not call it directly.
-  public mutating func __is<T, U>(_ value: T, _ type: U.Type, _ typeID: __ExpressionID) -> Bool {
-    let result = value is U
+  public mutating func __is<T, U>(_ value: T, _ valueID: __ExpressionID, _ type: U.Type, _ typeID: __ExpressionID) -> Bool {
+    let result = self(value, valueID) is U
 
     if !result {
       let correctType = Swift.type(of: value as Any)
-      runtimeValues[typeID] = { Expression.Value(reflecting: correctType) }
+      _ = self(correctType, typeID)
     }
 
     return result
@@ -445,46 +449,9 @@ extension __ExpectationContext {
   ///
   /// - Warning: This function is used to implement the `#expect()` and
   ///   `#require()` macros. Do not call it directly.
-  public mutating func callAsFunction<P, T>(_ value: P, _ id: __ExpressionID) -> UnsafePointer<T> 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.
-  public mutating func callAsFunction<P, T>(_ value: P?, _ id: __ExpressionID) -> UnsafePointer<T>? where P: _Pointer {
-    UnsafePointer(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.
-  public mutating func callAsFunction<P>(_ value: P, _ id: __ExpressionID) -> UnsafeRawPointer where P: _Pointer {
-    self(value as P?, id)!
+  @_disfavoredOverload
+  public mutating func callAsFunction<PFrom, PTo>(_ value: PFrom, _ id: __ExpressionID) -> PTo where PFrom: _Pointer, PTo: _Pointer {
+    self(value as PFrom?, id) as! PTo
   }
 
   /// Convert some pointer to an immutable one and capture information about it
@@ -502,8 +469,11 @@ extension __ExpectationContext {
   ///
   /// - Warning: This function is used to implement the `#expect()` and
   ///   `#require()` macros. Do not call it directly.
-  public mutating func callAsFunction<P>(_ value: P?, _ id: __ExpressionID) -> UnsafeRawPointer? where P: _Pointer {
-    UnsafeRawPointer(bitPattern: Int(bitPattern: self(value, id) as P?))
+  @_disfavoredOverload
+  public mutating func callAsFunction<PFrom, PTo>(_ value: PFrom?, _ id: __ExpressionID) -> PTo? where PFrom: _Pointer, PTo: _Pointer {
+    value.flatMap { value in
+      PTo(bitPattern: Int(bitPattern: self(value, id) as PFrom))
+    }
   }
 }
 

Sources/TestingMacros/Support/ConditionArgumentParsing.swift

@@ -123,26 +123,35 @@ 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.
   ///
   /// - Returns: A rewritten copy of `node` that calls into the expression
   ///   context when it is evaluated at runtime.
-  private func _rewrite<E>(_ node: E, originalWas originalNode: some SyntaxProtocol) -> ExprSyntax where E: ExprSyntaxProtocol {
-    if rewrittenNodes.contains(Syntax(originalNode)) {
+  private func _rewrite<E>(_ node: E, originalWas originalNode: some SyntaxProtocol, calling functionName: TokenSyntax? = nil, passing additionalArguments: [Argument] = []) -> ExprSyntax where E: ExprSyntaxProtocol {
+    guard rewrittenNodes.insert(Syntax(originalNode)).inserted else {
       // If this node has already been rewritten, we don't need to rewrite it
       // again. (Currently, this can only happen when expanding binary operators
       // which need a bit of extra help.)
       return ExprSyntax(node)
     }
 
-    rewrittenNodes.insert(Syntax(originalNode))
+    let calledExpr: ExprSyntax = if let functionName {
+      ExprSyntax(MemberAccessExprSyntax(base: expressionContextNameExpr, name: functionName))
+    } else {
+      ExprSyntax(expressionContextNameExpr)
+    }
 
-    var result = FunctionCallExprSyntax(calledExpression: expressionContextNameExpr) {
+    var result = FunctionCallExprSyntax(calledExpression: calledExpr) {
       LabeledExprSyntax(expression: node.trimmed)
       LabeledExprSyntax(expression: originalNode.expressionID(rootedAt: effectiveRootNode))
+      for argument in additionalArguments {
+        LabeledExprSyntax(argument)
+      }
     }
 
     result.leftParen = .leftParenToken()
@@ -331,41 +340,27 @@ private final class _ContextInserter<C, M>: SyntaxRewriter where C: MacroExpansi
     if let op = node.operator.as(BinaryOperatorExprSyntax.self)?.operator.textWithoutBackticks,
        op == "==" || op == "!=" || op == "===" || op == "!==" {
 
-      rewrittenNodes.insert(Syntax(node))
-      rewrittenNodes.insert(Syntax(node.leftOperand))
-      rewrittenNodes.insert(Syntax(node.rightOperand))
-
-      var result = FunctionCallExprSyntax(
-        calledExpression: MemberAccessExprSyntax(
-          base: expressionContextNameExpr,
-          name: .identifier("__cmp")
-        )
-      ) {
-        LabeledExprSyntax(expression: visit(node.leftOperand))
-        LabeledExprSyntax(expression: node.leftOperand.expressionID(rootedAt: effectiveRootNode))
-        LabeledExprSyntax(expression: visit(node.rightOperand))
-        LabeledExprSyntax(expression: node.rightOperand.expressionID(rootedAt: effectiveRootNode))
-        LabeledExprSyntax(
-          expression: ClosureExprSyntax {
-            InfixOperatorExprSyntax(
-              leftOperand: DeclReferenceExprSyntax(
-                baseName: .dollarIdentifier("$0")
-              ).with(\.trailingTrivia, .space),
-              operator: BinaryOperatorExprSyntax(text: op),
-              rightOperand: DeclReferenceExprSyntax(
-                baseName: .dollarIdentifier("$1")
-              ).with(\.leadingTrivia, .space)
-            )
-          }
-        )
-        LabeledExprSyntax(expression: node.expressionID(rootedAt: effectiveRootNode))
-      }
-      result.leftParen = .leftParenToken()
-      result.rightParen = .rightParenToken()
-      result.leadingTrivia = node.leadingTrivia
-      result.trailingTrivia = node.trailingTrivia
-
-      return ExprSyntax(result)
+      return _rewrite(
+        ClosureExprSyntax {
+          InfixOperatorExprSyntax(
+            leftOperand: DeclReferenceExprSyntax(
+              baseName: .dollarIdentifier("$0")
+            ).with(\.trailingTrivia, .space),
+            operator: BinaryOperatorExprSyntax(text: op),
+            rightOperand: DeclReferenceExprSyntax(
+              baseName: .dollarIdentifier("$1")
+            ).with(\.leadingTrivia, .space)
+          )
+        },
+        originalWas: node,
+        calling: .identifier("__cmp"),
+        passing: [
+          Argument(expression: visit(node.leftOperand)),
+          Argument(expression: node.leftOperand.expressionID(rootedAt: effectiveRootNode)),
+          Argument(expression: visit(node.rightOperand)),
+          Argument(expression: node.rightOperand.expressionID(rootedAt: effectiveRootNode))
+        ]
+      )
     }
 
     return _rewrite(
@@ -384,48 +379,41 @@ private final class _ContextInserter<C, M>: SyntaxRewriter where C: MacroExpansi
 
   // MARK: - Casts
 
-  /// Create a function call that represents an `is` or `as?` cast.
+  /// Rewrite an `is` or `as?` cast.
   ///
   /// - Parameters:
   ///   - valueExpr: The expression to cast.
   ///   - isAsKeyword: The casting keyword (either `.is` or `.as`).
   ///   - type: The type to cast `valueExpr` to.
+  ///   - originalNode: The original `IsExprSyntax` or `AsExprSyntax` node in
+  ///     the original syntax tree.
   ///
   /// - Returns: A function call expression equivalent to the described cast.
-  private func _makeCastCall(_ valueExpr: ExprSyntax, _ isAsKeyword: Keyword, _ type: TypeSyntax) -> FunctionCallExprSyntax {
-    var result = FunctionCallExprSyntax(
-      calledExpression: MemberAccessExprSyntax(
-        base: expressionContextNameExpr,
-        name: .identifier("__\(isAsKeyword)")
-      )
-    ) {
-      LabeledExprSyntax(expression: visit(valueExpr).trimmed)
-      LabeledExprSyntax(
-        expression: _rewrite(
-          MemberAccessExprSyntax(
+  private func _rewriteAsCast(_ valueExpr: ExprSyntax, _ isAsKeyword: Keyword, _ type: TypeSyntax, originalWas originalNode: some SyntaxProtocol) -> ExprSyntax {
+    rewrittenNodes.insert(Syntax(type))
+
+    return _rewrite(
+      visit(valueExpr).trimmed,
+      originalWas: originalNode,
+      calling: .identifier("__\(isAsKeyword)"),
+      passing: [
+        Argument(
+          expression: MemberAccessExprSyntax(
             base: TupleExprSyntax {
               LabeledExprSyntax(expression: TypeExprSyntax(type: type.trimmed))
             },
             declName: DeclReferenceExprSyntax(baseName: .keyword(.self))
-          ),
-          originalWas: type
-        )
-      )
-      LabeledExprSyntax(expression: type.expressionID(rootedAt: effectiveRootNode))
-    }
-    result.leftParen = .leftParenToken()
-    result.rightParen = .rightParenToken()
-
-    return result
+          )
+        ),
+        Argument(expression: type.expressionID(rootedAt: effectiveRootNode))
+      ]
+    )
   }
 
   override func visit(_ node: AsExprSyntax) -> ExprSyntax {
     switch node.questionOrExclamationMark?.tokenKind {
     case .postfixQuestionMark:
-      return _rewrite(
-        _makeCastCall(node.expression, .as, node.type),
-        originalWas: node
-      )
+      return _rewriteAsCast(node.expression, .as, node.type, originalWas: node)
 
     case .exclamationMark where !node.type.isNamed("Bool", inModuleNamed: "Swift") && !node.type.isOptional:
       // Warn that as! will be evaluated before #expect() or #require(), which is
@@ -436,21 +424,19 @@ private final class _ContextInserter<C, M>: SyntaxRewriter where C: MacroExpansi
       context.diagnose(.asExclamationMarkIsEvaluatedEarly(node, in: macro))
       return _rewrite(node)
 
-    default:
+    case .exclamationMark:
       // Only diagnose for `x as! T`. `x as T` is perfectly fine if it otherwise
       // compiles. For example, `#require(x as Int?)` should compile.
-      //
-      // If the token after "as" is something else entirely and got through the
-      // type checker, just leave it alone as we don't recognize it.
       return _rewrite(node)
+
+    default:
+      // This is an "escape hatch" cast. Do not attempt to process the cast.
+      return ExprSyntax(node)
     }
   }
 
   override func visit(_ node: IsExprSyntax) -> ExprSyntax {
-    _rewrite(
-      _makeCastCall(node.expression, .is, node.type),
-      originalWas: node
-    )
+    _rewriteAsCast(node.expression, .is, node.type, originalWas: node)
   }
 
   // MARK: - Literals