Merge pull request swiftlang#33570 from DougGregor/function-builders-throw

Author: swift-ci

lib/Sema/BuilderTransform.cpp

@@ -896,6 +896,26 @@ class BuilderClosureVisitor
     return finalForEachVar;
   }
 
+  /// Visit a throw statement, which never produces a result.
+  VarDecl *visitThrowStmt(ThrowStmt *throwStmt) {
+    Type exnType = ctx.getErrorDecl()->getDeclaredInterfaceType();
+    if (!exnType) {
+      hadError = true;
+    }
+
+    if (cs) {
+     SolutionApplicationTarget target(
+         throwStmt->getSubExpr(), dc, CTP_ThrowStmt, exnType,
+         /*isDiscarded=*/false);
+     if (cs->generateConstraints(target, FreeTypeVariableBinding::Disallow))
+       hadError = true;
+
+     cs->setSolutionApplicationTarget(throwStmt, target);
+   }
+
+    return nullptr;
+  }
+
   CONTROL_FLOW_STMT(Guard)
   CONTROL_FLOW_STMT(While)
   CONTROL_FLOW_STMT(DoCatch)
@@ -905,7 +925,6 @@ class BuilderClosureVisitor
   CONTROL_FLOW_STMT(Continue)
   CONTROL_FLOW_STMT(Fallthrough)
   CONTROL_FLOW_STMT(Fail)
-  CONTROL_FLOW_STMT(Throw)
   CONTROL_FLOW_STMT(PoundAssert)
 
 #undef CONTROL_FLOW_STMT
@@ -1141,6 +1160,14 @@ class BuilderClosureRewriter
       }
 
       if (auto stmt = node.dyn_cast<Stmt *>()) {
+        // "throw" statements produce no value. Transform them directly.
+        if (auto throwStmt = dyn_cast<ThrowStmt>(stmt)) {
+          if (auto newStmt = visitThrowStmt(throwStmt)) {
+            newElements.push_back(stmt);
+          }
+          continue;
+        }
+
         // Each statement turns into a (potential) temporary variable
         // binding followed by the statement itself.
         auto captured = takeCapturedStmt(stmt);
@@ -1429,6 +1456,22 @@ class BuilderClosureRewriter
         ctx, forEachStmt->getStartLoc(), outerBodySteps, newBody->getEndLoc());
   }
 
+  Stmt *visitThrowStmt(ThrowStmt *throwStmt) {
+    // Rewrite the error.
+    auto target = *solution.getConstraintSystem()
+        .getSolutionApplicationTarget(throwStmt);
+    if (auto result = rewriteTarget(target))
+      throwStmt->setSubExpr(result->getAsExpr());
+    else
+      return nullptr;
+
+    return throwStmt;
+  }
+
+  Stmt *visitThrowStmt(ThrowStmt *throwStmt, FunctionBuilderTarget target) {
+    llvm_unreachable("Throw statements produce no value");
+  }
+
 #define UNHANDLED_FUNCTION_BUILDER_STMT(STMT) \
   Stmt *visit##STMT##Stmt(STMT##Stmt *stmt, FunctionBuilderTarget target) { \
     llvm_unreachable("Function builders do not allow statement of kind " \
@@ -1446,7 +1489,6 @@ class BuilderClosureRewriter
   UNHANDLED_FUNCTION_BUILDER_STMT(Continue)
   UNHANDLED_FUNCTION_BUILDER_STMT(Fallthrough)
   UNHANDLED_FUNCTION_BUILDER_STMT(Fail)
-  UNHANDLED_FUNCTION_BUILDER_STMT(Throw)
   UNHANDLED_FUNCTION_BUILDER_STMT(PoundAssert)
 #undef UNHANDLED_FUNCTION_BUILDER_STMT
 };

test/Constraints/function_builder.swift

@@ -6,10 +6,6 @@ enum Either<T,U> {
   case second(U)
 }
 
-struct Do<T> {
-  var value: T
-}
-
 @_functionBuilder
 struct TupleBuilder {
   static func buildBlock<T1>(_ t1: T1) -> (T1) {
@@ -48,8 +44,8 @@ struct TupleBuilder {
   static func buildArray<T>(_ array: [T]) -> [T] { return array }
 }
 
-func tuplify<T>(_ cond: Bool, @TupleBuilder body: (Bool) -> T) {
-  print(body(cond))
+func tuplify<T>(_ cond: Bool, @TupleBuilder body: (Bool) throws -> T) rethrows {
+  print(try body(cond))
 }
 
 // CHECK: (17, 3.14159, "Hello, DSL", (["nested", "do"], 6), Optional((2.71828, ["if", "stmt"])))
@@ -753,3 +749,21 @@ let a = buildArray {
 // CHECK: ["1", "2"
 print(a)
 
+// Throwing in function builders.
+enum MyError: Error {
+  case boom
+}
+
+// CHECK: testThrow
+do {
+  print("testThrow")
+  try tuplify(true) { c in
+    "ready to throw"
+    throw MyError.boom
+  }
+} catch MyError.boom {
+  // CHECK: caught it!
+  print("caught it!")
+} catch {
+  fatalError("Threw something else?")
+}

test/Constraints/function_builder_diags.swift

@@ -623,3 +623,15 @@ struct MyView {
     ""
   }
 }
+
+// Make sure throwing function builder closures are implied.
+enum MyError: Error {
+  case boom
+}
+
+do {
+    tuplify(true) { c in // expected-error{{invalid conversion from throwing function of type '(Bool) throws -> String' to non-throwing function type '(Bool) -> String'}}
+    "testThrow"
+    throw MyError.boom
+  }
+}