[Typed throws] Basic SIL lowering and SIL generation for typed throws

Lower the thrown error type into the SIL function type. This requires
very little code because the thrown error type was already modeled as
a SILResultInfo, which carries type information. Note that this
lowering does not yet account for error types that need to passed
indirectly, but we will need to do so for (e.g.) using resilient error
types.

Teach a few places in SIL generation not to assume that thrown types
are always the existential error type, which primarily comes down to
ensuring that rethrow epilogues have the thrown type of the
corresponding function or closure.

Teach throw emission to implicitly box concrete thrown errors in the
error existential when needed to satisfy the throw destination. This
is a temporary solution that helps translate typed throws into untyped
throws, but it should be replaced by a better modeling within the AST
of the points at which thrown errors are converted.

Author: DougGregor

include/swift/AST/Decl.h

@@ -7066,6 +7066,13 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Retrieves the thrown interface type.
   Type getThrownInterfaceType() const;
 
+  /// Retrieve the "effective" thrown interface type, or llvm::None if
+  /// this function cannot throw.
+  ///
+  /// Functions with untyped throws will produce "any Error", functions that
+  /// cannot throw or are specified to throw "Never" will return llvm::None.
+  llvm::Optional<Type> getEffectiveThrownInterfaceType() const;
+
   /// Returns if the function throws or is async.
   bool hasEffect(EffectKind kind) const;
 

include/swift/AST/Expr.h

@@ -3847,6 +3847,13 @@ class AbstractClosureExpr : public DeclContext, public Expr {
   /// Return whether this closure is throwing when fully applied.
   bool isBodyThrowing() const;
 
+  /// Retrieve the "effective" thrown interface type, or llvm::None if
+  /// this closure cannot throw.
+  ///
+  /// Closures with untyped throws will produce "any Error", functions that
+  /// cannot throw or are specified to throw "Never" will return llvm::None.
+  llvm::Optional<Type> getEffectiveThrownType() const;
+
   /// \brief Return whether this closure is async when fully applied.
   bool isBodyAsync() const;
 

include/swift/AST/Types.h

@@ -3386,6 +3386,13 @@ class AnyFunctionType : public TypeBase {
   Type getGlobalActor() const;
   Type getThrownError() const;
 
+  /// Retrieve the "effective" thrown interface type, or llvm::None if
+  /// this function cannot throw.
+  ///
+  /// Functions with untyped throws will produce "any Error", functions that
+  /// cannot throw or are specified to throw "Never" will return llvm::None.
+  llvm::Optional<Type> getEffectiveThrownInterfaceType() const;
+  
   /// Returns true if the function type stores a Clang type that cannot
   /// be derived from its Swift type. Returns false otherwise, including if
   /// the function type is not @convention(c) or @convention(block).
@@ -3612,7 +3619,8 @@ BEGIN_CAN_TYPE_WRAPPER(AnyFunctionType, Type)
   }
 
   PROXY_CAN_TYPE_SIMPLE_GETTER(getResult)
-  
+  PROXY_CAN_TYPE_SIMPLE_GETTER(getThrownError)
+
   CanAnyFunctionType withExtInfo(ExtInfo info) const {
     return CanAnyFunctionType(getPointer()->withExtInfo(info));
   }

lib/AST/ASTVerifier.cpp

@@ -1014,9 +1014,15 @@ class Verifier : public ASTWalker {
     }
 
     void verifyChecked(ThrowStmt *S) {
-      checkSameType(S->getSubExpr()->getType(),
-                    checkExceptionTypeExists("throw expression"),
-                    "throw operand");
+      Type thrownError;
+      if (!Functions.empty()) {
+        if (auto fn = AnyFunctionRef::fromDeclContext(Functions.back()))
+          thrownError = fn->getThrownErrorType();
+      }
+
+      if (!thrownError)
+        thrownError = checkExceptionTypeExists("throw expression");
+      checkSameType(S->getSubExpr()->getType(), thrownError, "throw operand");
       verifyCheckedBase(S);
     }
 

lib/AST/Decl.cpp

@@ -952,6 +952,18 @@ Type AbstractFunctionDecl::getThrownInterfaceType() const {
       Type());
 }
 
+llvm::Optional<Type> 
+AbstractFunctionDecl::getEffectiveThrownInterfaceType() const {
+  Type interfaceType = getInterfaceType();
+  if (hasImplicitSelfDecl()) {
+    if (auto fnType = interfaceType->getAs<AnyFunctionType>())
+      interfaceType = fnType->getResult();
+  }
+
+  return interfaceType->castTo<AnyFunctionType>()
+      ->getEffectiveThrownInterfaceType();
+}
+
 Expr *AbstractFunctionDecl::getSingleExpressionBody() const {
   assert(hasSingleExpressionBody() && "Not a single-expression body");
   auto braceStmt = getBody();

lib/AST/Expr.cpp

@@ -1930,6 +1930,11 @@ Type AbstractClosureExpr::getResultType(
   return T->castTo<FunctionType>()->getResult();
 }
 
+llvm::Optional<Type> AbstractClosureExpr::getEffectiveThrownType() const {
+  return getType()->castTo<AnyFunctionType>()
+      ->getEffectiveThrownInterfaceType();
+}
+
 bool AbstractClosureExpr::isBodyThrowing() const {
   if (!getType() || getType()->hasError()) {
     // Scan the closure body to infer effects.

lib/AST/Type.cpp

@@ -5419,6 +5419,24 @@ AnyFunctionType *AnyFunctionType::getWithoutThrowing() const {
   return withExtInfo(info);
 }
 
+llvm::Optional<Type> AnyFunctionType::getEffectiveThrownInterfaceType() const {
+  // A non-throwing function... has no thrown interface type.
+  if (!isThrowing())
+    return llvm::None;
+
+  // If there is no specified thrown error type, it throws "any Error".
+  Type thrownError = getThrownError();
+  if (!thrownError)
+    return getASTContext().getErrorExistentialType();
+
+  // If the thrown interface type is "Never", this function does not throw.
+  if (thrownError->isEqual(getASTContext().getNeverType()))
+    return llvm::None;
+
+  // Otherwise, return the typed error.
+  return thrownError;
+}
+
 llvm::Optional<TangentSpace>
 TypeBase::getAutoDiffTangentSpace(LookupConformanceFn lookupConformance) {
   assert(lookupConformance);

lib/SIL/IR/SILFunctionType.cpp

@@ -2202,7 +2202,13 @@ static CanSILFunctionType getSILFunctionType(
       !foreignInfo.async) {
     assert(!origType.isForeign()
            && "using native Swift error convention for foreign type!");
-    SILType exnType = SILType::getExceptionType(TC.Context);
+    SILType exnType;
+    if (CanType thrownError = substFnInterfaceType.getThrownError()) {
+      exnType = TC.getLoweredType(thrownError, expansionContext);
+    } else {
+      // Untyped error throws the exception type.
+      exnType = SILType::getExceptionType(TC.Context);
+    }
     assert(exnType.isObject());
     errorResult = SILResultInfo(exnType.getASTType(),
                                 ResultConvention::Owned);

lib/SILGen/SILGenBackDeploy.cpp

@@ -237,7 +237,8 @@ void SILGenFunction::emitBackDeploymentThunk(SILDeclRef thunk) {
     paramsForForwarding.emplace_back(param.forward(*this));
   }
 
-  prepareEpilog(getResultInterfaceType(AFD), AFD->hasThrows(),
+  prepareEpilog(getResultInterfaceType(AFD),
+                AFD->getEffectiveThrownInterfaceType(),
                 CleanupLocation(AFD));
 
   SILBasicBlock *availableBB = createBasicBlock("availableBB");

lib/SILGen/SILGenBridging.cpp

@@ -2081,15 +2081,15 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
   auto foreignFnTy = foreignCI.SILFnType;
 
   // Find the foreign error/async convention and 'self' parameter index.
-  bool hasError = false;
+  llvm::Optional<Type> thrownErrorType;
   llvm::Optional<ForeignAsyncConvention> foreignAsync;
   if (nativeFnTy->isAsync()) {
     foreignAsync = fd->getForeignAsyncConvention();
     assert(foreignAsync && "couldn't find foreign async convention?!");
   }
   llvm::Optional<ForeignErrorConvention> foreignError;
   if (nativeFnTy->hasErrorResult()) {
-    hasError = true;
+    thrownErrorType = nativeFnTy->getErrorResult().getInterfaceType();
     foreignError = fd->getForeignErrorConvention();
     assert((foreignError || foreignAsync)
            && "couldn't find foreign error or async convention for foreign error!");
@@ -2133,8 +2133,8 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
 
   // Set up the throw destination if necessary.
   CleanupLocation cleanupLoc(fd);
-  if (hasError) {
-    prepareRethrowEpilog(cleanupLoc);
+  if (thrownErrorType) {
+    prepareRethrowEpilog(*thrownErrorType, cleanupLoc);
   }
 
   SILValue result;