Introduce 'do' expressions

Author: hamishknight

CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift

@@ -16,6 +16,7 @@ public enum ExperimentalFeature: String, CaseIterable {
   case referenceBindings
   case thenStatements
   case typedThrows
+  case doExpressions
 
   /// The name of the feature, which is used in the doc comment.
   public var featureName: String {
@@ -26,6 +27,8 @@ public enum ExperimentalFeature: String, CaseIterable {
       return "'then' statements"
     case .typedThrows:
       return "typed throws"
+    case .doExpressions:
+      return "'do' expressions"
     }
   }
 

CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift

@@ -740,6 +740,54 @@ public let EXPR_NODES: [Node] = [
     ]
   ),
 
+  Node(
+    kind: .doExpr,
+    base: .expr,
+    experimentalFeature: .doExpressions,
+    nameForDiagnostics: "'do' block",
+    documentation: """
+      A `do` block with one of more optional `catch` clauses.
+
+      This represents do blocks in both expression and statement postitions
+      (where the latter are wrapped in ExpressionStmtSyntax).
+
+      ### Examples
+
+      ```swift
+      do {
+        let x = 0
+        print(x)
+      }
+      ```
+
+      ```swift
+      let x = do {
+        try someThrowingFn()
+      } catch {
+        defaultValue
+      }
+      ```
+      """,
+    traits: [
+      "WithCodeBlock"
+    ],
+    children: [
+      Child(
+        name: "doKeyword",
+        kind: .token(choices: [.keyword(.do)])
+      ),
+      Child(
+        name: "body",
+        kind: .node(kind: .codeBlock),
+        nameForDiagnostics: "body"
+      ),
+      Child(
+        name: "catchClauses",
+        kind: .collection(kind: .catchClauseList, collectionElementName: "CatchClause", defaultsToEmpty: true)
+      ),
+    ]
+  ),
+
   Node(
     kind: .editorPlaceholderExpr,
     base: .expr,

CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift

@@ -107,6 +107,7 @@ public enum SyntaxNodeKind: String, CaseIterable {
   case discardStmt
   case documentationAttributeArgument
   case documentationAttributeArgumentList
+  case doExpr
   case doStmt
   case dynamicReplacementAttributeArguments
   case editorPlaceholderDecl

Sources/SwiftParser/Expressions.swift

@@ -20,7 +20,7 @@ extension TokenConsumer {
       backtrack.eat(handle)
 
       // These can be parsed as expressions with try/await.
-      if backtrack.at(anyIn: IfOrSwitch.self) != nil {
+      if backtrack.at(anyIn: SingleValueStatementExpression.self) != nil {
         return true
       }
       // Note we currently pass `preferExpr: false` to prefer diagnosing `try then`
@@ -525,21 +525,26 @@ extension Parser {
     flavor: ExprFlavor,
     pattern: PatternContext = .none
   ) -> 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)) {
+    // Try parse a single value statement as an expression (e.g do/if/switch).
+    // 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.
+    switch self.at(anyIn: SingleValueStatementExpression.self) {
+    case (.do, _)?:
       return RawExprSyntax(
-        parseSwitchExpression(switchHandle: .constant(.keyword(.switch)))
+        self.parseDoExpression(doHandle: .constant(.keyword(.do)))
       )
-    } else if self.at(.keyword(.if)) {
+    case (.if, _)?:
       return RawExprSyntax(
-        parseIfExpression(ifHandle: .constant(.keyword(.if)))
+        self.parseIfExpression(ifHandle: .constant(.keyword(.if)))
       )
+    case (.switch, _)?:
+      return RawExprSyntax(
+        self.parseSwitchExpression(switchHandle: .constant(.keyword(.switch)))
+      )
+    default:
+      break
     }
 
     switch self.at(anyIn: ExpressionPrefixOperator.self) {
@@ -2046,6 +2051,33 @@ extension Parser.Lookahead {
   }
 }
 
+// MARK: Do-Catch Expressions
+
+extension Parser {
+  /// Parse a do expression.
+  mutating func parseDoExpression(doHandle: RecoveryConsumptionHandle) -> RawDoExprSyntax {
+    assert(experimentalFeatures.contains(.doExpressions))
+    let (unexpectedBeforeDoKeyword, doKeyword) = self.eat(doHandle)
+    let body = self.parseCodeBlock(introducer: doKeyword)
+
+    // If the next token is 'catch', this is a 'do'/'catch'.
+    var elements = [RawCatchClauseSyntax]()
+    var loopProgress = LoopProgressCondition()
+    while self.at(.keyword(.catch)) && self.hasProgressed(&loopProgress) {
+      // Parse 'catch' clauses
+      elements.append(self.parseCatchClause())
+    }
+
+    return RawDoExprSyntax(
+      unexpectedBeforeDoKeyword,
+      doKeyword: doKeyword,
+      body: body,
+      catchClauses: RawCatchClauseListSyntax(elements: elements, arena: self.arena),
+      arena: self.arena
+    )
+  }
+}
+
 // MARK: Conditional Expressions
 
 extension Parser {

Sources/SwiftParser/Statements.swift

@@ -77,6 +77,19 @@ extension Parser {
     case (.repeat, let handle)?:
       return label(self.parseRepeatStatement(repeatHandle: handle), with: optLabel)
 
+    case (.do, let handle)?:
+      // If we have 'do' expressions enabled, we parse a DoExprSyntax, and wrap
+      // it in an ExpressionStmtSyntax.
+      if self.experimentalFeatures.contains(.doExpressions) {
+        let doExpr = self.parseDoExpression(doHandle: handle)
+        let doStmt = RawExpressionStmtSyntax(
+          expression: RawExprSyntax(doExpr),
+          arena: self.arena
+        )
+        return label(doStmt, with: optLabel)
+      }
+      // Otherwise parse a regular DoStmtSyntax.
+      return label(self.parseDoStatement(doHandle: handle), with: optLabel)
     case (.if, let handle)?:
       let ifExpr = self.parseIfExpression(ifHandle: handle)
       let ifStmt = RawExpressionStmtSyntax(
@@ -107,8 +120,6 @@ extension Parser {
       return label(self.parseThrowStatement(throwHandle: handle), with: optLabel)
     case (.defer, let handle)?:
       return label(self.parseDeferStatement(deferHandle: handle), with: optLabel)
-    case (.do, let handle)?:
-      return label(self.parseDoStatement(doHandle: handle), with: optLabel)
     case (.yield, let handle)?:
       return label(self.parseYieldStatement(yieldHandle: handle), with: optLabel)
     case (.then, let handle)? where experimentalFeatures.contains(.thenStatements):
@@ -634,8 +645,8 @@ extension Parser {
     if self.at(anyIn: NotReturnExprStart.self) != nil {
       return false
     }
-    // Allowed for if/switch expressions.
-    if self.at(anyIn: IfOrSwitch.self) != nil {
+    // Allowed for single value statement expressions, e.g do/if/switch.
+    if self.at(anyIn: SingleValueStatementExpression.self) != nil {
       return true
     }
     if self.atStartOfStatement(preferExpr: true) || self.atStartOfDeclaration() {

Sources/SwiftParser/TokenSpecSet.swift

@@ -754,12 +754,14 @@ enum ExpressionModifierKeyword: TokenSpecSet {
   }
 }
 
-enum IfOrSwitch: TokenSpecSet {
+enum SingleValueStatementExpression: TokenSpecSet {
+  case `do`
   case `if`
   case `switch`
 
   init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
     switch PrepareForKeywordMatch(lexeme) {
+    case TokenSpec(.do) where experimentalFeatures.contains(.doExpressions): self = .do
     case TokenSpec(.if): self = .if
     case TokenSpec(.switch): self = .switch
     default: return nil
@@ -768,6 +770,7 @@ enum IfOrSwitch: TokenSpecSet {
 
   var spec: TokenSpec {
     switch self {
+    case .do: return .keyword(.do)
     case .if: return .keyword(.if)
     case .switch: return .keyword(.switch)
     }
@@ -947,7 +950,7 @@ enum ExpressionStart: TokenSpecSet {
   case awaitTryMove(ExpressionModifierKeyword)
   case expressionPrefixOperator(ExpressionPrefixOperator)
   case primaryExpressionStart(PrimaryExpressionStart)
-  case ifOrSwitch(IfOrSwitch)
+  case singleValueStatement(SingleValueStatementExpression)
 
   init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
     if let subset = ExpressionModifierKeyword(lexeme: lexeme, experimentalFeatures: experimentalFeatures) {
@@ -956,8 +959,8 @@ enum ExpressionStart: TokenSpecSet {
       self = .expressionPrefixOperator(subset)
     } else if let subset = PrimaryExpressionStart(lexeme: lexeme, experimentalFeatures: experimentalFeatures) {
       self = .primaryExpressionStart(subset)
-    } else if let subset = IfOrSwitch(lexeme: lexeme, experimentalFeatures: experimentalFeatures) {
-      self = .ifOrSwitch(subset)
+    } else if let subset = SingleValueStatementExpression(lexeme: lexeme, experimentalFeatures: experimentalFeatures) {
+      self = .singleValueStatement(subset)
     } else {
       return nil
     }
@@ -967,15 +970,15 @@ enum ExpressionStart: TokenSpecSet {
     return ExpressionModifierKeyword.allCases.map(Self.awaitTryMove)
       + ExpressionPrefixOperator.allCases.map(Self.expressionPrefixOperator)
       + PrimaryExpressionStart.allCases.map(Self.primaryExpressionStart)
-      + IfOrSwitch.allCases.map(Self.ifOrSwitch)
+      + SingleValueStatementExpression.allCases.map(Self.singleValueStatement)
   }
 
   var spec: TokenSpec {
     switch self {
     case .awaitTryMove(let underlyingKind): return underlyingKind.spec
     case .expressionPrefixOperator(let underlyingKind): return underlyingKind.spec
     case .primaryExpressionStart(let underlyingKind): return underlyingKind.spec
-    case .ifOrSwitch(let underlyingKind): return underlyingKind.spec
+    case .singleValueStatement(let underlyingKind): return underlyingKind.spec
     }
   }
 }

Sources/SwiftParser/TopLevel.swift

@@ -186,7 +186,7 @@ extension Parser {
     if at(.keyword(.as)),
       let expr = stmt.as(RawExpressionStmtSyntax.self)?.expression
     {
-      if expr.is(RawIfExprSyntax.self) || expr.is(RawSwitchExprSyntax.self) {
+      if expr.is(RawDoExprSyntax.self) || expr.is(RawIfExprSyntax.self) || expr.is(RawSwitchExprSyntax.self) {
         let (op, rhs) = parseUnresolvedAsExpr(
           handle: .init(spec: .keyword(.as))
         )