Parse IfExprSyntax

Update the parser to support parsing IfExprSyntax.
For now, this only updates the existing statement
parsing, and does not attempt to parse in
expression position.

Author: hamishknight

Sources/SwiftParser/Expressions.swift

@@ -2524,16 +2524,20 @@ extension Parser.Lookahead {
   }
 }
 
+// MARK: Conditional Expressions
+
 extension Parser {
-  /// Parse an if statement.
+  /// Parse an if statement/expression.
   ///
   /// Grammar
   /// =======
   ///
-  ///     if-statement → 'if' condition-list code-block else-clause?
+  ///     if-expression → 'if' condition-list code-block else-clause?
   ///     else-clause  → 'else' code-block | else if-statement
   @_spi(RawSyntax)
-  public mutating func parseIfStatement(ifHandle: RecoveryConsumptionHandle) -> RawIfStmtSyntax {
+  public mutating func parseIfExpression(
+    ifHandle: RecoveryConsumptionHandle
+  ) -> RawIfExprSyntax {
     let (unexpectedBeforeIfKeyword, ifKeyword) = self.eat(ifHandle)
     // A scope encloses the condition and true branch for any variables bound
     // by a conditional binding. The else branch does *not* see these variables.
@@ -2542,18 +2546,20 @@ extension Parser {
 
     // The else branch, if any, is outside of the scope of the condition.
     let elseKeyword = self.consume(if: .elseKeyword)
-    let elseBody: RawIfStmtSyntax.ElseBody?
+    let elseBody: RawIfExprSyntax.ElseBody?
     if elseKeyword != nil {
       if self.at(.ifKeyword) {
-        elseBody = .ifStmt(self.parseIfStatement(ifHandle: .constant(.ifKeyword)))
+        elseBody = .ifExpr(
+          self.parseIfExpression(ifHandle: .constant(.ifKeyword))
+        )
       } else {
         elseBody = .codeBlock(self.parseCodeBlock(introducer: ifKeyword))
       }
     } else {
       elseBody = nil
     }
 
-    return RawIfStmtSyntax(
+    return RawIfExprSyntax(
       unexpectedBeforeIfKeyword,
       ifKeyword: ifKeyword,
       conditions: conditions,

Sources/SwiftParser/Statements.swift

@@ -97,7 +97,12 @@ extension Parser {
       return label(self.parseRepeatWhileStatement(repeatHandle: handle), with: optLabel)
 
     case (.ifKeyword, let handle)?:
-      return label(self.parseIfStatement(ifHandle: handle), with: optLabel)
+      let ifExpr = self.parseIfExpression(ifHandle: handle)
+      let ifStmt = RawExpressionStmtSyntax(
+        expression: RawExprSyntax(ifExpr),
+        arena: self.arena
+      )
+      return label(ifStmt, with: optLabel)
     case (.guardKeyword, let handle)?:
       return label(self.parseGuardStatement(guardHandle: handle), with: optLabel)
     case (.switchKeyword, let handle)?:

Sources/SwiftRefactor/MigrateToNewIfLetSyntax.swift

@@ -13,7 +13,7 @@
 import SwiftSyntax
 import SwiftParser
 
-/// ``MigrateToNewIfLetSyntax`` will visit each if statement in the Syntax tree, and
+/// ``MigrateToNewIfLetSyntax`` will visit each if expression in the Syntax tree, and
 /// checks if the there is an if condition which is of the pre Swift 5.7 "if-let-style"
 /// and rewrites it to the new one.
 ///
@@ -34,7 +34,7 @@ import SwiftParser
 ///   // ...
 /// }
 public struct MigrateToNewIfLetSyntax: RefactoringProvider {
-  public static func refactor(syntax node: IfStmtSyntax, in context: ()) -> StmtSyntax? {
+  public static func refactor(syntax node: IfExprSyntax, in context: ()) -> IfExprSyntax? {
     // Visit all conditions in the node.
     let newConditions = node.conditions.enumerated().map { (index, condition) -> ConditionElementListSyntax.Element in
       var conditionCopy = condition
@@ -57,6 +57,6 @@ public struct MigrateToNewIfLetSyntax: RefactoringProvider {
       }
       return conditionCopy
     }
-    return StmtSyntax(node.withConditions(ConditionElementListSyntax(newConditions)))
+    return node.withConditions(ConditionElementListSyntax(newConditions))
   }
 }

Sources/SwiftSyntaxBuilder/ConvenienceInitializers.swift

@@ -188,7 +188,7 @@ extension FunctionParameter {
 
 // MARK: - IfStmt
 
-extension IfStmt {
+extension IfExprSyntax {
   /// A convenience initializer that uses builder closures to express an
   /// if body, potentially with a second trailing builder closure for an else
   /// body.

Tests/SwiftParserTest/StatementTests.swift

@@ -21,7 +21,7 @@ final class StatementTests: XCTestCase {
       if let baz {}
       """,
       substructure: Syntax(
-        IfStmtSyntax(
+        IfExprSyntax(
           ifKeyword: .ifKeyword(),
           conditions: ConditionElementListSyntax([
             ConditionElementSyntax(
@@ -47,7 +47,7 @@ final class StatementTests: XCTestCase {
       if let self = self {}
       """,
       substructure: Syntax(
-        IfStmtSyntax(
+        IfExprSyntax(
           ifKeyword: .ifKeyword(),
           conditions: ConditionElementListSyntax([
             ConditionElementSyntax(

Tests/SwiftRefactorTest/MigrateToNewIfLetSyntax.swift

@@ -17,102 +17,113 @@ import SwiftSyntaxBuilder
 import XCTest
 import _SwiftSyntaxTestSupport
 
+@discardableResult
+func testRefactorIfLet(
+  _ syntax: ExprSyntax,
+  expected: ExprSyntax,
+  file: StaticString = #file,
+  line: UInt = #line
+) throws -> ExprSyntax {
+  let ifExpr = try XCTUnwrap(
+    syntax.as(IfExprSyntax.self),
+    file: file,
+    line: line
+  )
+
+  let refactored = try XCTUnwrap(
+    MigrateToNewIfLetSyntax.refactor(syntax: ifExpr),
+    file: file,
+    line: line
+  )
+
+  AssertStringsEqualWithDiff(expected.description, refactored.description)
+  return ExprSyntax(refactored)
+}
+
 final class MigrateToNewIfLetSyntaxTest: XCTestCase {
   func testRefactoring() throws {
-    let baselineSyntax: StmtSyntax = """
+    let baselineSyntax: ExprSyntax = """
       if let x = x {}
       """
 
-    let expectedSyntax: StmtSyntax = """
+    let expectedSyntax: ExprSyntax = """
       if let x {}
       """
 
-    let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self))
-    let expected = try XCTUnwrap(expectedSyntax.as(IfStmtSyntax.self))
-
-    let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline))
-
-    AssertStringsEqualWithDiff(expected.description, refactored.description)
+    try testRefactorIfLet(baselineSyntax, expected: expectedSyntax)
   }
 
   func testIdempotence() throws {
-    let baselineSyntax: StmtSyntax = """
+    let baselineSyntax: ExprSyntax = """
       if let x = x {}
       """
 
-    let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self))
-
-    let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline))
-    let refactoredAgain = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline))
+    let expectedSyntax: ExprSyntax = """
+      if let x {}
+      """
 
-    AssertStringsEqualWithDiff(refactored.description, refactoredAgain.description)
+    let refactored = try testRefactorIfLet(baselineSyntax, expected: expectedSyntax)
+    try testRefactorIfLet(refactored, expected: expectedSyntax)
   }
 
   func testMultiBinding() throws {
-    let baselineSyntax: StmtSyntax = """
+    let baselineSyntax: ExprSyntax = """
       if let x = x, var y = y, let z = z {}
       """
 
-    let expectedSyntax: StmtSyntax = """
+    let expectedSyntax: ExprSyntax = """
       if let x, var y, let z {}
       """
 
-    let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self))
-    let expected = try XCTUnwrap(expectedSyntax.as(IfStmtSyntax.self))
-
-    let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline))
-
-    AssertStringsEqualWithDiff(expected.description, refactored.description)
+    try testRefactorIfLet(baselineSyntax, expected: expectedSyntax)
   }
 
   func testMixedBinding() throws {
-    let baselineSyntax: StmtSyntax = """
+    let baselineSyntax: ExprSyntax = """
       if let x = x, var y = x, let z = y.w {}
       """
 
-    let expectedSyntax: StmtSyntax = """
+    let expectedSyntax: ExprSyntax = """
       if let x, var y = x, let z = y.w {}
       """
 
-    let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self))
-    let expected = try XCTUnwrap(expectedSyntax.as(IfStmtSyntax.self))
-
-    let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline))
-
-    AssertStringsEqualWithDiff(expected.description, refactored.description)
+    try testRefactorIfLet(baselineSyntax, expected: expectedSyntax)
   }
 
   func testConditions() throws {
-    let baselineSyntax: StmtSyntax = """
+    let baselineSyntax: ExprSyntax = """
       if let x = x + 1, x == x, !x {}
       """
 
-    let expectedSyntax: StmtSyntax = """
+    let expectedSyntax: ExprSyntax = """
       if let x = x + 1, x == x, !x {}
       """
 
-    let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self))
-    let expected = try XCTUnwrap(expectedSyntax.as(IfStmtSyntax.self))
-
-    let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline))
-
-    AssertStringsEqualWithDiff(expected.description, refactored.description)
+    try testRefactorIfLet(baselineSyntax, expected: expectedSyntax)
   }
 
   func testWhitespaceNormalization() throws {
-    let baselineSyntax: StmtSyntax = """
+    let baselineSyntax: ExprSyntax = """
       if let x = x   , let y = y {}
       """
 
-    let expectedSyntax: StmtSyntax = """
+    let expectedSyntax: ExprSyntax = """
       if let x, let y {}
       """
 
-    let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self))
-    let expected = try XCTUnwrap(expectedSyntax.as(IfStmtSyntax.self))
+    try testRefactorIfLet(baselineSyntax, expected: expectedSyntax)
+  }
 
-    let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline))
+  func testIfStmt() throws {
+    let baselineSyntax: StmtSyntax = """
+      if let x = x {}
+      """
+
+    let expectedSyntax: ExprSyntax = """
+      if let x {}
+      """
 
-    AssertStringsEqualWithDiff(expected.description, refactored.description)
+    let exprStmt = try XCTUnwrap(baselineSyntax.as(ExpressionStmtSyntax.self))
+    try testRefactorIfLet(exprStmt.expression, expected: expectedSyntax)
   }
 }

Tests/SwiftSyntaxBuilderTest/FunctionTests.swift

@@ -19,7 +19,7 @@ import _SwiftSyntaxTestSupport
 final class FunctionTests: XCTestCase {
   func testFibonacci() {
     let buildable = FunctionDecl("func fibonacci(_ n: Int) -> Int") {
-      IfStmt("if n <= 1 { return n }")
+      IfExpr("if n <= 1 { return n }")
 
       ReturnStmt("return fibonacci(n - 1) + self.fibonacci(n - 2)")
     }

Tests/SwiftSyntaxBuilderTest/IfStmtTests.swift

@@ -15,11 +15,11 @@ import SwiftSyntax
 import SwiftSyntaxBuilder
 
 final class IfStmtTests: XCTestCase {
-  func testEmptyIfStmt() {
+  func testEmptyIfExpr() {
     // Use the convenience initializer from IfStmtConvenienceInitializers. This is
     // disambiguated by the absence of a labelName parameter and the use of a
     // trailing closure.
-    let buildable = IfStmt(conditions: ConditionElementList { BooleanLiteralExpr(false) }) {}
+    let buildable = IfExpr(conditions: ConditionElementList { BooleanLiteralExpr(false) }) {}
     AssertBuildResult(
       buildable,
       """
@@ -32,7 +32,7 @@ final class IfStmtTests: XCTestCase {
   func testIfElseStmt() {
     // Use the convenience initializer from IfStmtConvenienceInitializers
     // with an else branch expressed by a second trailing closure.
-    let buildable = IfStmt(conditions: ConditionElementList { BooleanLiteralExpr(true) }) {
+    let buildable = IfExpr(conditions: ConditionElementList { BooleanLiteralExpr(true) }) {
       FunctionCallExpr(callee: ExprSyntax("print")) {
         TupleExprElement(expression: StringLiteralExpr(content: "Hello from the if-branch!"))
       }
@@ -54,7 +54,7 @@ final class IfStmtTests: XCTestCase {
   }
 
   func testIfLetStmt() {
-    let buildable = IfStmt(
+    let buildable = IfExpr(
       conditions: ConditionElementList {
         OptionalBindingCondition(
           letOrVarKeyword: .let,
@@ -73,7 +73,7 @@ final class IfStmtTests: XCTestCase {
   }
 
   func testIfCaseStmt() {
-    let buildable = IfStmt(
+    let buildable = IfExpr(
       conditions: ConditionElementList {
         MatchingPatternCondition(
           pattern: ExpressionPattern(expression: MemberAccessExpr(name: "x")),