[Multi-expression closures] Add support for 'switch' and 'fallthrough' statements.

Author: DougGregor

lib/Sema/CSClosure.cpp

@@ -209,14 +209,60 @@ class ClosureConstraintGenerator
     cs.setSolutionApplicationTarget(poundAssertStmt, target);
   }
 
+  void visitSwitchStmt(SwitchStmt *switchStmt) {
+    // FIXME: Very similar to BuilderTransform's visitSwitchStmt. Unify them.
+
+    // Generate constraints for the subject expression, and capture its
+    // type for use in matching the various patterns.
+    Expr *subjectExpr = switchStmt->getSubjectExpr();
+    ASTContext &ctx = cs.getASTContext();
+
+    // Form a one-way constraint to prevent backward propagation.
+    subjectExpr = new (ctx) OneWayExpr(subjectExpr);
+
+    // FIXME: Add contextual type purpose for switch subjects?
+    SolutionApplicationTarget target(
+        subjectExpr, closure, CTP_Unused, Type(), /*isDiscarded=*/false);
+    if (cs.generateConstraints(target, FreeTypeVariableBinding::Disallow)) {
+      hadError = true;
+      return;
+    }
+
+    cs.setSolutionApplicationTarget(switchStmt, target);
+    subjectExpr = target.getAsExpr();
+    assert(subjectExpr && "Must have a subject expression here");
+
+    // Visit the raw cases.
+    for (auto rawCase : switchStmt->getRawCases()) {
+      if (auto decl = rawCase.dyn_cast<Decl *>())
+        visitDecl(decl);
+      else
+        visitCaseStmt(cast<CaseStmt>(rawCase.get<Stmt *>()), subjectExpr);
+    }
+  }
+
+  void visitCaseStmt(CaseStmt *caseStmt, Expr *subjectExpr) {
+    auto locator = cs.getConstraintLocator(
+        subjectExpr, LocatorPathElt::ContextualType());
+    Type subjectType = cs.getType(subjectExpr);
+
+    if (cs.generateConstraints(caseStmt, closure, subjectType, locator)) {
+      hadError = true;
+      return;
+    }
+
+    // Visit the body.
+    visit(caseStmt->getBody());
+  }
+
+  void visitFallthroughStmt(FallthroughStmt *fallthroughStmt) { }
+
 #define UNSUPPORTED_STMT(STMT) void visit##STMT##Stmt(STMT##Stmt *) { \
       llvm_unreachable("Unsupported statement kind " #STMT);          \
   }
   UNSUPPORTED_STMT(Yield)
   UNSUPPORTED_STMT(DoCatch)
-  UNSUPPORTED_STMT(Switch)
   UNSUPPORTED_STMT(Case)
-  UNSUPPORTED_STMT(Fallthrough)
   UNSUPPORTED_STMT(Fail)
 #undef UNSUPPORTED_STMT
 };
@@ -503,14 +549,68 @@ class ClosureConstraintApplication
     return poundAssertStmt;
   }
 
+  ASTNode visitSwitchStmt(SwitchStmt *switchStmt) {
+    ConstraintSystem &cs = solution.getConstraintSystem();
+
+    // Rewrite the switch subject.
+    auto subjectTarget =
+        rewriteTarget(*cs.getSolutionApplicationTarget(switchStmt));
+    if (subjectTarget) {
+      switchStmt->setSubjectExpr(subjectTarget->getAsExpr());
+    } else {
+      hadError = true;
+    }
+
+    // Visit the raw cases.
+    bool limitExhaustivityChecks = false;
+    for (auto rawCase : switchStmt->getRawCases()) {
+      if (auto decl = rawCase.dyn_cast<Decl *>()) {
+        visitDecl(decl);
+        continue;
+      }
+
+      auto caseStmt = cast<CaseStmt>(rawCase.get<Stmt *>());
+      visitCaseStmt(caseStmt);
+
+      // Check restrictions on '@unknown'.
+      if (caseStmt->hasUnknownAttr()) {
+        checkUnknownAttrRestrictions(
+            cs.getASTContext(), caseStmt, limitExhaustivityChecks);
+      }
+    }
+
+    TypeChecker::checkSwitchExhaustiveness(
+        switchStmt, closure, limitExhaustivityChecks);
+
+    return switchStmt;
+  }
+
+  ASTNode visitCaseStmt(CaseStmt *caseStmt) {
+    // Translate the patterns and guard expressions for each case label item.
+    for (auto &caseLabelItem : caseStmt->getMutableCaseLabelItems()) {
+      SolutionApplicationTarget caseLabelTarget(&caseLabelItem, closure);
+      if (!rewriteTarget(caseLabelTarget)) {
+        hadError = true;
+      }
+    }
+
+    // Translate the body.
+    auto newBody = visit(caseStmt->getBody());
+    caseStmt->setBody(newBody.get<Stmt *>());
+    return caseStmt;
+  }
+
+  ASTNode visitFallthroughStmt(FallthroughStmt *fallthroughStmt) {
+    if (checkFallthroughStmt(closure, fallthroughStmt))
+      hadError = true;
+    return fallthroughStmt;
+  }
+
 #define UNSUPPORTED_STMT(STMT) ASTNode visit##STMT##Stmt(STMT##Stmt *) { \
       llvm_unreachable("Unsupported statement kind " #STMT);          \
   }
   UNSUPPORTED_STMT(Yield)
   UNSUPPORTED_STMT(DoCatch)
-  UNSUPPORTED_STMT(Switch)
-  UNSUPPORTED_STMT(Case)
-  UNSUPPORTED_STMT(Fallthrough)
   UNSUPPORTED_STMT(Fail)
 #undef UNSUPPORTED_STMT
 

lib/Sema/TypeCheckStmt.cpp

@@ -616,17 +616,21 @@ static void checkFallthroughPatternBindingsAndTypes(
 /// \returns true if an error occurred.
 static bool checkFallthroughStmt(
     DeclContext *dc, FallthroughStmt *stmt,
-    CaseStmt *oldFallthroughSource, CaseStmt *oldFallthroughDest) {
+    CaseStmt *oldFallthroughSource, CaseStmt *oldFallthroughDest,
+    bool allowOldInfo) {
   CaseStmt *fallthroughSource;
   CaseStmt *fallthroughDest;
   ASTContext &ctx = dc->getASTContext();
   if (ctx.LangOpts.EnableASTScopeLookup) {
     auto sourceFile = dc->getParentSourceFile();
     std::tie(fallthroughSource, fallthroughDest) =
         ASTScope::lookupFallthroughSourceAndDest(sourceFile, stmt->getLoc());
-    assert(fallthroughSource == oldFallthroughSource);
-    assert(fallthroughDest == oldFallthroughDest);
+    assert(!allowOldInfo || fallthroughSource == oldFallthroughSource);
+    assert(!allowOldInfo || fallthroughDest == oldFallthroughDest);
   } else {
+    if (!allowOldInfo)
+      return false;
+
     fallthroughSource = oldFallthroughSource;
     fallthroughDest = oldFallthroughDest;
   }
@@ -647,6 +651,11 @@ static bool checkFallthroughStmt(
   return false;
 }
 
+bool swift::checkFallthroughStmt(DeclContext *dc, FallthroughStmt *stmt) {
+  return ::checkFallthroughStmt(
+      dc, stmt, nullptr, nullptr, /*allowOldInfo=*/false);
+}
+
 namespace {
 class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
 public:
@@ -1079,7 +1088,8 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
   }
 
   Stmt *visitFallthroughStmt(FallthroughStmt *S) {
-    if (checkFallthroughStmt(DC, S, FallthroughSource, FallthroughDest))
+    if (::checkFallthroughStmt(DC, S, FallthroughSource, FallthroughDest,
+                               /*allowOldInfo=*/true))
       return nullptr;
 
     return S;

lib/Sema/TypeChecker.h

@@ -1375,6 +1375,11 @@ LabeledStmt *findBreakOrContinueStmtTarget(
     bool isContinue, DeclContext *dc,
     ArrayRef<LabeledStmt *> oldActiveLabeledStmts);
 
+/// Check the correctness of a 'fallthrough' statement.
+///
+/// \returns true if an error occurred.
+bool checkFallthroughStmt(DeclContext *dc, FallthroughStmt *stmt);
+
 /// Check for restrictions on the use of the @unknown attribute on a
 /// case statement.
 void checkUnknownAttrRestrictions(

test/expr/closure/multi_statement.swift

@@ -12,9 +12,15 @@ enum MyError: Error {
   case featureIsTooCool
 }
 
+enum State {
+  case suspended
+  case partial(Int, Int)
+  case finished
+}
+
 func random(_: Int) -> Bool { return false }
 
-func mapWithMoreStatements(ints: [Int]) throws {
+func mapWithMoreStatements(ints: [Int], state: State) throws {
   let _ = try ints.map { i in
     guard var actualValue = maybeGetValue(i) else {
       return String(0)
@@ -51,6 +57,19 @@ func mapWithMoreStatements(ints: [Int]) throws {
         continue
       }
 
+      switch (state, j) {
+      case (.suspended, 0):
+        print("something")
+        fallthrough
+      case (.finished, 0):
+        print("something else")
+
+      case (.partial(let current, let end), let j):
+        print("\(current) of \(end): \(j)")
+
+      default:
+        print("so, here we are")
+      }
       print("even")
       throw MyError.featureIsTooCool
     }