Hoist "try" and "await" expressions during folding.

When folding an expression such as `try x + y`, instead of producing
`(try x) + y`, hoist the `try` up to produce `try (x + y)`.

Author: DougGregor

Sources/SwiftOperators/OperatorTable+Folding.swift

@@ -94,6 +94,34 @@ extension OperatorTable {
   public static func makeBinaryOperationExpr(
     lhs: ExprSyntax, op: ExprSyntax, rhs: ExprSyntax
   ) -> ExprSyntax {
+    // If the left-hand side is a "try" or "await", hoist it up to encompass
+    // the right-hand side as well.
+    if let tryExpr = lhs.as(TryExprSyntax.self) {
+      return ExprSyntax(
+        TryExprSyntax(
+          tryExpr.unexpectedBeforeTryKeyword,
+          tryKeyword: tryExpr.tryKeyword,
+          tryExpr.unexpectedBetweenTryKeywordAndQuestionOrExclamationMark,
+          questionOrExclamationMark: tryExpr.questionOrExclamationMark,
+          tryExpr.unexpectedBetweenQuestionOrExclamationMarkAndExpression,
+          expression: makeBinaryOperationExpr(
+            lhs: tryExpr.expression, op: op, rhs: rhs)
+        )
+      )
+    }
+
+    if let awaitExpr = lhs.as(AwaitExprSyntax.self) {
+      return ExprSyntax(
+        AwaitExprSyntax(
+          awaitExpr.unexpectedBeforeAwaitKeyword,
+          awaitKeyword: awaitExpr.awaitKeyword,
+          awaitExpr.unexpectedBetweenAwaitKeywordAndExpression,
+          expression: makeBinaryOperationExpr(
+            lhs: awaitExpr.expression, op: op, rhs: rhs)
+        )
+      )
+    }
+
     // The form of the binary operation depends on the operator itself,
     // which will be one of the unresolved infix operators.
 

Tests/SwiftOperatorsTest/OperatorTableTests.swift

@@ -381,4 +381,11 @@ public class OperatorPrecedenceTests: XCTestCase {
       "b + c ? y : z ? z2 : z3",
       "((b + c) ? y : (z ? z2 : z3))")
   }
+
+  func testTryAwait() throws {
+    let opPrecedence = OperatorTable.standardOperators
+    try opPrecedence.assertExpectedFold("try x + y", "try (x + y)")
+    try opPrecedence.assertExpectedFold(
+      "await x + y + z", "await ((x + y) + z)")
+  }
 }