[Typed throws] Terminate with an error message for typed try! failures.

Author: DougGregor

include/swift/AST/KnownDecls.def

@@ -65,6 +65,7 @@ FUNC_DECL(BridgeAnyObjectToAny,
 FUNC_DECL(ConvertToAnyHashable, "_convertToAnyHashable")
 
 FUNC_DECL(DiagnoseUnexpectedError, "_unexpectedError")
+FUNC_DECL(DiagnoseUnexpectedErrorTyped, "_unexpectedErrorTyped")
 FUNC_DECL(DiagnoseUnexpectedNilOptional, "_diagnoseUnexpectedNilOptional")
 FUNC_DECL(DiagnoseUnexpectedEnumCase, "_diagnoseUnexpectedEnumCase")
 FUNC_DECL(DiagnoseUnexpectedEnumCaseValue, "_diagnoseUnexpectedEnumCaseValue")

lib/SILGen/SILGenExpr.cpp

@@ -1148,21 +1148,27 @@ SILGenFunction::ForceTryEmission::ForceTryEmission(SILGenFunction &SGF,
   // Set up a "catch" block for when an error occurs.
   SILBasicBlock *catchBB = SGF.createBasicBlock(FunctionSection::Postmatter);
 
+  SILValue indirectError;
   auto &errorTL = SGF.getTypeLowering(loc->getThrownError());
   if (!errorTL.isAddressOnly()) {
     (void) catchBB->createPhiArgument(errorTL.getLoweredType(),
                                       OwnershipKind::Owned);
+  } else {
+    indirectError = SGF.B.createAllocStack(loc, errorTL.getLoweredType());
+    SGF.enterDeallocStackCleanup(indirectError);
+
   }
 
   SGF.ThrowDest = JumpDest(catchBB, SGF.Cleanups.getCleanupsDepth(),
                            CleanupLocation(loc),
-                           ThrownErrorInfo::forDiscard());
+                           ThrownErrorInfo(indirectError, /*discard=*/true));
 }
 
 void SILGenFunction::ForceTryEmission::finish() {
   assert(Loc && "emission already finished");
 
   auto catchBB = SGF.ThrowDest.getBlock();
+  auto indirectError = SGF.ThrowDest.getThrownError().IndirectErrorResult;
   SGF.ThrowDest = OldThrowDest;
 
   // If there are no uses of the catch block, just drop it.
@@ -1175,29 +1181,64 @@ void SILGenFunction::ForceTryEmission::finish() {
     ASTContext &ctx = SGF.getASTContext();
 
     // Consume the thrown error.
+    ManagedValue error;
     if (catchBB->getNumArguments() == 1) {
-      auto error = ManagedValue::forForwardedRValue(SGF, catchBB->getArgument(0));
-
-      // FIXME: for typed throws, we need a new version of this entry point that
-      // takes a generic rather than an existential.
-      if (error.getType() == SILType::getExceptionType(ctx)) {
-        if (auto diagnoseError = ctx.getDiagnoseUnexpectedError()) {
-          auto args = SGF.emitSourceLocationArgs(Loc->getExclaimLoc(), Loc);
-
-          SGF.emitApplyOfLibraryIntrinsic(
-                  Loc,
-                  diagnoseError,
-                  SubstitutionMap(),
-                  {
-                    error,
-                    args.filenameStartPointer,
-                    args.filenameLength,
-                    args.filenameIsAscii,
-                    args.line
-                  },
-                  SGFContext());
+      error = ManagedValue::forForwardedRValue(SGF, catchBB->getArgument(0));
+    } else {
+      error = ManagedValue::forForwardedRValue(SGF, indirectError);
+    }
+
+    // If we have 'any Error', use the older entrypoint that takes an
+    // existential error directly. Otherwise, use the newer generic entrypoint.
+    auto diagnoseError = error.getType().getASTType()->isErrorExistentialType()
+      ? ctx.getDiagnoseUnexpectedError()
+      : ctx.getDiagnoseUnexpectedErrorTyped();
+    if (diagnoseError) {
+      SILValue tmpBuffer;
+      auto args = SGF.emitSourceLocationArgs(Loc->getExclaimLoc(), Loc);
+
+      SubstitutionMap subMap;
+      if (auto genericSig = diagnoseError->getGenericSignature()) {
+        // FIXME: The conformance of the thrown error type to the Error
+        // protocol should be provided to us by the type checker.
+        subMap = SubstitutionMap::get(
+            genericSig, [&](SubstitutableType *dependentType) {
+              return error.getType().getObjectType().getASTType();
+            }, LookUpConformanceInModule(SGF.getModule().getSwiftModule()));
+
+        // Generic errors are passed indirectly.
+        #if true
+        if (!error.getType().isAddress()) {
+          auto *tmp = SGF.B.createAllocStack(Loc,
+                                             error.getType().getObjectType(),
+                                             llvm::None);
+          error.forwardInto(SGF, Loc, tmp);
+          error = ManagedValue::forForwardedRValue(SGF, tmp);
+
+          tmpBuffer = tmp;
         }
+        #else
+        error = SGF.emitSubstToOrigValue(Loc, error,
+                                         AbstractionPattern::getOpaque(),
+                                         error.getType().getASTType());
+        #endif
       }
+
+      SGF.emitApplyOfLibraryIntrinsic(
+              Loc,
+              diagnoseError,
+              subMap,
+              {
+                error,
+                args.filenameStartPointer,
+                args.filenameLength,
+                args.filenameIsAscii,
+                args.line
+              },
+              SGFContext());
+
+      if (tmpBuffer)
+        SGF.B.createDeallocStack(Loc, tmpBuffer);
     }
 
     SGF.B.createUnreachable(Loc);

stdlib/public/core/ErrorType.swift

@@ -200,6 +200,28 @@ public func _unexpectedError(
   #endif
 }
 
+/// Invoked by the compiler when the subexpression of a `try!` expression
+/// throws an error.
+@_silgen_name("swift_unexpectedErrorTyped")
+@_alwaysEmitIntoClient
+@inlinable
+public func _unexpectedErrorTyped(
+  _ error: __owned some Error,
+  filenameStart: Builtin.RawPointer,
+  filenameLength: Builtin.Word,
+  filenameIsASCII: Builtin.Int1,
+  line: Builtin.Word
+) {
+  #if !$Embedded
+  _unexpectedError(
+    error, filenameStart: filenameStart, filenameLength: filenameLength,
+    filenameIsASCII: filenameIsASCII, line: line
+  )
+  #else
+  Builtin.int_trap()
+  #endif
+}
+
 /// Invoked by the compiler when code at top level throws an uncaught error.
 @_silgen_name("swift_errorInMain")
 public func _errorInMain(_ error: Error) {

test/SILGen/typed_throws.swift

@@ -26,7 +26,7 @@ func throwsConcrete() throws(MyError) {
 func rethrowConcrete() throws(MyError) {
   // CHECK: try_apply [[FN:%[0-9]+]]() : $@convention(thin) () -> @error MyError, normal [[NORMALBB:bb[0-9]+]], error [[ERRORBB:bb[0-9]+]]
   // CHECK: [[ERRORBB]]([[ERROR:%[0-9]+]] : $MyError)
-  // CHECK-NEXT: throw [[ERROR]] : $MyError 
+  // CHECK-NEXT: throw [[ERROR]] : $MyError
   try throwsConcrete()
 }
 // CHECK-LABEL: sil hidden [ossa] @$s12typed_throws29rethrowConcreteAndExistentialyyKF
@@ -152,6 +152,11 @@ func forceTryDifferent() throws(MyError) {
   // CHECK: [[NORMAL_BB]]([[RESULT:%.*]] : $()):
   // CHECK: return
   // CHECK: [[ERROR_BB]]([[ERROR:%.*]] : $MyBigError):
+  // CHECK: [[MATERIALIZED_ERROR:%.*]] = alloc_stack $MyBigError
+  // CHECK: store [[ERROR]] to [trivial] [[MATERIALIZED_ERROR]] : $*MyBigError
+  // CHECK: [[UNEXPECTED_FN:%.*]] = function_ref @swift_unexpectedErrorTyped : $@convention(thin) <τ_0_0 where τ_0_0 : Error> (@in τ_0_0, Builtin.RawPointer, Builtin.Word, Builtin.Int1, Builtin.Word) -> ()
+  // CHECK-NEXT: apply [[UNEXPECTED_FN]]<MyBigError>([[MATERIALIZED_ERROR]], {{[^)]*}}) : $@convention(thin) <τ_0_0 where τ_0_0 : Error> (@in τ_0_0, Builtin.RawPointer, Builtin.Word, Builtin.Int1, Builtin.Word) -> ()
+  // CHECK-NEXT: dealloc_stack [[MATERIALIZED_ERROR]]
   // CHECK-NEXT: unreachable
   try! throwsMyBigError()
 }

test/SILGen/typed_throws_generic.swift

@@ -78,9 +78,10 @@ public func genericForceTry<E>(fn: () throws(E) -> ()) {
 
 // CHECK-LABEL: sil [ossa] @$s20typed_throws_generic0C8ForceTry2fnyyyxYKXE_ts5ErrorRzlF : $@convention(thin) <E where E : Error> (@guaranteed @noescape @callee_guaranteed @substituted <τ_0_0> () -> @error_indirect τ_0_0 for <E>) -> () {
 // CHECK: bb0(%0 : @guaranteed $@noescape @callee_guaranteed @substituted <τ_0_0> () -> @error_indirect τ_0_0 for <E>):
+// CHECK: [[OUTER_ERROR:%.*]] = alloc_stack $E
 // CHECK: [[FN:%.*]] = copy_value %0 : $@noescape @callee_guaranteed @substituted <τ_0_0> () -> @error_indirect τ_0_0 for <E>
 // CHECK: [[ERROR:%.*]] = alloc_stack $E
-// CHECK: [[FN_BORROW:%.*]] = begin_borrow %2 : $@noescape @callee_guaranteed @substituted <τ_0_0> () -> @error_indirect τ_0_0 for <E>
+// CHECK: [[FN_BORROW:%.*]] = begin_borrow [[FN]] : $@noescape @callee_guaranteed @substituted <τ_0_0> () -> @error_indirect τ_0_0 for <E>
 // CHECK: try_apply [[FN_BORROW]]([[ERROR]]) : $@noescape @callee_guaranteed @substituted <τ_0_0> () -> @error_indirect τ_0_0 for <E>, normal bb1, error bb2
 
 // CHECK: bb1({{.*}} : $()):
@@ -90,11 +91,13 @@ public func genericForceTry<E>(fn: () throws(E) -> ()) {
 // CHECK: return [[RESULT]] : $()
 
 // CHECK: bb2:
-// CHECK: destroy_addr [[ERROR]] : $*E
+// CHECK: copy_addr [take] [[ERROR]] to [init] [[OUTER_ERROR]] : $*E
 // CHECK: end_borrow [[FN_BORROW]] : $@noescape @callee_guaranteed @substituted <τ_0_0> () -> @error_indirect τ_0_0 for <E>
 // CHECK: dealloc_stack [[ERROR]] : $*E
 // CHECK: destroy_value [[FN]] : $@noescape @callee_guaranteed @substituted <τ_0_0> () -> @error_indirect τ_0_0 for <E>
-// CHECK: unreachable
+  // CHECK: [[UNEXPECTED_FN:%.*]] = function_ref @swift_unexpectedErrorTyped : $@convention(thin) <τ_0_0 where τ_0_0 : Error> (@in τ_0_0, Builtin.RawPointer, Builtin.Word, Builtin.Int1, Builtin.Word) -> ()
+  // CHECK-NEXT: apply [[UNEXPECTED_FN]]<E>([[OUTER_ERROR]], {{[^)]*}}) : $@convention(thin) <τ_0_0 where τ_0_0 : Error> (@in τ_0_0, Builtin.RawPointer, Builtin.Word, Builtin.Int1, Builtin.Word) -> ()
+// CHECK-NEXT: unreachable
 
 enum MyError: Error {
 case fail