Eliminate the DeclContext from ExplicitCaughtTypeRequest

Correctly determining the DeclContext needed for an
ExplicitCaughtTypeRequest is tricky for a number of callers, and
mistakes here can easily lead to redundant computation of the caught
type, redundant diagnostics, etc.

Instead, put a `DeclContext` into `DoCatchStmt`, because that's the
only catch node that needs a `DeclContext` but does not have one.

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

@@ -1389,6 +1389,8 @@ class DoCatchStmt final
   friend TrailingObjects;
   friend class ExplicitCaughtTypeRequest;
 
+  DeclContext *DC;
+
   SourceLoc DoLoc;
 
   /// Location of the 'throws' token.
@@ -1400,12 +1402,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 *>());
@@ -1414,13 +1417,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.
@@ -1435,7 +1441,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; }
@@ -1461,7 +1467,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,

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> 
@@ -11710,7 +11707,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);
@@ -11733,15 +11730,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 *>();
@@ -11750,24 +11747,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

@@ -2255,8 +2255,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()) {

lib/SILGen/SILGenStmt.cpp

@@ -1117,7 +1117,7 @@ void StmtEmitter::visitDoStmt(DoStmt *S) {
 }
 
 void StmtEmitter::visitDoCatchStmt(DoCatchStmt *S) {
-  Type formalExnType = S->getCaughtErrorType(SGF.FunctionDC);
+  Type formalExnType = S->getCaughtErrorType();
   auto &exnTL = SGF.getTypeLowering(formalExnType);
 
   SILValue exnArg;