parse in expr positition

Author: hamishknight

Sources/SwiftParser/Expressions.swift

@@ -182,6 +182,30 @@ extension Parser {
       arena: self.arena))
   }
 
+  /// 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.
@@ -313,19 +337,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 {
@@ -452,8 +464,16 @@ extension Parser {
     forDirective: Bool = false,
     pattern: PatternContext = .none
   ) -> RawExprSyntax {
-    // First check to see if we have the start of a regex literal `/.../`.
-    //    tryLexRegexLiteral(/*forUnappliedOperator*/ false)
+
+    if self.at(.switchKeyword) {
+      return RawExprSyntax(
+        parseSwitchExpression(switchHandle: .constant(.switchKeyword)))
+    }
+    if self.at(.ifKeyword) {
+      return RawExprSyntax(
+        parseIfExpression(ifHandle: .constant(.ifKeyword)))
+    }
+
     switch self.at(anyIn: ExpressionPrefixOperator.self) {
     case (.prefixAmpersand, let handle)?:
       let amp = self.eat(handle)
@@ -2347,6 +2367,11 @@ extension Parser.Lookahead {
       return false
     }
 
+    // If this is the start of a switch body, this isn't a trailing closure.
+    if self.peek().tokenKind == .caseKeyword {
+      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/Statements.swift

@@ -632,6 +632,24 @@ extension Parser {
 // MARK: Control Transfer Statements
 
 extension Parser {
+  private 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(any: [.ifKeyword, .switchKeyword]) {
+      return true
+    }
+    if self.atStartOfStatement() || self.atStartOfDeclaration() {
+      return false
+    }
+    return true
+  }
+
   /// Parse a return statement
   ///
   /// Grammar
@@ -647,13 +665,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(RawTryExprSyntax(

Sources/SwiftParser/TopLevel.swift

@@ -192,6 +192,29 @@ 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.
+    if at(.asKeyword), 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: .asKeyword)
+        )
+        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.
@@ -224,13 +247,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

@@ -794,3 +794,34 @@ 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 }
+      }
+      """)
+  }
+}