[Typed throws] Unify ThrownTypeRequest and DoCatchExplicitThrownTypeRequest

These two requests are effectively doing the same thing to two
different cases within CatchNode. Unify the requests into a single
request, ExplicitCaughtTypeRequest, which operates on a CatchNode.

This also moves the logic for closures with explicitly-specified throws
clauses into the same request, taking it out of the constraint system.

Author: DougGregor

include/swift/AST/CatchNode.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_AST_CATCHNODE_H
 #define SWIFT_AST_CATCHNODE_H
 
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "swift/AST/Decl.h"
@@ -36,8 +37,15 @@ 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;
+
+  friend llvm::hash_code hash_value(CatchNode catchNode) {
+    using llvm::hash_value;
+    return hash_value(catchNode.getOpaqueValue());
+  }
 };
 
+void simple_display(llvm::raw_ostream &out, CatchNode catchNode);
+
 } // end namespace swift
 
 #endif // SWIFT_AST_CATCHNODE_H

include/swift/AST/Decl.h

@@ -6989,7 +6989,7 @@ void simple_display(llvm::raw_ostream &out, BodyAndFingerprint value);
 /// Base class for function-like declarations.
 class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   friend class NeedsNewVTableEntryRequest;
-  friend class ThrownTypeRequest;
+  friend class ExplicitCaughtTypeRequest;
 
 public:
   /// records the kind of SILGen-synthesized body this decl represents

include/swift/AST/Expr.h

@@ -3987,6 +3987,8 @@ class SerializedAbstractClosureExpr : public SerializedLocalDeclContext {
 ///     { [weak c] (a : Int) -> Int in a + c!.getFoo() }
 /// \endcode
 class ClosureExpr : public AbstractClosureExpr {
+  friend class ExplicitCaughtTypeRequest;
+
 public:
   enum class BodyState {
     /// The body was parsed, but not ready for type checking because
@@ -4034,7 +4036,7 @@ class ClosureExpr : public AbstractClosureExpr {
   /// The location of the "in", if present.
   SourceLoc InLoc;
 
-  /// The explcitly-specified thrown type.
+  /// The explicitly-specified thrown type.
   TypeExpr *ThrownType;
 
   /// The explicitly-specified result type.
@@ -4149,14 +4151,7 @@ class ClosureExpr : public AbstractClosureExpr {
   }
 
   /// Retrieve the explicitly-thrown type.
-  Type getExplicitThrownType() const {
-    if (ThrownType)
-      return ThrownType->getInstanceType();
-
-    return nullptr;
-  }
-
-  void setExplicitThrownType(Type thrownType);
+  Type getExplicitThrownType() const;
 
   /// Retrieve the explicitly-thrown type representation.
   TypeRepr *getExplicitThrownTypeRepr() const {

include/swift/AST/Stmt.h

@@ -1387,7 +1387,7 @@ class DoCatchStmt final
     : public LabeledStmt,
       private llvm::TrailingObjects<DoCatchStmt, CaseStmt *> {
   friend TrailingObjects;
-  friend class DoCatchExplicitThrownTypeRequest;
+  friend class ExplicitCaughtTypeRequest;
 
   SourceLoc DoLoc;
 
@@ -1429,13 +1429,13 @@ class DoCatchStmt final
   SourceLoc getStartLoc() const { return getLabelLocOrKeywordLoc(DoLoc); }
   SourceLoc getEndLoc() const { return getCatches().back()->getEndLoc(); }
 
-  /// Retrieves the type representation for the thrown type.
-  TypeRepr *getThrownTypeRepr() const {
+  /// Retrieves the type representation for the caught type.
+  TypeRepr *getCaughtTypeRepr() const {
     return ThrownType.getTypeRepr();
   }
 
-  // Get the explicitly-specified thrown error type.
-  Type getExplicitlyThrownType(DeclContext *dc) const;
+  // Get the explicitly-specified caught error type.
+  Type getExplicitCaughtType(DeclContext *dc) const;
 
   Stmt *getBody() const { return Body; }
   void setBody(Stmt *s) { Body = s; }

include/swift/AST/TypeCheckRequests.h

@@ -20,6 +20,7 @@
 #include "swift/AST/AnyFunctionRef.h"
 #include "swift/AST/ASTNode.h"
 #include "swift/AST/ASTTypeIDs.h"
+#include "swift/AST/CatchNode.h"
 #include "swift/AST/Effects.h"
 #include "swift/AST/GenericParamList.h"
 #include "swift/AST/GenericSignature.h"
@@ -2283,31 +2284,16 @@ class ParamSpecifierRequest
   void cacheResult(ParamSpecifier value) const;
 };
 
-/// Determines the explicitly-written thrown result type of a function.
-class ThrownTypeRequest
-    : public SimpleRequest<ThrownTypeRequest,
-                           Type(AbstractFunctionDecl *),
-                           RequestFlags::SeparatelyCached> {
-public:
-  using SimpleRequest::SimpleRequest;
-
-private:
-  friend SimpleRequest;
-
-  // Evaluation.
-  Type evaluate(Evaluator &evaluator, AbstractFunctionDecl *func) const;
-
-public:
-  // Separate caching.
-  bool isCached() const { return true; }
-  llvm::Optional<Type> getCachedResult() const;
-  void cacheResult(Type value) const;
-};
-
-/// Determines the explicitly-written thrown error type in a do..catch block.
-class DoCatchExplicitThrownTypeRequest
-    : public SimpleRequest<DoCatchExplicitThrownTypeRequest,
-                           Type(DeclContext *, DoCatchStmt *),
+/// Determines the explicitly-written caught result type for any catch node,
+/// including functions/closures and do..catch statements.
+///
+/// Returns the caught result type for the catch node, which will be
+/// `Never` if no error can be thrown from within the context (e.g., a
+/// non-throwing function). Returns a NULL type if the caught error type
+/// requires type inference.
+class ExplicitCaughtTypeRequest
+    : public SimpleRequest<ExplicitCaughtTypeRequest,
+                           Type(DeclContext *, CatchNode),
                            RequestFlags::SeparatelyCached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -2316,7 +2302,7 @@ class DoCatchExplicitThrownTypeRequest
   friend SimpleRequest;
 
   // Evaluation.
-  Type evaluate(Evaluator &evaluator, DeclContext *dc, DoCatchStmt *stmt) const;
+  Type evaluate(Evaluator &evaluator, DeclContext *dc, CatchNode catchNode) const;
 
 public:
   // Separate caching.

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -358,11 +358,8 @@ SWIFT_REQUEST(TypeChecker, NeedsNewVTableEntryRequest,
               bool(AbstractFunctionDecl *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ParamSpecifierRequest,
               ParamDecl::Specifier(ParamDecl *), SeparatelyCached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, ThrownTypeRequest,
-              Type(AbstractFunctionDecl *), SeparatelyCached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, DoCatchExplicitThrownTypeRequest,
-              Type(DeclContext *, DoCatchStmt *), SeparatelyCached,
-              NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, ExplicitCaughtTypeRequest,
+              Type(DeclContext *, CatchNode), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ResultTypeRequest,
               Type(ValueDecl *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, AreAllStoredPropertiesDefaultInitableRequest,

lib/AST/Decl.cpp

@@ -979,9 +979,13 @@ bool Decl::preconcurrency() const {
 }
 
 Type AbstractFunctionDecl::getThrownInterfaceType() const {
+  if (!getThrownTypeRepr())
+    return ThrownType.getType();
+
+  auto mutableThis = const_cast<AbstractFunctionDecl *>(this);
   return evaluateOrDefault(
       getASTContext().evaluator,
-      ThrownTypeRequest{const_cast<AbstractFunctionDecl *>(this)},
+      ExplicitCaughtTypeRequest{mutableThis, mutableThis},
       Type());
 }
 
@@ -11737,3 +11741,96 @@ CatchNode::getThrownErrorTypeInContext(DeclContext *dc) const {
 
   llvm_unreachable("Unhandled catch node kind");
 }
+
+void swift::simple_display(llvm::raw_ostream &out, CatchNode catchNode) {
+  out << "catch node";
+}
+
+//----------------------------------------------------------------------------//
+// ExplicitCaughtTypeRequest computation.
+//----------------------------------------------------------------------------//
+bool ExplicitCaughtTypeRequest::isCached() const {
+  auto catchNode = std::get<1>(getStorage());
+
+  // try? and try! never need to be cached.
+  if (catchNode.is<AnyTryExpr *>())
+    return false;
+
+  // Functions with explicitly-written thrown types need the result cached.
+  if (auto func = catchNode.dyn_cast<AbstractFunctionDecl *>()) {
+    return func->ThrownType.getTypeRepr() != nullptr;
+  }
+
+  // Closures with explicitly-written thrown types need the result cached.
+  if (auto abstractClosure = catchNode.dyn_cast<AbstractClosureExpr *>()) {
+    if (auto closure = dyn_cast<ClosureExpr>(abstractClosure)) {
+      return closure->ThrownType != nullptr;
+    }
+
+    return false;
+  }
+
+  // Do..catch with explicitly-written thrown types need the result cached.
+  if (auto doCatch = catchNode.dyn_cast<DoCatchStmt *>()) {
+    return doCatch->getThrowsLoc().isValid();
+  }
+
+  llvm_unreachable("Unhandled catch node");
+}
+
+llvm::Optional<Type> ExplicitCaughtTypeRequest::getCachedResult() const {
+  // Map a possibly-null Type to llvm::Optional<Type>.
+  auto nonnullTypeOrNone = [](Type type) -> llvm::Optional<Type> {
+    if (type.isNull())
+      return llvm::None;
+
+    return type;
+  };
+
+  auto catchNode = std::get<1>(getStorage());
+
+  if (auto func = catchNode.dyn_cast<AbstractFunctionDecl *>()) {
+    return nonnullTypeOrNone(func->ThrownType.getType());
+  }
+
+  if (auto abstractClosure = catchNode.dyn_cast<AbstractClosureExpr *>()) {
+    auto closure = cast<ClosureExpr>(abstractClosure);
+    if (closure->ThrownType) {
+      return nonnullTypeOrNone(closure->ThrownType->getInstanceType());
+    }
+
+    return llvm::None;
+  }
+
+  if (auto doCatch = catchNode.dyn_cast<DoCatchStmt *>()) {
+    return nonnullTypeOrNone(doCatch->ThrownType.getType());
+  }
+
+  llvm_unreachable("Unhandled catch node");
+}
+
+void ExplicitCaughtTypeRequest::cacheResult(Type type) const {
+  auto catchNode = std::get<1>(getStorage());
+
+  if (auto func = catchNode.dyn_cast<AbstractFunctionDecl *>()) {
+    func->ThrownType.setType(type);
+    return;
+  }
+
+  if (auto abstractClosure = catchNode.dyn_cast<AbstractClosureExpr *>()) {
+    auto closure = cast<ClosureExpr>(abstractClosure);
+    if (closure->ThrownType)
+      closure->ThrownType->setType(MetatypeType::get(type));
+    else
+      closure->ThrownType =
+          TypeExpr::createImplicit(type, type->getASTContext());
+    return;
+  }
+
+  if (auto doCatch = catchNode.dyn_cast<DoCatchStmt *>()) {
+    doCatch->ThrownType.setType(type);
+    return;
+  }
+
+  llvm_unreachable("Unhandled catch node");
+}

lib/AST/Expr.cpp

@@ -2046,11 +2046,14 @@ bool ClosureExpr::hasEmptyBody() const {
   return getBody()->empty();
 }
 
-void ClosureExpr::setExplicitThrownType(Type thrownType) {
-  assert(thrownType && !thrownType->hasTypeVariable() &&
-         !thrownType->hasPlaceholder());
-  assert(ThrownType);
-  ThrownType->setType(MetatypeType::get(thrownType));
+Type ClosureExpr::getExplicitThrownType() const {
+  if (getThrowsLoc().isInvalid())
+    return Type();
+  
+  ASTContext &ctx = getASTContext();
+  auto mutableThis = const_cast<ClosureExpr *>(this);
+  ExplicitCaughtTypeRequest request{mutableThis, mutableThis};
+  return evaluateOrDefault(ctx.evaluator, request, Type());
 }
 
 void ClosureExpr::setExplicitResultType(Type ty) {

lib/AST/Stmt.cpp

@@ -478,15 +478,15 @@ bool DoCatchStmt::isSyntacticallyExhaustive() const {
   return false;
 }
 
-Type DoCatchStmt::getExplicitlyThrownType(DeclContext *dc) const {
+Type DoCatchStmt::getExplicitCaughtType(DeclContext *dc) const {
   ASTContext &ctx = dc->getASTContext();
-  DoCatchExplicitThrownTypeRequest request{dc, const_cast<DoCatchStmt *>(this)};
+  ExplicitCaughtTypeRequest request{dc, const_cast<DoCatchStmt *>(this)};
   return evaluateOrDefault(ctx.evaluator, request, Type());
 }
 
 Type DoCatchStmt::getCaughtErrorType(DeclContext *dc) const {
   // Check for an explicitly-specified error type.
-  if (Type explicitError = getExplicitlyThrownType(dc))
+  if (Type explicitError = getExplicitCaughtType(dc))
     return explicitError;
 
   auto firstPattern = getCatches()

lib/AST/TypeCheckRequests.cpp

@@ -951,47 +951,6 @@ void ParamSpecifierRequest::cacheResult(ParamSpecifier specifier) const {
   decl->setSpecifier(specifier);
 }
 
-//----------------------------------------------------------------------------//
-// ThrownTypeRequest computation.
-//----------------------------------------------------------------------------//
-
-llvm::Optional<Type> ThrownTypeRequest::getCachedResult() const {
-  auto *const func = std::get<0>(getStorage());
-  Type thrownType = func->ThrownType.getType();
-  if (thrownType.isNull())
-    return llvm::None;
-
-  return thrownType;
-}
-
-void ThrownTypeRequest::cacheResult(Type type) const {
-  auto *const func = std::get<0>(getStorage());
-  func->ThrownType.setType(type);
-}
-
-//----------------------------------------------------------------------------//
-// DoCatchExplicitThrownTypeRequest computation.
-//----------------------------------------------------------------------------//
-
-bool DoCatchExplicitThrownTypeRequest::isCached() const {
-  auto *const stmt = std::get<1>(getStorage());
-  return stmt->getThrowsLoc().isValid();
-}
-
-llvm::Optional<Type> DoCatchExplicitThrownTypeRequest::getCachedResult() const {
-  auto *const stmt = std::get<1>(getStorage());
-  Type thrownType = stmt->ThrownType.getType();
-  if (thrownType.isNull())
-    return llvm::None;
-
-  return thrownType;
-}
-
-void DoCatchExplicitThrownTypeRequest::cacheResult(Type type) const {
-  auto *const stmt = std::get<1>(getStorage());
-  stmt->ThrownType.setType(type);
-}
-
 //----------------------------------------------------------------------------//
 // ResultTypeRequest computation.
 //----------------------------------------------------------------------------//