[Typed throws] Infer thrown error type for do..catch blocks within closures.

Start classifying all potential throw sites within a constraint
system and associate them with the nearest enclosing catch node. Then,
determine the thrown error type for a given catch node by taking the
union of the thrown errors at each potential throw site. Use this to
compute the error type thrown from the body of a `do..catch` block
within a closure.

This behavior is limited to the upcoming feature `FullTypedThrows`.

Author: DougGregor

include/swift/Sema/ConstraintSystem.h

@@ -1440,6 +1440,31 @@ struct MatchCallArgumentResult {
   }
 };
 
+/// Describes a potential throw site in the constraint system.
+///
+/// For example, given `try f() + a[b] + x.y`, each of `f()`, `a[b]`, `x`, and
+/// `x.y` is a potential throw site.
+struct PotentialThrowSite {
+  enum Kind {
+    /// The application of a function or subscript.
+    Application,
+
+    /// An explicit 'throw'.
+    ExplicitThrow,
+
+    /// A non-exhaustive do...catch, which rethrows whatever is thrown from
+    /// inside it's `do` block.
+    NonExhaustiveDoCatch,
+  } kind;
+
+  /// The type that describes the potential throw site, such as the type of the
+  /// function being called or type being thrown.
+  Type type;
+
+  /// The locator that specifies where the throwing operation occurs.
+  ConstraintLocator *locator;
+};
+
 /// A complete solution to a constraint system.
 ///
 /// A solution to a constraint system consists of type variable bindings to
@@ -1547,6 +1572,13 @@ class Solution {
   llvm::MapVector<const CaseLabelItem *, CaseLabelItemInfo>
       caseLabelItems;
 
+  /// Maps catch nodes to the set of potential throw sites that will be caught
+  /// at that location.
+
+  /// The set of opened types for a given locator.
+  std::vector<std::pair<CatchNode, PotentialThrowSite>>
+      potentialThrowSites;
+
   /// A map of expressions to the ExprPatterns that they are being solved as
   /// a part of.
   llvm::MapVector<Expr *, ExprPattern *> exprPatterns;
@@ -2210,6 +2242,11 @@ class ConstraintSystem {
   llvm::SmallMapVector<const CaseLabelItem *, CaseLabelItemInfo, 4>
       caseLabelItems;
 
+  /// Keep track of all of the potential throw sites.
+  /// FIXME: This data structure should be replaced with something that
+  /// is, in effect, a multimap-vector.
+  std::vector<std::pair<CatchNode, PotentialThrowSite>> potentialThrowSites;
+
   /// A map of expressions to the ExprPatterns that they are being solved as
   /// a part of.
   llvm::SmallMapVector<Expr *, ExprPattern *, 2> exprPatterns;
@@ -2821,6 +2858,9 @@ class ConstraintSystem {
     /// The length of \c caseLabelItems.
     unsigned numCaseLabelItems;
 
+    /// The length of \c potentialThrowSites.
+    unsigned numPotentialThrowSites;
+
     /// The length of \c exprPatterns.
     unsigned numExprPatterns;
 
@@ -3293,6 +3333,14 @@ class ConstraintSystem {
     return known->second;
   }
 
+  /// Note that there is a potential throw site at the given location.
+  void recordPotentialThrowSite(
+      PotentialThrowSite::Kind kind, Type type,
+      ConstraintLocatorBuilder locator);
+
+  /// Determine the caught error type for the given catch node.
+  Type getCaughtErrorType(CatchNode node);
+
   /// Retrieve the constraint locator for the given anchor and
   /// path, uniqued.
   ConstraintLocator *

lib/Sema/CSGen.cpp

@@ -2464,6 +2464,13 @@ namespace {
             return explicitType;
         }
 
+        // Explicitly-specified 'throws' without a type is untyped throws.
+        // Use a NULL return here so that the inferred type is written with
+        // `throws` instead of `throws(any Error)`, although the two are
+        // semantically equivalent.
+        if (closure->getThrowsLoc().isValid())
+          return Type();
+
         // Thrown type inferred from context.
         if (auto contextualType = CS.getContextualType(
                 closure, /*forConstraint=*/false)) {
@@ -2474,7 +2481,7 @@ namespace {
         }
 
         // We do not try to infer a thrown error type if one isn't immediately
-        // available. We could attempt this in the future.
+        // available.
         return Type();
       }();
 

lib/Sema/CSSimplify.cpp

@@ -12855,6 +12855,10 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyApplicableFnConstraint(
   // is not valid for operators though, where an inout parameter does not
   // have an explicit inout argument.
   if (type1.getPointer() == desugar2) {
+    // Note that this could throw.
+    recordPotentialThrowSite(
+        PotentialThrowSite::Application, Type(desugar2), outerLocator);
+
     if (!isOperator || !hasInOut()) {
       recordMatchCallArgumentResult(
           getConstraintLocator(
@@ -12905,6 +12909,10 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyApplicableFnConstraint(
 
   // For a function, bind the output and convert the argument to the input.
   if (auto func2 = dyn_cast<FunctionType>(desugar2)) {
+    // Note that this could throw.
+    recordPotentialThrowSite(
+        PotentialThrowSite::Application, Type(desugar2), outerLocator);
+
     ConstraintKind subKind = (isOperator
                               ? ConstraintKind::OperatorArgumentConversion
                               : ConstraintKind::ArgumentConversion);

lib/Sema/CSSolver.cpp

@@ -206,6 +206,9 @@ Solution ConstraintSystem::finalize() {
   for (const auto &item : caseLabelItems)
     solution.caseLabelItems.insert(item);
 
+  for (const auto &throwSite : potentialThrowSites)
+    solution.potentialThrowSites.push_back(throwSite);
+
   for (const auto &pattern : exprPatterns)
     solution.exprPatterns.insert(pattern);
 
@@ -350,6 +353,10 @@ void ConstraintSystem::applySolution(const Solution &solution) {
       setCaseLabelItemInfo(info.first, info.second);
   }
 
+  potentialThrowSites.insert(potentialThrowSites.end(),
+                             solution.potentialThrowSites.begin(),
+                             solution.potentialThrowSites.end());
+
   for (auto param : solution.isolatedParams) {
     isolatedParams.insert(param);
   }
@@ -653,6 +660,7 @@ ConstraintSystem::SolverScope::SolverScope(ConstraintSystem &cs)
   numContextualTypes = cs.contextualTypes.size();
   numTargets = cs.targets.size();
   numCaseLabelItems = cs.caseLabelItems.size();
+  numPotentialThrowSites = cs.potentialThrowSites.size();
   numExprPatterns = cs.exprPatterns.size();
   numIsolatedParams = cs.isolatedParams.size();
   numPreconcurrencyClosures = cs.preconcurrencyClosures.size();
@@ -776,6 +784,9 @@ ConstraintSystem::SolverScope::~SolverScope() {
   // Remove any case label item infos.
   truncate(cs.caseLabelItems, numCaseLabelItems);
 
+  // Remove any potential throw sites.
+  truncate(cs.potentialThrowSites, numPotentialThrowSites);
+
   // Remove any ExprPattern mappings.
   truncate(cs.exprPatterns, numExprPatterns);
 

lib/Sema/CSSyntacticElement.cpp

@@ -921,21 +921,11 @@ class SyntacticElementConstraintGenerator
   void visitThrowStmt(ThrowStmt *throwStmt) {
     // Look up the catch node for this "throw" to determine the error type.
     auto dc = context.getAsDeclContext();
-    CatchNode catchNode = ASTScope::lookupCatchNode(
-        dc->getParentModule(), throwStmt->getThrowLoc());
+    auto module = dc->getParentModule();
+    auto throwLoc = throwStmt->getThrowLoc();
     Type errorType;
-    if (catchNode) {
-      // FIXME: Introduce something like getThrownErrorTypeInContext() for the
-      // constraint solver.
-      if (auto closure = catchNode.dyn_cast<ClosureExpr *>()) {
-        errorType = cs.getClosureType(closure)->getThrownError();
-      }
-
-      if (!errorType) {
-        ASTContext &ctx = cs.getASTContext();
-        errorType = catchNode.getThrownErrorTypeInContext(ctx).value_or(Type());
-      }
-    }
+    if (auto catchNode = ASTScope::lookupCatchNode(module, throwLoc))
+      errorType = catchNode.getExplicitCaughtType(cs.getASTContext());
 
     if (!errorType) {
       if (!cs.getASTContext().getErrorDecl()) {
@@ -1070,10 +1060,15 @@ class SyntacticElementConstraintGenerator
         contextualTy = cs.getType(switchStmt->getSubjectExpr());
       } else if (auto doCatch =
                      dyn_cast_or_null<DoCatchStmt>(parent.dyn_cast<Stmt *>())) {
-        auto dc = context.getAsDeclContext();
-        contextualTy = doCatch->getExplicitCaughtType();
-        if (!contextualTy)
-          contextualTy = cs.getASTContext().getErrorExistentialType();
+        contextualTy = cs.getCaughtErrorType(doCatch);
+
+        // A non-exhaustive do..catch statement is a potential throw site.
+        if (caseStmt == doCatch->getCatches().back() &&
+            !doCatch->isSyntacticallyExhaustive()) {
+          cs.recordPotentialThrowSite(
+              PotentialThrowSite::NonExhaustiveDoCatch, contextualTy,
+              cs.getConstraintLocator(doCatch));
+        }
       } else {
         hadError = true;
         return;
@@ -1639,6 +1634,13 @@ ConstraintSystem::simplifySyntacticElementConstraint(
     if (generateConstraints(target))
       return SolutionKind::Error;
 
+    // If this expression is the operand of a `throw` statement, record it as
+    // a potential throw site.
+    if (contextInfo.purpose == CTP_ThrowStmt) {
+      recordPotentialThrowSite(PotentialThrowSite::ExplicitThrow,
+                               getType(expr), getConstraintLocator(expr));
+    }
+
     setTargetFor(expr, target);
     return SolutionKind::Solved;
   } else if (auto *stmt = element.dyn_cast<Stmt *>()) {

lib/Sema/ConstraintSystem.cpp

@@ -368,6 +368,114 @@ bool ConstraintSystem::containsIDEInspectionTarget(
                                             Context.SourceMgr);
 }
 
+void ConstraintSystem::recordPotentialThrowSite(
+    PotentialThrowSite::Kind kind, Type type,
+    ConstraintLocatorBuilder locator) {
+  ASTContext &ctx = getASTContext();
+
+  // Only record potential throw sites when typed throws is enabled.
+  if (!ctx.LangOpts.hasFeature(Feature::TypedThrows))
+    return;
+
+  // Catch node location is determined by the source location.
+  auto sourceLoc = locator.getAnchor().getStartLoc();
+  if (!sourceLoc)
+    return;
+
+  auto catchNode = ASTScope::lookupCatchNode(DC->getParentModule(), sourceLoc);
+  if (!catchNode)
+    return;
+
+  // If there is an explicit caught type for this node, we don't need to
+  // record a potential throw site.
+  if (Type explicitCaughtType = catchNode.getExplicitCaughtType(ctx))
+    return;
+
+  // do..catch statements without an explicit `throws` clause do infer
+  // thrown types.
+  if (auto doCatch = catchNode.dyn_cast<DoCatchStmt *>()) {
+    potentialThrowSites.push_back(
+        {catchNode,
+         PotentialThrowSite{kind, type, getConstraintLocator(locator)}});
+    return;
+  }
+
+  // Closures without an explicit `throws` clause, and which syntactically
+  // appear that they can throw, do infer thrown types.
+  auto closure = catchNode.get<ClosureExpr *>();
+
+  // Check whether the closure syntactically throws. If not, there is no
+  // need to record a throw site.
+  if (!closureEffects(closure).isThrowing())
+    return;
+
+  potentialThrowSites.push_back(
+      {catchNode,
+       PotentialThrowSite{kind, type, getConstraintLocator(locator)}});
+}
+
+Type ConstraintSystem::getCaughtErrorType(CatchNode catchNode) {
+  ASTContext &ctx = getASTContext();
+
+  // If there is an explicit caught type for this node, use it.
+  if (Type explicitCaughtType = catchNode.getExplicitCaughtType(ctx)) {
+    if (explicitCaughtType->hasTypeParameter())
+      explicitCaughtType = DC->mapTypeIntoContext(explicitCaughtType);
+
+    return explicitCaughtType;
+  }
+
+  // Retrieve the thrown error type of a closure.
+  // FIXME: This will need to change when we do inference of thrown error
+  // types in closures.
+  if (auto closure = catchNode.dyn_cast<ClosureExpr *>()) {
+    return getClosureType(closure)->getEffectiveThrownErrorTypeOrNever();
+  }
+
+  // Handle inference of caught error types.
+
+  // Collect all of the potential throw sites for this catch node.
+  SmallVector<PotentialThrowSite, 2> throwSites;
+  for (const auto &potentialThrowSite : potentialThrowSites) {
+    if (potentialThrowSite.first == catchNode) {
+      throwSites.push_back(potentialThrowSite.second);
+    }
+  }
+
+  Type caughtErrorType = ctx.getNeverType();
+  for (const auto &throwSite : throwSites) {
+    Type type = simplifyType(throwSite.type);
+
+    Type thrownErrorType;
+    switch (throwSite.kind) {
+    case PotentialThrowSite::Application: {
+      auto fnType = type->castTo<AnyFunctionType>();
+      thrownErrorType = fnType->getEffectiveThrownErrorTypeOrNever();
+      break;
+    }
+
+    case PotentialThrowSite::ExplicitThrow:
+    case PotentialThrowSite::NonExhaustiveDoCatch:
+      thrownErrorType = type;
+      break;
+    }
+
+    // Perform the errorUnion() of the caught error type so far with the
+    // thrown error type of this potential throw site.
+    caughtErrorType = TypeChecker::errorUnion(
+        caughtErrorType, thrownErrorType,
+        [&](Type type) {
+      return simplifyType(type);
+    });
+
+    // If we ended up at 'any Error', we're done.
+    if (caughtErrorType->isErrorExistentialType())
+      break;
+  }
+
+  return caughtErrorType;
+}
+
 ConstraintLocator *ConstraintSystem::getConstraintLocator(
     ASTNode anchor, ArrayRef<ConstraintLocator::PathElement> path) {
   auto summaryFlags = ConstraintLocator::getSummaryFlagsForPath(path);

lib/Sema/TypeCheckConstraints.cpp

@@ -1655,6 +1655,30 @@ void ConstraintSystem::print(raw_ostream &out) const {
       out << "\n";
     }
   }
+
+  if (!potentialThrowSites.empty()) {
+    out.indent(indent) << "Potential throw sites:\n";
+    interleave(potentialThrowSites, [&](const auto &throwSite) {
+      out.indent(indent + 2);
+      switch (throwSite.second.kind) {
+      case PotentialThrowSite::Application:
+        out << "- application @ ";
+        break;
+      case PotentialThrowSite::ExplicitThrow:
+        out << " - explicit throw @ ";
+        break;
+      case PotentialThrowSite::NonExhaustiveDoCatch:
+        out << " - non-exhaustive do..catch @ ";
+        break;
+      }
+
+      throwSite.second.locator->dump(&getASTContext().SourceMgr, out);
+    }, [&] {
+      out << "\n";
+    });
+    out << "\n";
+
+  }
 }
 
 /// Determine the semantics of a checked cast operation.

test/expr/closure/typed_throws.swift

@@ -17,7 +17,12 @@ func testClosures() {
   // expected-error@-1{{invalid conversion from throwing function of type '() throws(MyError) -> ()'}}
 
   let _: () throws(MyError) -> Void = {
-    throw .fail
+    // NOTE: under full typed throws, this should succeed
+    throw MyError.fail // expected-error{{thrown expression type 'any Error' cannot be converted to error type 'MyError'}}
+  }
+
+  let _: () throws(MyError) -> Void = {
+    throw .fail // expected-error{{type 'any Error' has no member 'fail'}}
   }
 
   // FIXME: Terrible diagnostic.