[Typed throws] Check thrown error types of for applications/subscripts/etc.

Whenever there is a throwing operation such as a call, subscript, or
property access, check that the error type thrown from that operation
can be caught/rethrown from the current context.

Author: DougGregor

lib/Sema/TypeCheckEffects.cpp

@@ -1718,14 +1718,15 @@ class Context {
 private:
   static Context getContextForPatternBinding(PatternBindingDecl *pbd) {
     if (!pbd->isStatic() && pbd->getDeclContext()->isTypeContext()) {
-      return Context(Kind::IVarInitializer);
+      return Context(Kind::IVarInitializer, pbd->getDeclContext());
     } else {
-      return Context(Kind::GlobalVarInitializer);
+      return Context(Kind::GlobalVarInitializer, pbd->getDeclContext());
     }
   }
 
   Kind TheKind;
   llvm::Optional<AnyFunctionRef> Function;
+  DeclContext *DC;
   bool HandlesErrors = false;
   bool HandlesAsync = false;
 
@@ -1736,14 +1737,15 @@ class Context {
   bool DiagnoseErrorOnTry = false;
   InterpolatedStringLiteralExpr *InterpolatedString = nullptr;
 
-  explicit Context(Kind kind)
-      : TheKind(kind), Function(llvm::None), HandlesErrors(false) {
+  explicit Context(Kind kind, DeclContext *dc)
+      : TheKind(kind), Function(llvm::None), DC(dc), HandlesErrors(false) {
     assert(TheKind != Kind::PotentiallyHandled);
   }
 
   explicit Context(bool handlesErrors, bool handlesAsync,
-                   llvm::Optional<AnyFunctionRef> function)
-      : TheKind(Kind::PotentiallyHandled), Function(function),
+                   llvm::Optional<AnyFunctionRef> function,
+                   DeclContext *dc)
+      : TheKind(Kind::PotentiallyHandled), Function(function), DC(dc),
         HandlesErrors(handlesErrors), HandlesAsync(handlesAsync) {}
 
 public:
@@ -1820,7 +1822,7 @@ class Context {
   static Context forTopLevelCode(TopLevelCodeDecl *D) {
     // Top-level code implicitly handles errors.
     return Context(/*handlesErrors=*/true,
-                   /*handlesAsync=*/D->isAsyncContext(), llvm::None);
+                   /*handlesAsync=*/D->isAsyncContext(), llvm::None, D);
   }
 
   static Context forFunction(AbstractFunctionDecl *D) {
@@ -1840,20 +1842,20 @@ class Context {
       }
     }
 
-    return Context(D->hasThrows(), D->isAsyncContext(), AnyFunctionRef(D));
+    return Context(D->hasThrows(), D->isAsyncContext(), AnyFunctionRef(D), D);
   }
 
-  static Context forDeferBody() {
-    return Context(Kind::DeferBody);
+  static Context forDeferBody(DeclContext *dc) {
+    return Context(Kind::DeferBody, dc);
   }
 
   static Context forInitializer(Initializer *init) {
     if (isa<DefaultArgumentInitializer>(init)) {
-      return Context(Kind::DefaultArgument);
+      return Context(Kind::DefaultArgument, init);
     }
 
     if (isa<PropertyWrapperInitializer>(init)) {
-      return Context(Kind::PropertyWrapper);
+      return Context(Kind::PropertyWrapper, init);
     }
 
     auto *binding = cast<PatternBindingInitializer>(init)->getBinding();
@@ -1863,7 +1865,7 @@ class Context {
   }
 
   static Context forEnumElementInitializer(EnumElementDecl *elt) {
-    return Context(Kind::EnumElementInitializer);
+    return Context(Kind::EnumElementInitializer, elt);
   }
 
   static Context forClosure(AbstractClosureExpr *E) {
@@ -1877,15 +1879,15 @@ class Context {
       }
     }
 
-    return Context(closureTypeThrows, closureTypeIsAsync, AnyFunctionRef(E));
+    return Context(closureTypeThrows, closureTypeIsAsync, AnyFunctionRef(E), E);
   }
 
-  static Context forCatchPattern(CaseStmt *S) {
-    return Context(Kind::CatchPattern);
+  static Context forCatchPattern(CaseStmt *S, DeclContext *dc) {
+    return Context(Kind::CatchPattern, dc);
   }
 
-  static Context forCatchGuard(CaseStmt *S) {
-    return Context(Kind::CatchGuard);
+  static Context forCatchGuard(CaseStmt *S, DeclContext *dc) {
+    return Context(Kind::CatchGuard, dc);
   }
 
   static Context forPatternBinding(PatternBindingDecl *binding) {
@@ -1909,6 +1911,8 @@ class Context {
 
   Kind getKind() const { return TheKind; }
 
+  DeclContext *getDeclContext() const { return DC; }
+
   bool handlesThrows(ConditionalEffectKind errorKind) const {
     switch (errorKind) {
     case ConditionalEffectKind::None:
@@ -2587,6 +2591,19 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
     }
   };
 
+  /// Retrieve the type of the error that can be caught when an error is
+  /// thrown from the given location.
+  Type getCaughtErrorTypeAt(SourceLoc loc) {
+    auto module = CurContext.getDeclContext()->getParentModule();
+    if (CatchNode catchNode = ASTScope::lookupCatchNode(module, loc)) {
+      if (auto caughtType = catchNode.getThrownErrorTypeInContext(Ctx))
+        return *caughtType;
+    }
+
+    // Fall back to the error existential.
+    return Ctx.getErrorExistentialType();
+  }
+
 public:
   CheckEffectsCoverage(ASTContext &ctx, Context initialContext)
     : Ctx(ctx), CurContext(initialContext),
@@ -2706,6 +2723,11 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
     // specialized diagnostic about non-exhaustive catches.
     if (!CurContext.handlesThrows(ConditionalEffectKind::Conditional)) {
       CurContext.setNonExhaustiveCatch(true);
+    } else if (Type rethrownErrorType = S->getCaughtErrorType()) {
+      // We're implicitly rethrowing the error out of this do..catch, so make
+      // sure that we can throw an error of this type out of this context.
+      auto catches = S->getCatches();
+      checkThrownErrorType(catches.back()->getEndLoc(), rethrownErrorType);
     }
 
     S->getBody()->walk(*this);
@@ -2727,14 +2749,15 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
   }
 
   void checkCatch(CaseStmt *S, ConditionalEffectKind doThrowingKind) {
+    auto dc = CurContext.getDeclContext();
     for (auto &LabelItem : S->getMutableCaseLabelItems()) {
       // The pattern and guard aren't allowed to throw.
       {
-        ContextScope scope(*this, Context::forCatchPattern(S));
+        ContextScope scope(*this, Context::forCatchPattern(S, dc));
         LabelItem.getPattern()->walk(*this);
       }
       if (auto guard = LabelItem.getGuardExpr()) {
-        ContextScope scope(*this, Context::forCatchGuard(S));
+        ContextScope scope(*this, Context::forCatchGuard(S, dc));
         guard->walk(*this);
       }
     }
@@ -2943,11 +2966,27 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
       } else if (!isTryCovered) {
         CurContext.diagnoseUncoveredThrowSite(Ctx, E, // we want this one to trigger
                                               classification.getThrowReason());
+      } else {
+        checkThrownErrorType(E.getStartLoc(), classification.getThrownError());
       }
       break;
     }
   }
 
+  /// Check the thrown error type against the type that can be caught or
+  /// rethrown by the context.
+  void checkThrownErrorType(SourceLoc loc, Type thrownErrorType) {
+    Type caughtErrorType = getCaughtErrorTypeAt(loc);
+    if (caughtErrorType->isEqual(thrownErrorType))
+      return;
+
+    OpaqueValueExpr *opaque = new (Ctx) OpaqueValueExpr(loc, thrownErrorType);
+    Expr *rethrowExpr = opaque;
+    TypeChecker::typeCheckExpression(
+        rethrowExpr, CurContext.getDeclContext(),
+        {caughtErrorType, /*FIXME:*/CTP_ThrowStmt});
+  }
+
   ShouldRecurse_t checkAwait(AwaitExpr *E) {
 
     // Walk the operand.
@@ -3206,7 +3245,7 @@ void TypeChecker::checkFunctionEffects(AbstractFunctionDecl *fn) {
 
   auto isDeferBody = isa<FuncDecl>(fn) && cast<FuncDecl>(fn)->isDeferBody();
   auto context =
-      isDeferBody ? Context::forDeferBody() : Context::forFunction(fn);
+      isDeferBody ? Context::forDeferBody(fn) : Context::forFunction(fn);
   auto &ctx = fn->getASTContext();
   CheckEffectsCoverage checker(ctx, context);
 

lib/Sema/TypeCheckStmt.cpp

@@ -1689,21 +1689,6 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
                           CaseParentKind::DoCatch, limitExhaustivityChecks,
                           caughtErrorType);
 
-    if (!S->isSyntacticallyExhaustive()) {
-      // If we're implicitly rethrowing the error out of this do..catch, make
-      // sure that we can throw an error of this type out of this context.
-      // FIXME: Unify this lookup of the type with that from ThrowStmt.
-      if (auto TheFunc = AnyFunctionRef::fromDeclContext(DC)) {
-        if (Type expectedErrorType = TheFunc->getThrownErrorType()) {
-          OpaqueValueExpr *opaque = new (Ctx) OpaqueValueExpr(
-              catches.back()->getEndLoc(), caughtErrorType);
-          Expr *rethrowExpr = opaque;
-          TypeChecker::typeCheckExpression(
-              rethrowExpr, DC, {expectedErrorType, CTP_ThrowStmt});
-        }
-      }
-    }
-
     return S;
   }
 

test/stmt/typed_throws.swift

@@ -117,7 +117,7 @@ func testDoCatchRethrowsTyped() throws(HomeworkError) {
 func testTryIncompatibleTyped(cond: Bool) throws(HomeworkError) {
   try doHomework() // okay
 
-  try doSomething() // FIXME: should error
+  try doSomething() // expected-error{{thrown expression type 'MyError' cannot be converted to error type 'HomeworkError'}}
 
   do {
     if cond {