Fix minor regressions from refactoring of caught error types

Author: DougGregor

lib/AST/Expr.cpp

@@ -1937,8 +1937,10 @@ Type AbstractClosureExpr::getResultType(
 }
 
 llvm::Optional<Type> AbstractClosureExpr::getEffectiveThrownType() const {
-  return getType()->castTo<AnyFunctionType>()
-      ->getEffectiveThrownErrorType();
+  if (auto fnType = getType()->getAs<AnyFunctionType>())
+    return fnType->getEffectiveThrownErrorType();
+
+  return llvm::None;
 }
 
 bool AbstractClosureExpr::isBodyThrowing() const {

lib/Sema/CSGen.cpp

@@ -2459,8 +2459,10 @@ namespace {
       // Determine the thrown error type, when appropriate.
       Type thrownErrorTy = [&] {
         // Explicitly-specified thrown type.
-        if (Type explicitType = closure->getExplicitThrownType())
-          return explicitType;
+        if (closure->getExplicitThrownTypeRepr()) {
+          if (Type explicitType = closure->getExplicitThrownType())
+            return explicitType;
+        }
 
         // Thrown type inferred from context.
         if (auto contextualType = CS.getContextualType(

lib/Sema/CSSyntacticElement.cpp

@@ -925,7 +925,16 @@ class SyntacticElementConstraintGenerator
         dc->getParentModule(), throwStmt->getThrowLoc());
     Type errorType;
     if (catchNode) {
-      errorType = catchNode.getThrownErrorTypeInContext(dc).value_or(Type());
+      // FIXME: Introduce something like getThrownErrorTypeInContext() for the
+      // constraint solver.
+      if (auto abstractClosure = catchNode.dyn_cast<AbstractClosureExpr *>()) {
+        if (auto closure = dyn_cast<ClosureExpr>(abstractClosure)) {
+          errorType = cs.getClosureType(closure)->getThrownError();
+        }
+      }
+
+      if (!errorType)
+        errorType = catchNode.getThrownErrorTypeInContext(dc).value_or(Type());
     }
 
     if (!errorType) {

lib/Sema/TypeCheckType.cpp

@@ -5680,7 +5680,7 @@ Type ExplicitCaughtTypeRequest::evaluate(
       return ctx.getNeverType();
     }
 
-    // We have an explici thrown error type, so resolve it.
+    // We have an explicit thrown error type, so resolve it.
     if (!ctx.LangOpts.hasFeature(Feature::TypedThrows)) {
       ctx.Diags.diagnose(thrownTypeRepr->getLoc(), diag::experimental_typed_throws);
     }
@@ -5719,20 +5719,10 @@ Type ExplicitCaughtTypeRequest::evaluate(
       if (closure->getThrowsLoc().isValid()) {
         return ctx.getErrorExistentialType();
       }
-
-      // If there is no potential throw site (based on syntactic analysis),
-      // then this closure is non-throwing.
-      auto effects = evaluateOrDefault(
-          evaluator, ClosureEffectsRequest{closure}, FunctionType::ExtInfo());
-      if (!effects.isThrowing())
-        return ctx.getNeverType();
     }
 
-    // TODO: A throwing closure with no explicit 'throws' annotation will infer
-    // the thrown error type in Swift 6 and under FullTypedThrows.
-
-    // Otherwise, we throw 'any Error'.
-    return ctx.getErrorExistentialType();
+    // Thrown error type will be inferred.
+    return Type();
   }
 
   // do..catch statements.