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

@@ -2099,16 +2099,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.
@@ -2117,18 +2121,20 @@ extension Parser {
 
     // The else branch, if any, is outside of the scope of the condition.
     let elseKeyword = self.consume(if: .keyword(.else))
-    let elseBody: RawIfStmtSyntax.ElseBody?
+    let elseBody: RawIfExprSyntax.ElseBody?
     if elseKeyword != nil {
       if self.at(.keyword(.if)) {
-        elseBody = .ifStmt(self.parseIfStatement(ifHandle: .constant(.keyword(.if))))
+        elseBody = .ifExpr(
+          self.parseIfExpression(ifHandle: .constant(.keyword(.if)))
+        )
       } else {
         elseBody = .codeBlock(self.parseCodeBlock(introducer: ifKeyword))
       }
     } else {
       elseBody = nil
     }
 
-    return RawIfStmtSyntax(
+    return RawIfExprSyntax(
       unexpectedBeforeIfKeyword,
       ifKeyword: ifKeyword,
       conditions: conditions,

Sources/SwiftParser/Statements.swift

@@ -102,7 +102,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.with(\.conditions, ConditionElementListSyntax(newConditions)))
+    return node.with(\.conditions, ConditionElementListSyntax(newConditions))
   }
 }

Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift

@@ -116,30 +116,30 @@ extension ExtensionDeclSyntax: HasTrailingMemberDeclBlock {}
 extension ProtocolDeclSyntax: HasTrailingMemberDeclBlock {}
 extension StructDeclSyntax: HasTrailingMemberDeclBlock {}
 
-// MARK: - IfStmtSyntax
-// IfStmtSyntax is a special scenario as we also have the `else` body or an if-else
+// MARK: - IfExprSyntax
+// IfExprSyntax is a special scenario as we also have the `else` body or an if-else
 // So we cannot conform to `HasTrailingCodeBlock`
 
-public extension IfStmtSyntax {
+public extension IfExprSyntax {
   init(_ header: PartialSyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () throws -> CodeBlockItemListSyntax, @CodeBlockItemListBuilder `else` elseBuilder: () throws -> CodeBlockItemListSyntax? = { nil }) throws {
-    let stmt = StmtSyntax("\(header) {}")
-    guard let ifStmt = stmt.as(IfStmtSyntax.self) else {
-      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: stmt)
+    let expr = ExprSyntax("\(header) {}")
+    guard let ifExpr = expr.as(Self.self) else {
+      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: expr)
     }
-    self = ifStmt
+    self = ifExpr
     self.body = try CodeBlockSyntax(statements: bodyBuilder())
     self.elseBody = try elseBuilder().map { .codeBlock(CodeBlockSyntax(statements: $0)) }
     self.elseKeyword = elseBody != nil ? .keyword(.else) : nil
   }
 
-  init(_ header: PartialSyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemListSyntax, elseIf: IfStmtSyntax) throws {
-    let stmt = StmtSyntax("\(header) {}")
-    guard let ifStmt = stmt.as(IfStmtSyntax.self) else {
-      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: stmt)
+  init(_ header: PartialSyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemListSyntax, elseIf: IfExprSyntax) throws {
+    let expr = ExprSyntax("\(header) {}")
+    guard let ifExpr = expr.as(Self.self) else {
+      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: expr)
     }
-    self = ifStmt
+    self = ifExpr
     self.body = CodeBlockSyntax(statements: bodyBuilder())
-    self.elseBody = .ifStmt(elseIf)
+    self.elseBody = .ifExpr(elseIf)
     self.elseKeyword = elseBody != nil ? .keyword(.else) : nil
   }
 }

Tests/SwiftParserTest/StatementTests.swift

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