Add EffectfulExprSyntax syntax trait

Introduces the `EffectfulExprSyntax` protocol, designed to provide a common interface for effectful expressions such as `try` and `await`.

Solves #2549

Author: Matejkob

CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift

@@ -152,6 +152,9 @@ public let EXPR_NODES: [Node] = [
     kind: .awaitExpr,
     base: .expr,
     nameForDiagnostics: "'await' expression",
+    traits: [
+      "EffectfulExpr"
+    ],
     children: [
       Child(
         name: "awaitKeyword",
@@ -1914,6 +1917,9 @@ public let EXPR_NODES: [Node] = [
       try! foo()
       ```
       """,
+    traits: [
+      "EffectfulExpr"
+    ],
     children: [
       Child(
         name: "tryKeyword",

CodeGeneration/Sources/SyntaxSupport/Traits.swift

@@ -66,6 +66,13 @@ public let TRAITS: [Trait] = [
       Child(name: "memberBlock", kind: .node(kind: .memberBlock)),
     ]
   ),
+  Trait(
+    traitName: "EffectfulExpr",
+    documentation: "Syntax trait for effectful expressions, such as `try` and `await`.",
+    children: [
+      Child(name: "expression", kind: .node(kind: .expr))
+    ]
+  ),
   Trait(
     traitName: "EffectSpecifiers",
     children: [

CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift

@@ -534,18 +534,56 @@ class ValidateSyntaxNodes: XCTestCase {
       failures,
       expectedFailures: [
         ValidationFailure(node: .accessorParameters, message: "could conform to trait 'NamedDecl' but does not"),
+        ValidationFailure(node: .arrayElement, message: "could conform to trait 'EffectfulExpr' but does not"),
+        ValidationFailure(node: .asExpr, message: "could conform to trait 'EffectfulExpr' but does not"),
         ValidationFailure(node: .availabilityCondition, message: "could conform to trait 'Parenthesized' but does not"),
+        ValidationFailure(node: .borrowExpr, message: "could conform to trait 'EffectfulExpr' but does not"),
         ValidationFailure(node: ._canImportExpr, message: "could conform to trait 'Parenthesized' but does not"),
+        ValidationFailure(node: .closureCapture, message: "could conform to trait 'EffectfulExpr' but does not"),
+        ValidationFailure(node: .consumeExpr, message: "could conform to trait 'EffectfulExpr' but does not"),
+        ValidationFailure(node: .copyExpr, message: "could conform to trait 'EffectfulExpr' but does not"),
         ValidationFailure(
           node: .differentiabilityArguments,
           message: "could conform to trait 'Parenthesized' but does not"
         ),
+        ValidationFailure(node: .discardStmt, message: "could conform to trait 'EffectfulExpr' but does not"),
         ValidationFailure(node: .editorPlaceholderDecl, message: "could conform to trait 'MissingNode' but does not"),
         ValidationFailure(node: .editorPlaceholderExpr, message: "could conform to trait 'MissingNode' but does not"),
         ValidationFailure(node: .enumCaseElement, message: "could conform to trait 'NamedDecl' but does not"),
+        ValidationFailure(
+          node: .expressionPattern,
+          message: "could conform to trait 'EffectfulExpr' but does not"
+        ),
+        ValidationFailure(node: .expressionStmt, message: "could conform to trait 'EffectfulExpr' but does not"),
+        ValidationFailure(node: .forceUnwrapExpr, message: "could conform to trait 'EffectfulExpr' but does not"),
         ValidationFailure(node: .genericParameter, message: "could conform to trait 'NamedDecl' but does not"),
+        ValidationFailure(
+          node: .genericSpecializationExpr,
+          message: "could conform to trait 'EffectfulExpr' but does not"
+        ),
+        ValidationFailure(node: .inOutExpr, message: "could conform to trait 'EffectfulExpr' but does not"),
+        ValidationFailure(node: .isExpr, message: "could conform to trait 'EffectfulExpr' but does not"),
+        ValidationFailure(node: .labeledExpr, message: "could conform to trait 'EffectfulExpr' but does not"),
+        ValidationFailure(
+          node: .optionalChainingExpr,
+          message: "could conform to trait 'EffectfulExpr' but does not"
+        ),
+        ValidationFailure(
+          node: .postfixOperatorExpr,
+          message: "could conform to trait 'EffectfulExpr' but does not"
+        ),
+        ValidationFailure(
+          node: .prefixOperatorExpr,
+          message: "could conform to trait 'EffectfulExpr' but does not"
+        ),
         ValidationFailure(node: .precedenceGroupName, message: "could conform to trait 'NamedDecl' but does not"),
         ValidationFailure(node: .primaryAssociatedType, message: "could conform to trait 'NamedDecl' but does not"),
+        ValidationFailure(node: .thenStmt, message: "could conform to trait 'EffectfulExpr' but does not"),
+        ValidationFailure(node: .throwStmt, message: "could conform to trait 'EffectfulExpr' but does not"),
+        ValidationFailure(
+          node: .yieldedExpression,
+          message: "could conform to trait 'EffectfulExpr' but does not"
+        ),
         ValidationFailure(
           node: .yieldedExpressionsClause,
           message: "could conform to trait 'Parenthesized' but does not"

Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md

@@ -392,6 +392,7 @@ These articles are intended for developers wishing to contribute to SwiftSyntax
 
 - <doc:SwiftSyntax/BracedSyntax>
 - <doc:SwiftSyntax/DeclGroupSyntax>
+- <doc:SwiftSyntax/EffectfulExprSyntax>
 - <doc:SwiftSyntax/EffectSpecifiersSyntax>
 - <doc:SwiftSyntax/FreestandingMacroExpansionSyntax>
 - <doc:SwiftSyntax/NamedDeclSyntax>

Sources/SwiftSyntax/generated/SyntaxTraits.swift

@@ -132,6 +132,43 @@ public extension SyntaxProtocol {
   }
 }
 
+// MARK: - EffectfulExprSyntax
+
+/// Syntax trait for effectful expressions, such as `try` and `await`.
+public protocol EffectfulExprSyntax: SyntaxProtocol {
+  var expression: ExprSyntax {
+    get
+    set
+  }
+}
+
+public extension EffectfulExprSyntax {
+  /// Without this function, the `with` function defined on `SyntaxProtocol`
+  /// does not work on existentials of this protocol type.
+  @_disfavoredOverload
+  func with<T>(_ keyPath: WritableKeyPath<EffectfulExprSyntax, T>, _ newChild: T) -> EffectfulExprSyntax {
+    var copy: EffectfulExprSyntax = self
+    copy[keyPath: keyPath] = newChild
+    return copy
+  }
+}
+
+public extension SyntaxProtocol {
+  /// Check whether the non-type erased version of this syntax node conforms to
+  /// `EffectfulExprSyntax`.
+  /// Note that this will incur an existential conversion.
+  func isProtocol(_: EffectfulExprSyntax.Protocol) -> Bool {
+    return self.asProtocol(EffectfulExprSyntax.self) != nil
+  }
+  
+  /// Return the non-type erased version of this syntax node if it conforms to
+  /// `EffectfulExprSyntax`. Otherwise return `nil`.
+  /// Note that this will incur an existential conversion.
+  func asProtocol(_: EffectfulExprSyntax.Protocol) -> EffectfulExprSyntax? {
+    return Syntax(self).asProtocol(SyntaxProtocol.self) as? EffectfulExprSyntax
+  }
+}
+
 // MARK: - EffectSpecifiersSyntax
 
 public protocol EffectSpecifiersSyntax: SyntaxProtocol {
@@ -689,6 +726,8 @@ extension AttributedTypeSyntax: WithAttributesSyntax {}
 
 extension AvailabilityArgumentSyntax: WithTrailingCommaSyntax {}
 
+extension AwaitExprSyntax: EffectfulExprSyntax {}
+
 extension CatchClauseSyntax: WithCodeBlockSyntax {}
 
 extension CatchItemSyntax: WithTrailingCommaSyntax {}
@@ -831,6 +870,8 @@ extension SwitchCaseSyntax: WithStatementsSyntax {}
 
 extension SwitchExprSyntax: BracedSyntax {}
 
+extension TryExprSyntax: EffectfulExprSyntax {}
+
 extension TupleExprSyntax: ParenthesizedSyntax {}
 
 extension TuplePatternElementSyntax: WithTrailingCommaSyntax {}