[ASTGen] Handle 'try' at the first element of SequenceExprSyntax

TryExpr must be hosted to wrap the whole sequence expression.

Author: rintaro

lib/ASTGen/Sources/ASTGen/Exprs.swift

@@ -1098,6 +1098,18 @@ extension ASTGenVisitor {
     var elements: [BridgedExpr] = []
     elements.reserveCapacity(node.elements.count)
 
+    // If the left-most sequence expr is a 'try', hoist it up to turn
+    // '(try x) + y' into 'try (x + y)'. This is necessary to do in the
+    // ASTGen because 'try' nodes are represented in the ASTScope tree
+    // to look up catch nodes. The scope tree must be syntactic because
+    // it's constructed before sequence folding happens during preCheckExpr.
+    // Otherwise, catch node lookup would find the incorrect catch node for
+    // 'try x + y' at the source location for 'y'.
+    //
+    // 'try' has restrictions for where it can appear within a sequence
+    // expr. This is still diagnosed in TypeChecker::foldSequence.
+    let firstTryExprSyntax = node.elements.first?.as(TryExprSyntax.self)
+
     var iter = node.elements.makeIterator()
     while let node = iter.next() {
       switch node.as(ExprSyntaxEnum.self) {
@@ -1124,15 +1136,24 @@ extension ASTGenVisitor {
       case .unresolvedTernaryExpr(let node):
         elements.append(self.generate(unresolvedTernaryExpr: node).asExpr)
       default:
-        // Operand.
-        elements.append(self.generate(expr: node))
+        if let firstTryExprSyntax, node.id == firstTryExprSyntax.id {
+          elements.append(self.generate(expr: firstTryExprSyntax.expression))
+        } else {
+          elements.append(self.generate(expr: node))
+        }
       }
     }
 
-    return BridgedSequenceExpr.createParsed(
+    let seqExpr = BridgedSequenceExpr.createParsed(
       self.ctx,
       exprs: elements.lazy.bridgedArray(in: self)
     ).asExpr
+
+    if let firstTryExprSyntax {
+      return self.generate(tryExpr: firstTryExprSyntax, overridingSubExpr: seqExpr)
+    } else {
+      return seqExpr
+    }
   }
 
   func generate(subscriptCallExpr node: SubscriptCallExprSyntax, postfixIfConfigBaseExpr: BridgedExpr? = nil) -> BridgedSubscriptExpr {
@@ -1164,9 +1185,9 @@ extension ASTGenVisitor {
     )
   }
 
-  func generate(tryExpr node: TryExprSyntax) -> BridgedExpr {
+  func generate(tryExpr node: TryExprSyntax, overridingSubExpr: BridgedExpr? = nil) -> BridgedExpr {
     let tryLoc = self.generateSourceLoc(node.tryKeyword)
-    let subExpr = self.generate(expr: node.expression)
+    let subExpr = overridingSubExpr ?? self.generate(expr: node.expression)
 
     switch node.questionOrExclamationMark {
     case nil:

test/ASTGen/exprs.swift

@@ -85,6 +85,11 @@ func testUnaryExprs() async throws {
   let bar = copy foo
   let baz = consume foo
 }
+func throwsFunc() throws -> Int { 1 }
+func testOptionalTry() {
+  let _ = try! 1 + throwsFunc()
+  let _ = try? throwsFunc() + throwsFunc()
+}
 
 func testRepeatEach<each T>(_ t: repeat each T) -> (repeat each T) {
   return (repeat each t)