Merge pull request #70454 from DougGregor/full-typed-throws-inference

[Typed throws] Implement thrown type inference for do..catch within closures

Author: DougGregor

include/swift/AST/CatchNode.h

@@ -36,7 +36,14 @@ class CatchNode: public llvm::PointerUnion<
   ///
   /// Returns the thrown error type for a throwing context, or \c llvm::None
   /// if this is a non-throwing context.
-  llvm::Optional<Type> getThrownErrorTypeInContext(DeclContext *dc) const;
+  llvm::Optional<Type> getThrownErrorTypeInContext(ASTContext &ctx) const;
+
+  /// Determines the explicitly-specified type error that will be caught by
+  /// this catch node.
+  ///
+  /// Returns the explicitly-caught type, or a NULL type if the caught type
+  /// needs to be inferred.
+  Type getExplicitCaughtType(ASTContext &ctx) const;
 
   friend llvm::hash_code hash_value(CatchNode catchNode) {
     using llvm::hash_value;
@@ -46,6 +53,8 @@ class CatchNode: public llvm::PointerUnion<
 
 void simple_display(llvm::raw_ostream &out, CatchNode catchNode);
 
+SourceLoc extractNearestSourceLoc(CatchNode catchNode);
+
 } // end namespace swift
 
 #endif // SWIFT_AST_CATCHNODE_H

include/swift/AST/Stmt.h

@@ -1429,6 +1429,8 @@ class DoCatchStmt final
   friend TrailingObjects;
   friend class ExplicitCaughtTypeRequest;
 
+  DeclContext *DC;
+
   SourceLoc DoLoc;
 
   /// Location of the 'throws' token.
@@ -1440,12 +1442,13 @@ class DoCatchStmt final
   Stmt *Body;
   ThrownErrorDestination RethrowDest;
 
-  DoCatchStmt(LabeledStmtInfo labelInfo, SourceLoc doLoc, 
+  DoCatchStmt(DeclContext *dc,LabeledStmtInfo labelInfo, SourceLoc doLoc,
               SourceLoc throwsLoc, TypeLoc thrownType, Stmt *body,
               ArrayRef<CaseStmt *> catches, llvm::Optional<bool> implicit)
       : LabeledStmt(StmtKind::DoCatch, getDefaultImplicitFlag(implicit, doLoc),
                     labelInfo),
-        DoLoc(doLoc), ThrowsLoc(throwsLoc), ThrownType(thrownType), Body(body) {
+        DC(dc), DoLoc(doLoc), ThrowsLoc(throwsLoc), ThrownType(thrownType),
+        Body(body) {
     Bits.DoCatchStmt.NumCatches = catches.size();
     std::uninitialized_copy(catches.begin(), catches.end(),
                             getTrailingObjects<CaseStmt *>());
@@ -1454,13 +1457,16 @@ class DoCatchStmt final
   }
 
 public:
-  static DoCatchStmt *create(ASTContext &ctx, LabeledStmtInfo labelInfo,
-                             SourceLoc doLoc, 
+  static DoCatchStmt *create(DeclContext *dc,
+                             LabeledStmtInfo labelInfo,
+                             SourceLoc doLoc,
                              SourceLoc throwsLoc, TypeLoc thrownType,
                              Stmt *body,
                              ArrayRef<CaseStmt *> catches,
                              llvm::Optional<bool> implicit = llvm::None);
 
+  DeclContext *getDeclContext() const { return DC; }
+
   SourceLoc getDoLoc() const { return DoLoc; }
 
   /// Retrieve the location of the 'throws' keyword, if present.
@@ -1475,7 +1481,7 @@ class DoCatchStmt final
   }
 
   // Get the explicitly-specified caught error type.
-  Type getExplicitCaughtType(DeclContext *dc) const;
+  Type getExplicitCaughtType() const;
 
   Stmt *getBody() const { return Body; }
   void setBody(Stmt *s) { Body = s; }
@@ -1501,7 +1507,7 @@ class DoCatchStmt final
   // and caught by the various 'catch' clauses. If this the catch clauses
   // aren't exhausive, this is also the type of the error that is implicitly
   // rethrown.
-  Type getCaughtErrorType(DeclContext *dc) const;
+  Type getCaughtErrorType() const;
 
   /// Retrieves the rethrown error and its conversion to the error type
   /// expected by the enclosing context.

include/swift/AST/TypeCheckRequests.h

@@ -2294,7 +2294,7 @@ class ParamSpecifierRequest
 /// requires type inference.
 class ExplicitCaughtTypeRequest
     : public SimpleRequest<ExplicitCaughtTypeRequest,
-                           Type(DeclContext *, CatchNode),
+                           Type(ASTContext *, CatchNode),
                            RequestFlags::SeparatelyCached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -2303,7 +2303,7 @@ class ExplicitCaughtTypeRequest
   friend SimpleRequest;
 
   // Evaluation.
-  Type evaluate(Evaluator &evaluator, DeclContext *dc, CatchNode catchNode) const;
+  Type evaluate(Evaluator &evaluator, ASTContext *, CatchNode catchNode) const;
 
 public:
   // Separate caching.

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -360,7 +360,7 @@ SWIFT_REQUEST(TypeChecker, NeedsNewVTableEntryRequest,
 SWIFT_REQUEST(TypeChecker, ParamSpecifierRequest,
               ParamDecl::Specifier(ParamDecl *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ExplicitCaughtTypeRequest,
-              Type(DeclContext *, CatchNode), SeparatelyCached, NoLocationInfo)
+              Type(ASTContext *, CatchNode), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ResultTypeRequest,
               Type(ValueDecl *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, AreAllStoredPropertiesDefaultInitableRequest,

include/swift/Sema/ConstraintSystem.h

@@ -1440,6 +1440,34 @@ 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,
+
+    /// A property access that can throw an error.
+    PropertyAccess,
+  } 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 +1575,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;
@@ -2038,6 +2073,9 @@ struct DeclReferenceType {
   /// (e.g.) applying the base of a member access. This is the type of the
   /// expression used to form the declaration reference.
   Type adjustedReferenceType;
+
+  /// The type that could be thrown by accessing this declaration.
+  Type thrownErrorTypeOnAccess;
 };
 
 /// Describes a system of constraints on type variables, the
@@ -2210,6 +2248,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 +2864,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 +3339,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/AST/ASTVerifier.cpp

@@ -1046,9 +1046,8 @@ class Verifier : public ASTWalker {
       SourceLoc loc = S->getThrowLoc();
       if (loc.isValid()) {
         auto catchNode = ASTScope::lookupCatchNode(getModuleContext(), loc);
-        DeclContext *dc = getInnermostDC();
-        if (catchNode && dc) {
-          if (auto thrown = catchNode.getThrownErrorTypeInContext(dc)) {
+        if (catchNode) {
+          if (auto thrown = catchNode.getThrownErrorTypeInContext(Ctx)) {
             thrownError = *thrown;
           } else {
             thrownError = Ctx.getNeverType();

lib/AST/Decl.cpp

@@ -983,10 +983,7 @@ Type AbstractFunctionDecl::getThrownInterfaceType() const {
     return ThrownType.getType();
 
   auto mutableThis = const_cast<AbstractFunctionDecl *>(this);
-  return evaluateOrDefault(
-      getASTContext().evaluator,
-      ExplicitCaughtTypeRequest{mutableThis, mutableThis},
-      Type());
+  return CatchNode(mutableThis).getExplicitCaughtType(getASTContext());
 }
 
 llvm::Optional<Type> 
@@ -11728,7 +11725,7 @@ MacroDiscriminatorContext::getParentOf(FreestandingMacroExpansion *expansion) {
 }
 
 llvm::Optional<Type>
-CatchNode::getThrownErrorTypeInContext(DeclContext *dc) const {
+CatchNode::getThrownErrorTypeInContext(ASTContext &ctx) const {
   if (auto func = dyn_cast<AbstractFunctionDecl *>()) {
     if (auto thrownError = func->getEffectiveThrownErrorType())
       return func->mapTypeIntoContext(*thrownError);
@@ -11751,15 +11748,15 @@ CatchNode::getThrownErrorTypeInContext(DeclContext *dc) const {
   }
 
   if (auto doCatch = dyn_cast<DoCatchStmt *>()) {
-    if (auto thrownError = doCatch->getCaughtErrorType(dc)) {
+    if (auto thrownError = doCatch->getCaughtErrorType()) {
       if (thrownError->isNever())
         return llvm::None;
 
       return thrownError;
     }
 
     // If we haven't computed the error type yet, return 'any Error'.
-    return dc->getASTContext().getErrorExistentialType();
+    return ctx.getErrorExistentialType();
   }
 
   auto tryExpr = get<AnyTryExpr *>();
@@ -11768,24 +11765,41 @@ CatchNode::getThrownErrorTypeInContext(DeclContext *dc) const {
       return thrownError;
 
     // If we haven't computed the error type yet, return 'any Error'.
-    return dc->getASTContext().getErrorExistentialType();
+    return ctx.getErrorExistentialType();
   }
 
   if (auto optTry = llvm::dyn_cast<OptionalTryExpr>(tryExpr)) {
     if (auto thrownError = optTry->getThrownError())
       return thrownError;
 
     // If we haven't computed the error type yet, return 'any Error'.
-    return dc->getASTContext().getErrorExistentialType();
+    return ctx.getErrorExistentialType();
   }
 
   llvm_unreachable("Unhandled catch node kind");
 }
 
+Type CatchNode::getExplicitCaughtType(ASTContext &ctx) const {
+  return evaluateOrDefault(
+      ctx.evaluator, ExplicitCaughtTypeRequest{&ctx, *this}, Type());
+}
+
 void swift::simple_display(llvm::raw_ostream &out, CatchNode catchNode) {
   out << "catch node";
 }
 
+SourceLoc swift::extractNearestSourceLoc(CatchNode catchNode) {
+  if (auto func = catchNode.dyn_cast<AbstractFunctionDecl *>())
+    return func->getLoc();
+  if (auto closure = catchNode.dyn_cast<ClosureExpr *>())
+    return closure->getLoc();
+  if (auto doCatch = catchNode.dyn_cast<DoCatchStmt *>())
+    return doCatch->getDoLoc();
+  if (auto tryExpr = catchNode.dyn_cast<AnyTryExpr *>())
+    return tryExpr->getTryLoc();
+  llvm_unreachable("Unhandled catch node");
+}
+
 //----------------------------------------------------------------------------//
 // ExplicitCaughtTypeRequest computation.
 //----------------------------------------------------------------------------//

lib/AST/Expr.cpp

@@ -2054,7 +2054,7 @@ Type ClosureExpr::getExplicitThrownType() const {
 
   ASTContext &ctx = getASTContext();
   auto mutableThis = const_cast<ClosureExpr *>(this);
-  ExplicitCaughtTypeRequest request{mutableThis, mutableThis};
+  ExplicitCaughtTypeRequest request{&ctx, mutableThis};
   return evaluateOrDefault(ctx.evaluator, request, Type());
 }
 

lib/AST/Stmt.cpp

@@ -452,16 +452,18 @@ Expr *ForEachStmt::getTypeCheckedSequence() const {
   return iteratorVar ? iteratorVar->getInit(/*index=*/0) : nullptr;
 }
 
-DoCatchStmt *DoCatchStmt::create(ASTContext &ctx, LabeledStmtInfo labelInfo,
+DoCatchStmt *DoCatchStmt::create(DeclContext *dc,
+                                 LabeledStmtInfo labelInfo,
                                  SourceLoc doLoc,
                                  SourceLoc throwsLoc, TypeLoc thrownType,
                                  Stmt *body,
                                  ArrayRef<CaseStmt *> catches,
                                  llvm::Optional<bool> implicit) {
+  ASTContext &ctx = dc->getASTContext();
   void *mem = ctx.Allocate(totalSizeToAlloc<CaseStmt *>(catches.size()),
                            alignof(DoCatchStmt));
-  return ::new (mem) DoCatchStmt(labelInfo, doLoc, throwsLoc, thrownType, body,
-                                 catches, implicit);
+  return ::new (mem) DoCatchStmt(dc, labelInfo, doLoc, throwsLoc, thrownType,
+                                 body, catches, implicit);
 }
 
 bool CaseLabelItem::isSyntacticallyExhaustive() const {
@@ -478,15 +480,14 @@ bool DoCatchStmt::isSyntacticallyExhaustive() const {
   return false;
 }
 
-Type DoCatchStmt::getExplicitCaughtType(DeclContext *dc) const {
-  ASTContext &ctx = dc->getASTContext();
-  ExplicitCaughtTypeRequest request{dc, const_cast<DoCatchStmt *>(this)};
-  return evaluateOrDefault(ctx.evaluator, request, Type());
+Type DoCatchStmt::getExplicitCaughtType() const {
+  ASTContext &ctx = DC->getASTContext();
+  return CatchNode(const_cast<DoCatchStmt *>(this)).getExplicitCaughtType(ctx);
 }
 
-Type DoCatchStmt::getCaughtErrorType(DeclContext *dc) const {
+Type DoCatchStmt::getCaughtErrorType() const {
   // Check for an explicitly-specified error type.
-  if (Type explicitError = getExplicitCaughtType(dc))
+  if (Type explicitError = getExplicitCaughtType())
     return explicitError;
 
   auto firstPattern = getCatches()

lib/Parse/ParseStmt.cpp

@@ -2256,8 +2256,8 @@ ParserResult<Stmt> Parser::parseStmtDo(LabeledStmtInfo labelInfo,
     }
 
     return makeParserResult(status,
-      DoCatchStmt::create(Context, labelInfo, doLoc, throwsLoc, thrownType,
-                          body.get(), allClauses));
+      DoCatchStmt::create(CurDeclContext, labelInfo, doLoc, throwsLoc,
+                          thrownType, body.get(), allClauses));
   }
 
   if (throwsLoc.isValid()) {