Fix incorrect discovery of effectful keywords in the lexical context. (#1482)

This PR fixes a bug in our code that discovers effectful keywords like
`try` when expanding `#expect()`.

### 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

Sources/TestingMacros/Support/ConditionArgumentParsing.swift

@@ -507,23 +507,32 @@ private func _parseCondition(from expr: ExprSyntax, for macro: some Freestanding
 
 // MARK: -
 
-/// Parse a condition argument from an arbitrary expression.
-///
-/// - Parameters:
-///   - expr: The condition expression to parse.
-///   - macro: The macro expression being expanded.
-///   - context: The macro context in which the expression is being parsed.
-///
-/// - Returns: An instance of ``Condition`` describing `expr`.
-func parseCondition(from expr: ExprSyntax, for macro: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext) -> Condition {
-  // If the condition involves the `unsafe`, `try`, or `await` keywords, assume
-  // we cannot expand it.
-  let effectKeywordsToApply = findEffectKeywords(in: expr).union(findEffectKeywords(in: context))
-  guard effectKeywordsToApply.intersection([.unsafe, .try, .await]).isEmpty else {
-    return Condition(expression: expr)
-  }
+extension ConditionMacro {
+  /// Parse a condition argument from an arbitrary expression.
+  ///
+  /// - Parameters:
+  ///   - expr: The condition expression to parse.
+  ///   - macro: The macro expression being expanded.
+  ///   - context: The macro context in which the expression is being parsed.
+  ///
+  /// - Returns: An instance of ``Condition`` describing `expr`.
+  static func parseCondition(from expr: ExprSyntax, for macro: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext) -> Condition {
+    // If the condition involves the `unsafe`, `try`, or `await` keywords, assume
+    // we cannot expand it.
+    let effectKeywordsFromNode = findEffectKeywords(in: expr)
+    guard effectKeywordsFromNode.intersection([.unsafe, .try, .await]).isEmpty else {
+      return Condition(expression: expr)
+    }
+    let effectKeywordsInLexicalContext = findEffectKeywords(in: context)
+    guard effectKeywordsInLexicalContext.intersection([.unsafe, .await]).isEmpty else {
+      return Condition(expression: expr)
+    }
+    if !isThrowing && effectKeywordsInLexicalContext.contains(.try) {
+      return Condition(expression: expr)
+    }
 
-  _diagnoseTrivialBooleanValue(from: expr, for: macro, in: context)
-  let result = _parseCondition(from: expr, for: macro, in: context)
-  return result
+    _diagnoseTrivialBooleanValue(from: expr, for: macro, in: context)
+    let result = _parseCondition(from: expr, for: macro, in: context)
+    return result
+  }
 }

Sources/TestingMacros/Support/EffectfulExpressionHandling.swift

@@ -106,7 +106,9 @@ func findEffectKeywords(in node: some SyntaxProtocol) -> Set<Keyword> {
 /// - Returns: A set of effectful keywords such as `await` that are present in
 ///   `context` and would apply to an expression macro during its expansion.
 func findEffectKeywords(in context: some MacroExpansionContext) -> Set<Keyword> {
-  let result = context.lexicalContext.reversed().lazy
+  // The lexical context is ordered from innermost to outermost, and we are most
+  // interested in keywords near the macro expansion, so don't use reversed().
+  let result = context.lexicalContext.lazy
     .prefix { _continueKind(for: $0) == .visitChildren }
     .compactMap { $0.as(ExprSyntax.self) }
     .compactMap(_effectKeyword(for:))

Tests/TestingTests/MiscellaneousTests.swift

@@ -272,6 +272,14 @@ struct MultiLineSuite {
   _ = try #require(x?[...].last)
 }
 
+extension Bool {
+  func throwingValue() throws -> Bool { self }
+}
+
+@Test(.hidden) func `Effectful keywords are found in the lexical context of an expression macro`() throws {
+  try #expect(true.throwingValue())
+}
+
 @Suite("Miscellaneous tests")
 struct MiscellaneousTests {
   @Test("Free function's name")