xxx

Author: hamishknight

include/swift/AST/DiagnosticsSema.def

@@ -1234,6 +1234,9 @@ ERROR(single_value_stmt_must_be_unlabeled,none,
 ERROR(if_expr_must_be_syntactically_exhaustive,none,
       "'if' must have an unconditional 'else' to be used as expression",
       ())
+ERROR(do_catch_expr_must_be_syntactically_exhaustive,none,
+      "'do catch' must have an unconditional 'catch' to be used as expression",
+      ())
 ERROR(single_value_stmt_branch_empty,none,
       "expected expression in branch of '%0' expression",
       (StmtKind))

include/swift/AST/Expr.h

@@ -6119,7 +6119,7 @@ class KeyPathDotExpr : public Expr {
 class SingleValueStmtExpr : public Expr {
 public:
   enum class Kind {
-    If, Switch
+    If, Switch, Do, DoCatch
   };
 
 private:

include/swift/AST/Stmt.h

@@ -1418,6 +1418,9 @@ class DoCatchStmt final
     return {getTrailingObjects<CaseStmt *>(), Bits.DoCatchStmt.NumCatches};
   }
 
+  /// Retrieve the complete set of branches for this do-catch statement.
+  ArrayRef<Stmt *> getBranches(SmallVectorImpl<Stmt *> &scratch) const;
+
   /// Does this statement contain a syntactically exhaustive catch
   /// clause?
   ///

include/swift/AST/TypeCheckRequests.h

@@ -3903,6 +3903,10 @@ class IsSingleValueStmtResult {
     /// The statement is an 'if' statement without an unconditional 'else'.
     NonExhaustiveIf,
 
+    /// The statement is a 'do catch' statement without an unconditional
+    /// 'catch'.
+    NonExhaustiveDoCatch,
+
     /// There is no branch that produces a resulting value.
     NoResult,
 
@@ -3959,6 +3963,9 @@ class IsSingleValueStmtResult {
   static IsSingleValueStmtResult nonExhaustiveIf() {
     return IsSingleValueStmtResult(Kind::NonExhaustiveIf);
   }
+  static IsSingleValueStmtResult nonExhaustiveDoCatch() {
+    return IsSingleValueStmtResult(Kind::NonExhaustiveDoCatch);
+  }
   static IsSingleValueStmtResult noResult() {
     return IsSingleValueStmtResult(Kind::NoResult);
   }

include/swift/Basic/Features.def

@@ -229,6 +229,9 @@ EXPERIMENTAL_FEATURE(PlaygroundExtendedCallbacks, true)
 /// Enable 'then' statements.
 EXPERIMENTAL_FEATURE(ThenStatements, false)
 
+/// Enable 'do' expressions.
+EXPERIMENTAL_FEATURE(DoExpressions, false)
+
 /// Enable the `@_rawLayout` attribute.
 EXPERIMENTAL_FEATURE(RawLayout, true)
 

lib/AST/ASTPrinter.cpp

@@ -3529,6 +3529,10 @@ static bool usesFeatureThenStatements(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureDoExpressions(Decl *decl) {
+  return false;
+}
+
 static bool usesFeatureNewCxxMethodSafetyHeuristics(Decl *decl) {
   return decl->hasClangNode();
 }

lib/AST/ASTVerifier.cpp

@@ -1222,6 +1222,7 @@ class Verifier : public ASTWalker {
         break;
       case Kind::UnterminatedBranches:
       case Kind::NonExhaustiveIf:
+      case Kind::NonExhaustiveDoCatch:
       case Kind::UnhandledStmt:
       case Kind::CircularReference:
       case Kind::HasLabel:

lib/AST/Expr.cpp

@@ -2488,6 +2488,8 @@ SingleValueStmtExpr *SingleValueStmtExpr::create(ASTContext &ctx, Stmt *S,
 
 SingleValueStmtExpr *SingleValueStmtExpr::createWithWrappedBranches(
     ASTContext &ctx, Stmt *S, DeclContext *DC, bool mustBeExpr) {
+  assert(!isa<DoStmt>(S) || !isa<DoCatchStmt>(S) ||
+         ctx.LangOpts.hasFeature(Feature::DoExpressions));
   auto *SVE = create(ctx, S, DC);
 
   // Attempt to wrap any branches that can be wrapped.
@@ -2499,12 +2501,15 @@ SingleValueStmtExpr *SingleValueStmtExpr::createWithWrappedBranches(
 
     if (auto *S = BS->getSingleActiveStatement()) {
       if (mustBeExpr) {
-        // If this must be an expression, we can eagerly wrap any exhaustive if
-        // and switch branch.
+        // If this must be an expression, we can eagerly wrap any exhaustive if,
+        // switch, and do statement.
         if (auto *IS = dyn_cast<IfStmt>(S)) {
           if (!IS->isSyntacticallyExhaustive())
             continue;
-        } else if (!isa<SwitchStmt>(S)) {
+        } else if (auto *DCS = dyn_cast<DoCatchStmt>(S)) {
+          if (!DCS->isSyntacticallyExhaustive())
+            continue;
+        } else if (!isa<SwitchStmt>(S) && !isa<DoStmt>(S)) {
           continue;
         }
       } else {
@@ -2587,18 +2592,28 @@ SingleValueStmtExpr::Kind SingleValueStmtExpr::getStmtKind() const {
     return Kind::If;
   case StmtKind::Switch:
     return Kind::Switch;
+  case StmtKind::Do:
+    return Kind::Do;
+  case StmtKind::DoCatch:
+    return Kind::DoCatch;
   default:
     llvm_unreachable("Unhandled kind!");
   }
 }
 
 ArrayRef<Stmt *>
 SingleValueStmtExpr::getBranches(SmallVectorImpl<Stmt *> &scratch) const {
+  assert(scratch.empty());
   switch (getStmtKind()) {
   case Kind::If:
     return cast<IfStmt>(getStmt())->getBranches(scratch);
   case Kind::Switch:
     return cast<SwitchStmt>(getStmt())->getBranches(scratch);
+  case Kind::Do:
+    scratch.push_back(cast<DoStmt>(getStmt())->getBody());
+    return scratch;
+  case Kind::DoCatch:
+    return cast<DoCatchStmt>(getStmt())->getBranches(scratch);
   }
   llvm_unreachable("Unhandled case in switch!");
 }

lib/AST/Stmt.cpp

@@ -854,6 +854,15 @@ SwitchStmt::getBranches(SmallVectorImpl<Stmt *> &scratch) const {
   return scratch;
 }
 
+ArrayRef<Stmt *>
+DoCatchStmt::getBranches(SmallVectorImpl<Stmt *> &scratch) const {
+  assert(scratch.empty());
+  scratch.push_back(getBody());
+  for (auto *CS : getCatches())
+    scratch.push_back(CS->getBody());
+  return scratch;
+}
+
 // See swift/Basic/Statistic.h for declaration: this enables tracing Stmts, is
 // defined here to avoid too much layering violation / circular linkage
 // dependency.

lib/ASTGen/Sources/ASTGen/SourceFile.swift

@@ -35,7 +35,9 @@ extension Parser.ExperimentalFeatures {
         insert(feature)
       }
     }
+    mapFeature(.ReferenceBindings, to: .referenceBindings)
     mapFeature(.ThenStatements, to: .thenStatements)
+    mapFeature(.DoExpressions, to: .doExpressions)
   }
 }
 

lib/Parse/ParseExpr.cpp

@@ -584,11 +584,13 @@ ParserResult<Expr> Parser::parseExprUnary(Diag<> Message, bool isExprBasic) {
   // 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
-  // parseExprUnary as we don't allow postfix syntax to hang off such
+  // Try parse 'if', 'switch', and 'do' as expressions. Note we do this here
+  // in parseExprUnary 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 (Tok.isAny(tok::kw_if, tok::kw_switch)) {
+  if (Tok.isAny(tok::kw_if, tok::kw_switch) ||
+      (Tok.is(tok::kw_do) &&
+       Context.LangOpts.hasFeature(Feature::DoExpressions))) {
     auto Result = parseStmt();
     Expr *E = nullptr;
     if (Result.isNonNull()) {

lib/Parse/ParseStmt.cpp

@@ -78,8 +78,10 @@ bool Parser::isStartOfStmt(bool preferExpr) {
     // "try" cannot actually start any statements, but we parse it there for
     // better recovery in cases like 'try return'.
 
-    // For 'if' and 'switch' we can parse as an expression.
-    if (peekToken().isAny(tok::kw_if, tok::kw_switch)) {
+    // For 'if', 'switch', and 'do' we can parse as an expression.
+    if (peekToken().isAny(tok::kw_if, tok::kw_switch) ||
+        (peekToken().is(tok::kw_do) &&
+         Context.LangOpts.hasFeature(Feature::DoExpressions))) {
       return false;
     }
     Parser::BacktrackingScope backtrack(*this);
@@ -157,7 +159,10 @@ ParserStatus Parser::parseExprOrStmt(ASTNode &Result) {
       // 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 ((isa<IfStmt>(S) || isa<SwitchStmt>(S)) && Tok.is(tok::kw_as)) {
+      if ((isa<IfStmt>(S) || isa<SwitchStmt>(S) || 
+           ((isa<DoStmt>(S) || isa<DoCatchStmt>(S)) &&
+            Context.LangOpts.hasFeature(Feature::DoExpressions)))
+          && Tok.is(tok::kw_as)) {
         auto *SVE = SingleValueStmtExpr::createWithWrappedBranches(
             Context, S, CurDeclContext, /*mustBeExpr*/ true);
         auto As = parseExprAs();
@@ -778,8 +783,10 @@ ParserResult<Stmt> Parser::parseStmtReturn(SourceLoc tryLoc) {
                   tok::pound_else, tok::pound_elseif)) {
       return false;
     }
-    // Allowed for if/switch expressions.
-    if (Tok.isAny(tok::kw_if, tok::kw_switch)) {
+    // Allowed for if/switch/do expressions.
+    if (Tok.isAny(tok::kw_if, tok::kw_switch) ||
+        (Tok.is(tok::kw_do) &&
+         Context.LangOpts.hasFeature(Feature::DoExpressions))) {
       return true;
     }
     if (isStartOfStmt(/*preferExpr*/ true) || isStartOfSwiftDecl())

lib/Sema/CSSyntacticElement.cpp

@@ -999,14 +999,23 @@ class SyntacticElementConstraintGenerator
 
     SmallVector<ElementInfo, 4> elements;
 
-    // First, let's record a body of `do` statement.
-    elements.push_back(makeElement(doStmt->getBody(), doLoc));
+    // First, let's record a body of `do` statement. Note we need to add a
+    // SyntaticElement locator path element here to avoid treating the inner
+    // brace conjunction as being isolated if 'doLoc' is for an isolated
+    // conjunction (as is the case with 'do' expressions).
+    auto *doBodyLoc = cs.getConstraintLocator(
+        doLoc, LocatorPathElt::SyntacticElement(doStmt->getBody()));
+    elements.push_back(makeElement(doStmt->getBody(), doBodyLoc));
 
     // After that has been type-checked, let's switch to
     // individual `catch` statements.
     for (auto *catchStmt : doStmt->getCatches())
       elements.push_back(makeElement(catchStmt, doLoc));
 
+    // Inject a join if we have one.
+    if (auto *join = context.ElementJoin.getPtrOrNull())
+      elements.push_back(makeJoinElement(cs, join, locator));
+
     createConjunction(elements, doLoc);
   }
 
@@ -1195,6 +1204,10 @@ class SyntacticElementConstraintGenerator
           contextInfo.value_or(ContextualTypeInfo()), isDiscarded));
     }
 
+    // Inject a join if we have one.
+    if (auto *join = context.ElementJoin.getPtrOrNull())
+      elements.push_back(makeJoinElement(cs, join, locator));
+
     createConjunction(elements, locator);
   }
 

lib/Sema/ConstraintLocator.cpp

@@ -661,7 +661,8 @@ bool ConstraintLocator::isForSingleValueStmtConjunction() const {
 }
 
 bool ConstraintLocator::isForSingleValueStmtConjunctionOrBrace() const {
-  if (!isExpr<SingleValueStmtExpr>(getAnchor()))
+  auto *SVE = getAsExpr<SingleValueStmtExpr>(getAnchor());
+  if (!SVE)
     return false;
 
   auto path = getPath();
@@ -672,11 +673,17 @@ bool ConstraintLocator::isForSingleValueStmtConjunctionOrBrace() const {
       continue;
     }
 
-    // Ignore a SyntaticElement path element for a case statement of a switch.
+    // Ignore a SyntaticElement path element for a case statement of a switch,
+    // or the catch of a do-catch, or the brace of a do-statement.
     if (auto elt = path.back().getAs<LocatorPathElt::SyntacticElement>()) {
       if (elt->getElement().isStmt(StmtKind::Case)) {
         path = path.drop_back();
-        continue;
+        break;
+      }
+      if (elt->getElement().isStmt(StmtKind::Brace) &&
+          isa<DoCatchStmt>(SVE->getStmt())) {
+        path = path.drop_back();
+        break;
       }
     }
     break;

lib/Sema/MiscDiagnostics.cpp

@@ -3947,6 +3947,11 @@ class SingleValueStmtUsageChecker final : public ASTWalker {
                        diag::if_expr_must_be_syntactically_exhaustive);
         break;
       }
+      case IsSingleValueStmtResult::Kind::NonExhaustiveDoCatch: {
+        Diags.diagnose(S->getStartLoc(),
+                       diag::do_catch_expr_must_be_syntactically_exhaustive);
+        break;
+      }
       case IsSingleValueStmtResult::Kind::HasLabel: {
         // FIXME: We should offer a fix-it to remove (currently we don't track
         // the colon SourceLoc).

lib/Sema/TypeCheckStmt.cpp

@@ -2997,14 +2997,11 @@ areBranchesValidForSingleValueStmt(Evaluator &eval, ArrayRef<Stmt *> branches) {
 
 IsSingleValueStmtResult
 IsSingleValueStmtRequest::evaluate(Evaluator &eval, const Stmt *S) const {
-  if (!isa<IfStmt>(S) && !isa<SwitchStmt>(S))
-    return IsSingleValueStmtResult::unhandledStmt();
-
   // Statements must be unlabeled.
-  auto *LS = cast<LabeledStmt>(S);
-  if (LS->getLabelInfo())
-    return IsSingleValueStmtResult::hasLabel();
-
+  if (auto *LS = dyn_cast<LabeledStmt>(S)) {
+    if (LS->getLabelInfo())
+      return IsSingleValueStmtResult::hasLabel();
+  }
   if (auto *IS = dyn_cast<IfStmt>(S)) {
     // Must be exhaustive.
     if (!IS->isSyntacticallyExhaustive())
@@ -3017,7 +3014,17 @@ IsSingleValueStmtRequest::evaluate(Evaluator &eval, const Stmt *S) const {
     SmallVector<Stmt *, 4> scratch;
     return areBranchesValidForSingleValueStmt(eval, SS->getBranches(scratch));
   }
-  llvm_unreachable("Unhandled case");
+  if (auto *DS = dyn_cast<DoStmt>(S))
+    return areBranchesValidForSingleValueStmt(eval, DS->getBody());
+
+  if (auto *DCS = dyn_cast<DoCatchStmt>(S)) {
+    if (!DCS->isSyntacticallyExhaustive())
+      return IsSingleValueStmtResult::nonExhaustiveDoCatch();
+
+    SmallVector<Stmt *, 4> scratch;
+    return areBranchesValidForSingleValueStmt(eval, DCS->getBranches(scratch));
+  }
+  return IsSingleValueStmtResult::unhandledStmt();
 }
 
 void swift::checkUnknownAttrRestrictions(

test/SILGen/do_expr.swift

@@ -0,0 +1,55 @@
+// RUN: %target-swift-emit-silgen -enable-experimental-feature ThenStatements -enable-experimental-feature DoExpressions %s | %FileCheck %s
+// RUN: %target-swift-emit-ir -enable-experimental-feature ThenStatements -enable-experimental-feature DoExpressions %s
+
+// Required for experimental features
+// REQUIRES: asserts
+
+@discardableResult
+func throwsError(_ x: Int = 0) throws -> Int { 0 }
+
+func test1() -> Int {
+  do { 5 }
+}
+
+func test2() -> Int {
+  return do { 5 }
+}
+
+func test3() -> Int {
+  let x = do { 5 }
+  return x
+}
+
+func test4() -> Int {
+  do { then 5 }
+}
+
+func test5() -> Int {
+  let x = do { (); then 5 }
+  return x
+}
+
+func test6(_ x: Bool) -> Int {
+  let x = do {
+    let y = 0
+    try throwsError()
+    then y
+  } catch {
+    7
+  }
+  return x
+}
+
+func test7() throws -> Int {
+  let x = do {
+    let y = 0
+    then try throwsError(y)
+  } catch _ where .random() {
+    then try throwsError()
+  } catch {
+    8
+  }
+  return x
+}
+
+// CHECK: test1

test/expr/unary/if_expr.swift

@@ -933,6 +933,7 @@ func continue1() -> Int {
 func return1() -> Int {
   // Make sure we always reject a return.
   let i = if .random() {
+    ()
     do {
       for _ in [0] {
         while true {