Parse IfExpr and SwitchExpr in expression position

Start parsing if and switch expressions as unary
expressions (as we don't allow postfix grammar for
them). In addition, parse if/switch expressions
in statement position if we see a
`try`/`await`/`move`, or a trailing `as Type`.

Author: hamishknight

Sources/SwiftParser/Expressions.swift

@@ -18,6 +18,11 @@ extension TokenConsumer {
     case (.awaitTryMove, let handle)?:
       var backtrack = self.lookahead()
       backtrack.eat(handle)
+
+      // These can be parsed as expressions with try/await.
+      if backtrack.at(anyIn: IfOrSwitch.self) != nil {
+        return true
+      }
       if backtrack.atStartOfDeclaration() || backtrack.atStartOfStatement() {
         // If after the 'try' we are at a declaration or statement, it can't be a valid expression.
         // Decide how we want to consume the 'try':
@@ -191,6 +196,30 @@ extension Parser {
     )
   }
 
+  /// Parse an unresolved 'as' expression.
+  ///
+  ///     type-casting-operator → 'as' type
+  ///     type-casting-operator → 'as' '?' type
+  ///     type-casting-operator → 'as' '!' type
+  ///
+  mutating func parseUnresolvedAsExpr(
+    handle: TokenConsumptionHandle
+  ) -> (operator: RawExprSyntax, rhs: RawExprSyntax) {
+    let asKeyword = self.eat(handle)
+    let failable = self.consume(ifAny: [.postfixQuestionMark, .exclamationMark])
+    let op = RawUnresolvedAsExprSyntax(
+      asTok: asKeyword,
+      questionOrExclamationMark: failable,
+      arena: self.arena
+    )
+
+    // Parse the right type expression operand as part of the 'as' production.
+    let type = self.parseType()
+    let rhs = RawTypeExprSyntax(type: type, arena: self.arena)
+
+    return (RawExprSyntax(op), RawExprSyntax(rhs))
+  }
+
   /// Parse an expression sequence operators.
   ///
   /// Returns `nil` if the current token is not at an operator.
@@ -323,19 +352,7 @@ extension Parser {
       return (RawExprSyntax(op), RawExprSyntax(rhs))
 
     case (.asKeyword, let handle)?:
-      let asKeyword = self.eat(handle)
-      let failable = self.consume(ifAny: [.postfixQuestionMark, .exclamationMark])
-      let op = RawUnresolvedAsExprSyntax(
-        asTok: asKeyword,
-        questionOrExclamationMark: failable,
-        arena: self.arena
-      )
-
-      // Parse the right type expression operand as part of the 'as' production.
-      let type = self.parseType()
-      let rhs = RawTypeExprSyntax(type: type, arena: self.arena)
-
-      return (RawExprSyntax(op), RawExprSyntax(rhs))
+      return parseUnresolvedAsExpr(handle: handle)
 
     case (.async, _)?:
       if self.peek().tokenKind == .arrow || self.peek().tokenKind == .throwsKeyword {
@@ -487,6 +504,22 @@ extension Parser {
   ) -> RawExprSyntax {
     // First check to see if we have the start of a regex literal `/.../`.
     //    tryLexRegexLiteral(/*forUnappliedOperator*/ false)
+
+    // Try parse an 'if' or 'switch' as an expression. Note we do this here in
+    // parseUnaryExpression as we don't allow postfix syntax to hang off such
+    // expressions to avoid ambiguities such as postfix '.member', which can
+    // currently be parsed as a static dot member for a result builder.
+    if self.at(.keyword(.switch)) {
+      return RawExprSyntax(
+        parseSwitchExpression(switchHandle: .constant(.keyword(.switch)))
+      )
+    }
+    if self.at(.keyword(.if)) {
+      return RawExprSyntax(
+        parseIfExpression(ifHandle: .constant(.keyword(.if)))
+      )
+    }
+
     switch self.at(anyIn: ExpressionPrefixOperator.self) {
     case (.prefixAmpersand, let handle)?:
       let amp = self.eat(handle)
@@ -2461,6 +2494,11 @@ extension Parser.Lookahead {
       return false
     }
 
+    // If this is the start of a switch body, this isn't a trailing closure.
+    if self.peek().rawTokenKind == .keyword(.case) {
+      return false;
+    }
+
     // If this is a normal expression (not an expr-basic) then trailing closures
     // are allowed, so this is obviously one.
     // TODO: We could handle try to disambiguate cases like:

Sources/SwiftParser/RawTokenKindSubset.swift

@@ -611,6 +611,26 @@ enum AwaitTryMove: RawTokenKindSubset {
   }
 }
 
+enum IfOrSwitch: RawTokenKindSubset {
+  case ifKeyword
+  case switchKeyword
+
+  init?(lexeme: Lexer.Lexeme) {
+    switch lexeme {
+    case RawTokenKindMatch(.keyword(.if)): self = .ifKeyword
+    case RawTokenKindMatch(.keyword(.switch)): self = .switchKeyword
+    default: return nil
+    }
+  }
+
+  var rawTokenKind: RawTokenKind {
+    switch self {
+    case .ifKeyword: return .keyword(.if)
+    case .switchKeyword: return .keyword(.switch)
+    }
+  }
+}
+
 enum ExpressionPrefixOperator: RawTokenKindSubset {
   case backslash
   case prefixAmpersand

Sources/SwiftParser/Statements.swift

@@ -665,6 +665,24 @@ extension Parser {
 // MARK: Control Transfer Statements
 
 extension Parser {
+  private mutating func isStartOfReturnExpr() -> Bool {
+    if self.at(any: [
+      .rightBrace, .caseKeyword, .defaultKeyword, .semicolon, .eof,
+      .poundIfKeyword, .poundErrorKeyword, .poundWarningKeyword,
+      .poundEndifKeyword, .poundElseKeyword, .poundElseifKeyword,
+    ]) {
+      return false
+    }
+    // Allowed for if/switch expressions.
+    if self.at(anyIn: IfOrSwitch.self) != nil {
+      return true
+    }
+    if self.atStartOfStatement() || self.atStartOfDeclaration() {
+      return false
+    }
+    return true
+  }
+
   /// Parse a return statement
   ///
   /// Grammar
@@ -680,13 +698,7 @@ extension Parser {
     // enclosing stmt-brace to get it by eagerly eating it unless the return is
     // followed by a '}', '', statement or decl start keyword sequence.
     let expr: RawExprSyntax?
-    if !self.at(any: [
-      .rightBrace, .caseKeyword, .defaultKeyword, .semicolon, .eof,
-      .poundIfKeyword, .poundErrorKeyword, .poundWarningKeyword,
-      .poundEndifKeyword, .poundElseKeyword, .poundElseifKeyword,
-    ])
-      && !self.atStartOfStatement() && !self.atStartOfDeclaration()
-    {
+    if isStartOfReturnExpr() {
       let parsedExpr = self.parseExpression()
       if hasMisplacedTry && !parsedExpr.is(RawTryExprSyntax.self) {
         expr = RawExprSyntax(

Sources/SwiftParser/TopLevel.swift

@@ -194,6 +194,35 @@ extension Parser {
     )
   }
 
+  private mutating func parseStatementItem() -> RawCodeBlockItemSyntax.Item {
+    let stmt = self.parseStatement()
+
+    // Special case: An 'if' or 'switch' statement followed by an 'as' must
+    // be an if/switch expression in a coercion.
+    // We could also achieve this by more eagerly attempting to parse an 'if'
+    // or 'switch' as an expression when in statement position, but that
+    // could result in less useful recovery behavior.
+    if at(.keyword(.as)), let stmtExpr = stmt.as(RawExpressionStmtSyntax.self) {
+      let expr = stmtExpr.expression
+      if expr.is(RawIfExprSyntax.self) || expr.is(RawSwitchExprSyntax.self) {
+        let (op, rhs) = parseUnresolvedAsExpr(
+          handle: .init(tokenKind: .keyword(.as))
+        )
+        let sequence = RawExprSyntax(
+          RawSequenceExprSyntax(
+            elements: RawExprListSyntax(
+              elements: [expr, op, rhs],
+              arena: self.arena
+            ),
+            arena: self.arena
+          )
+        )
+        return .expr(sequence)
+      }
+    }
+    return .stmt(stmt)
+  }
+
   /// `isAtTopLevel` determines whether this is trying to parse an item that's at
   /// the top level of the source file. If this is the case, we allow skipping
   /// closing braces while trying to recover to the next item.
@@ -227,13 +256,13 @@ extension Parser {
     } else if self.atStartOfDeclaration(allowInitDecl: allowInitDecl) {
       return .decl(self.parseDeclaration())
     } else if self.atStartOfStatement() {
-      return .stmt(self.parseStatement())
+      return self.parseStatementItem()
     } else if self.atStartOfExpression() {
       return .expr(self.parseExpression())
     } else if self.atStartOfDeclaration(isAtTopLevel: isAtTopLevel, allowInitDecl: allowInitDecl, allowRecovery: true) {
       return .decl(self.parseDeclaration())
     } else if self.atStartOfStatement(allowRecovery: true) {
-      return .stmt(self.parseStatement())
+      return self.parseStatementItem()
     } else {
       return .expr(RawExprSyntax(RawMissingExprSyntax(arena: self.arena)))
     }

Tests/SwiftParserTest/ExpressionTests.swift

@@ -803,3 +803,154 @@ final class ExpressionTests: XCTestCase {
     )
   }
 }
+
+final class StatementExpressionTests: XCTestCase {
+  func testIfExprInCoercion() {
+    AssertParse(
+      """
+      func foo() {
+        if .random() { 0 } else { 1 } as Int
+      }
+      """
+    )
+  }
+  func testSwitchExprInCoercion() {
+    AssertParse(
+      """
+      func foo() {
+        switch Bool.random() { case true: 0 case false: 1 } as Int
+      }
+      """
+    )
+  }
+  func testIfExprInReturn() {
+    AssertParse(
+      """
+      func foo() {
+        return if .random() { 0 } else { 1 }
+      }
+      """
+    )
+  }
+  func testSwitchExprInReturn() {
+    AssertParse(
+      """
+      func foo() {
+        return switch Bool.random() { case true: 0 case false: 1 }
+      }
+      """
+    )
+  }
+  func testTryIf1() {
+    AssertParse(
+      """
+      func foo() -> Int {
+        try if .random() { 0 } else { 1 }
+      }
+      """
+    )
+  }
+  func testTryIf2() {
+    AssertParse(
+      """
+      func foo() -> Int {
+        return try if .random() { 0 } else { 1 }
+      }
+      """
+    )
+  }
+  func testTryIf3() {
+    AssertParse(
+      """
+      func foo() -> Int {
+        let x = try if .random() { 0 } else { 1 }
+        return x
+      }
+      """
+    )
+  }
+  func testAwaitIf1() {
+    AssertParse(
+      """
+      func foo() async -> Int {
+        await if .random() { 0 } else { 1 }
+      }
+      """
+    )
+  }
+  func testAwaitIf2() {
+    AssertParse(
+      """
+      func foo() async -> Int {
+        return await if .random() { 0 } else { 1 }
+      }
+      """
+    )
+  }
+  func testAwaitIf3() {
+    AssertParse(
+      """
+      func foo() async -> Int {
+        let x = await if .random() { 0 } else { 1 }
+        return x
+      }
+      """
+    )
+  }
+  func testTrySwitch1() {
+    AssertParse(
+      """
+      func foo() -> Int {
+        try switch Bool.random() { case true: 0 case false: 1 }
+      }
+      """
+    )
+  }
+  func testTrySwitch2() {
+    AssertParse(
+      """
+      func foo() -> Int {
+        return try switch Bool.random() { case true: 0 case false: 1 }
+      }
+      """
+    )
+  }
+  func testTrySwitch3() {
+    AssertParse(
+      """
+      func foo() -> Int {
+        let x = try switch Bool.random() { case true: 0 case false: 1 }
+        return x
+      }
+      """
+    )
+  }
+  func testAwaitSwitch1() {
+    AssertParse(
+      """
+      func foo() async -> Int {
+        await switch Bool.random() { case true: 0 case false: 1 }
+      }
+      """
+    )
+  }
+  func testAwaitSwitch2() {
+    AssertParse(
+      """
+      func foo() async -> Int {
+        return await switch Bool.random() { case true: 0 case false: 1 }
+      }
+      """
+    )
+  }
+  func testAwaitSwitch3() {
+    AssertParse(
+      """
+      func foo() async -> Int {
+        let x = await switch Bool.random() { case true: 0 case false: 1 }
+        return x
+      }
+      """
+    )
+  }
+}