[Typed throws] Implement support for do throws(...) syntax

During the review of SE-0413, typed throws, the notion of a `do throws`
syntax for `do..catch` blocks came up. Implement that syntax and
semantics, as a way to explicitly specify the type of error that is
thrown from the `do` body in `do..catch` statement.

Author: DougGregor

include/swift/AST/CatchNode.h

@@ -35,7 +35,7 @@ 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(ASTContext &ctx) const;
+  llvm::Optional<Type> getThrownErrorTypeInContext(DeclContext *dc) const;
 };
 
 } // end namespace swift

include/swift/AST/DiagnosticsParse.def

@@ -1196,6 +1196,9 @@ ERROR(expected_catch_where_expr,PointsToFirstBadToken,
 ERROR(docatch_not_trycatch,PointsToFirstBadToken,
       "the 'do' keyword is used to specify a 'catch' region",
       ())
+ERROR(do_throws_without_catch,none,
+      "a 'do' statement with a 'throws' clause must have at least one 'catch'",
+      ())
 
 // C-Style For Stmt
 ERROR(c_style_for_stmt_removed,none,

include/swift/AST/Stmt.h

@@ -24,6 +24,7 @@
 #include "swift/AST/ConcreteDeclRef.h"
 #include "swift/AST/IfConfigClause.h"
 #include "swift/AST/TypeAlignments.h"
+#include "swift/AST/TypeLoc.h"
 #include "swift/AST/ThrownErrorDestination.h"
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/NullablePtr.h"
@@ -1381,16 +1382,25 @@ class DoCatchStmt final
     : public LabeledStmt,
       private llvm::TrailingObjects<DoCatchStmt, CaseStmt *> {
   friend TrailingObjects;
+  friend class DoCatchExplicitThrownTypeRequest;
 
   SourceLoc DoLoc;
+
+  /// Location of the 'throws' token.
+  SourceLoc ThrowsLoc;
+
+  /// The error type that is being thrown.
+  TypeLoc ThrownType;
+
   Stmt *Body;
   ThrownErrorDestination RethrowDest;
 
-  DoCatchStmt(LabeledStmtInfo labelInfo, SourceLoc doLoc, Stmt *body,
+  DoCatchStmt(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), Body(body) {
+        DoLoc(doLoc), ThrowsLoc(throwsLoc), ThrownType(thrownType), Body(body) {
     Bits.DoCatchStmt.NumCatches = catches.size();
     std::uninitialized_copy(catches.begin(), catches.end(),
                             getTrailingObjects<CaseStmt *>());
@@ -1400,15 +1410,28 @@ class DoCatchStmt final
 
 public:
   static DoCatchStmt *create(ASTContext &ctx, LabeledStmtInfo labelInfo,
-                             SourceLoc doLoc, Stmt *body,
+                             SourceLoc doLoc, 
+                             SourceLoc throwsLoc, TypeLoc thrownType,
+                             Stmt *body,
                              ArrayRef<CaseStmt *> catches,
                              llvm::Optional<bool> implicit = llvm::None);
 
   SourceLoc getDoLoc() const { return DoLoc; }
 
+  /// Retrieve the location of the 'throws' keyword, if present.
+  SourceLoc getThrowsLoc() const { return ThrowsLoc; }
+
   SourceLoc getStartLoc() const { return getLabelLocOrKeywordLoc(DoLoc); }
   SourceLoc getEndLoc() const { return getCatches().back()->getEndLoc(); }
 
+  /// Retrieves the type representation for the thrown type.
+  TypeRepr *getThrownTypeRepr() const {
+    return ThrownType.getTypeRepr();
+  }
+
+  // Get the explicitly-specified thrown error type.
+  Type getExplicitlyThrownType(DeclContext *dc) const;
+
   Stmt *getBody() const { return Body; }
   void setBody(Stmt *s) { Body = s; }
 
@@ -1433,7 +1456,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() const;
+  Type getCaughtErrorType(DeclContext *dc) const;
 
   /// Retrieves the rethrown error and its conversion to the error type
   /// expected by the enclosing context.

include/swift/AST/TypeCheckRequests.h

@@ -46,6 +46,7 @@ class ContextualPattern;
 class ContinueStmt;
 class DefaultArgumentExpr;
 class DefaultArgumentType;
+class DoCatchStmt;
 struct ExternalMacroDefinition;
 class ClosureExpr;
 class GenericParamList;
@@ -2303,6 +2304,27 @@ class ThrownTypeRequest
   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 *),
+                           RequestFlags::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  Type evaluate(Evaluator &evaluator, DeclContext *dc, DoCatchStmt *stmt) const;
+
+public:
+  // Separate caching.
+  bool isCached() const;
+  llvm::Optional<Type> getCachedResult() const;
+  void cacheResult(Type value) const;
+};
+
 /// Determines the result type of a function or element type of a subscript.
 class ResultTypeRequest
     : public SimpleRequest<ResultTypeRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -360,6 +360,9 @@ 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, ResultTypeRequest,
               Type(ValueDecl *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, AreAllStoredPropertiesDefaultInitableRequest,

lib/AST/Decl.cpp

@@ -11634,7 +11634,7 @@ MacroDiscriminatorContext::getParentOf(FreestandingMacroExpansion *expansion) {
 }
 
 llvm::Optional<Type>
-CatchNode::getThrownErrorTypeInContext(ASTContext &ctx) const {
+CatchNode::getThrownErrorTypeInContext(DeclContext *dc) const {
   if (auto func = dyn_cast<AbstractFunctionDecl *>()) {
     if (auto thrownError = func->getEffectiveThrownErrorType())
       return func->mapTypeIntoContext(*thrownError);
@@ -11651,13 +11651,13 @@ CatchNode::getThrownErrorTypeInContext(ASTContext &ctx) const {
   }
 
   auto doCatch = get<DoCatchStmt *>();
-  if (auto thrownError = doCatch->getCaughtErrorType()) {
+  if (auto thrownError = doCatch->getCaughtErrorType(dc)) {
     if (thrownError->isNever())
       return llvm::None;
 
     return thrownError;
   }
 
   // If we haven't computed the error type yet, do so now.
-  return ctx.getErrorExistentialType();
+  return dc->getASTContext().getErrorExistentialType();
 }

lib/AST/Stmt.cpp

@@ -450,12 +450,15 @@ Expr *ForEachStmt::getTypeCheckedSequence() const {
 }
 
 DoCatchStmt *DoCatchStmt::create(ASTContext &ctx, LabeledStmtInfo labelInfo,
-                                 SourceLoc doLoc, Stmt *body,
+                                 SourceLoc doLoc,
+                                 SourceLoc throwsLoc, TypeLoc thrownType,
+                                 Stmt *body,
                                  ArrayRef<CaseStmt *> catches,
                                  llvm::Optional<bool> implicit) {
   void *mem = ctx.Allocate(totalSizeToAlloc<CaseStmt *>(catches.size()),
                            alignof(DoCatchStmt));
-  return ::new (mem) DoCatchStmt(labelInfo, doLoc, body, catches, implicit);
+  return ::new (mem) DoCatchStmt(labelInfo, doLoc, throwsLoc, thrownType, body,
+                                 catches, implicit);
 }
 
 bool CaseLabelItem::isSyntacticallyExhaustive() const {
@@ -472,7 +475,17 @@ bool DoCatchStmt::isSyntacticallyExhaustive() const {
   return false;
 }
 
-Type DoCatchStmt::getCaughtErrorType() const {
+Type DoCatchStmt::getExplicitlyThrownType(DeclContext *dc) const {
+  ASTContext &ctx = dc->getASTContext();
+  DoCatchExplicitThrownTypeRequest 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))
+    return explicitError;
+
   auto firstPattern = getCatches()
     .front()
     ->getCaseLabelItems()

lib/AST/TypeCheckRequests.cpp

@@ -969,6 +969,29 @@ void ThrownTypeRequest::cacheResult(Type type) const {
   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.
 //----------------------------------------------------------------------------//

lib/Parse/ParseStmt.cpp

@@ -2191,8 +2191,8 @@ ParserResult<Stmt> Parser::parseStmtRepeat(LabeledStmtInfo labelInfo) {
 
 /// 
 ///   stmt-do:
-///     (identifier ':')? 'do' stmt-brace
-///     (identifier ':')? 'do' stmt-brace stmt-catch+
+///     (identifier ':')? 'do' throws-clause? stmt-brace
+///     (identifier ':')? 'do' throws-clause? stmt-brace stmt-catch+
 ParserResult<Stmt> Parser::parseStmtDo(LabeledStmtInfo labelInfo,
                                        bool shouldSkipDoTokenConsume) {
   SourceLoc doLoc;
@@ -2205,6 +2205,25 @@ ParserResult<Stmt> Parser::parseStmtDo(LabeledStmtInfo labelInfo,
 
   ParserStatus status;
 
+  // Parse the optional 'throws' clause.
+  SourceLoc throwsLoc;
+  TypeRepr *thrownType = nullptr;
+  if (consumeIf(tok::kw_throws, throwsLoc)) {
+    // Parse the thrown error type.
+    SourceLoc lParenLoc;
+    if (consumeIf(tok::l_paren, lParenLoc)) {
+      ParserResult<TypeRepr> parsedThrownTy =
+          parseType(diag::expected_thrown_error_type);
+      thrownType = parsedThrownTy.getPtrOrNull();
+      status |= parsedThrownTy;
+
+      SourceLoc rParenLoc;
+      parseMatchingToken(
+          tok::r_paren, rParenLoc,
+          diag::expected_rparen_after_thrown_error_type, lParenLoc);
+    }
+  }
+
   ParserResult<BraceStmt> body =
       parseBraceItemList(diag::expected_lbrace_after_do);
   status |= body;
@@ -2236,7 +2255,12 @@ ParserResult<Stmt> Parser::parseStmtDo(LabeledStmtInfo labelInfo,
     }
 
     return makeParserResult(status,
-      DoCatchStmt::create(Context, labelInfo, doLoc, body.get(), allClauses));
+      DoCatchStmt::create(Context, labelInfo, doLoc, throwsLoc, thrownType,
+                          body.get(), allClauses));
+  }
+
+  if (throwsLoc.isValid()) {
+    diagnose(throwsLoc, diag::do_throws_without_catch);
   }
 
   // If we dont see a 'while' or see a 'while' that starts

lib/SILGen/SILGenStmt.cpp

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

lib/Sema/TypeCheckEffects.cpp

@@ -2751,9 +2751,10 @@ 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();
+    auto dc = CurContext.getDeclContext();
+    auto module = dc->getParentModule();
     if (CatchNode catchNode = ASTScope::lookupCatchNode(module, loc)) {
-      if (auto caughtType = catchNode.getThrownErrorTypeInContext(Ctx))
+      if (auto caughtType = catchNode.getThrownErrorTypeInContext(dc))
         return *caughtType;
     }
 
@@ -2880,7 +2881,8 @@ 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()) {
+    } else if (Type rethrownErrorType =
+                   S->getCaughtErrorType(CurContext.getDeclContext())) {
       // 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();
@@ -3510,15 +3512,23 @@ llvm::Optional<Type> TypeChecker::canThrow(ASTContext &ctx, Expr *expr) {
   return classification.getThrownError();
 }
 
-Type TypeChecker::catchErrorType(ASTContext &ctx, DoCatchStmt *stmt) {
+Type TypeChecker::catchErrorType(DeclContext *dc, DoCatchStmt *stmt) {
+  ASTContext &ctx = dc->getASTContext();
+
   // When typed throws is disabled, this is always "any Error".
   // FIXME: When we distinguish "precise" typed throws from normal typed
   // throws, we'll be able to compute a more narrow catch error type in some
   // case, e.g., from a `try` but not a `throws`.
   if (!ctx.LangOpts.hasFeature(Feature::TypedThrows))
     return ctx.getErrorExistentialType();
 
-  // Classify the throwing behavior of the "do" body.
+  // If the do..catch statement explicitly specifies that it throws, use
+  // that type.
+  if (Type explicitError = stmt->getExplicitlyThrownType(dc)) {
+    return explicitError;
+  }
+
+  // Otherwise, infer the thrown error type from the "do" body.
   ApplyClassifier classifier(ctx);
   Classification classification = classifier.classifyStmt(
       stmt->getBody(), EffectKind::Throws);

lib/Sema/TypeCheckStmt.cpp

@@ -1195,8 +1195,7 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
         DC->getParentModule(), TS->getThrowLoc());
     Type errorType;
     if (catchNode) {
-      errorType = catchNode.getThrownErrorTypeInContext(getASTContext())
-          .value_or(Type());
+      errorType = catchNode.getThrownErrorTypeInContext(DC).value_or(Type());
     }
 
     // If there was no error type, use 'any Error'. We'll check it later.
@@ -1679,7 +1678,7 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
     // Do-catch statements always limit exhaustivity checks.
     bool limitExhaustivityChecks = true;
 
-    Type caughtErrorType = TypeChecker::catchErrorType(Ctx, S);
+    Type caughtErrorType = TypeChecker::catchErrorType(DC, S);
     auto catches = S->getCatches();
     checkSiblingCaseStmts(catches.begin(), catches.end(),
                           CaseParentKind::DoCatch, limitExhaustivityChecks,

lib/Sema/TypeCheckType.cpp

@@ -5626,3 +5626,29 @@ Type CustomAttrTypeRequest::evaluate(Evaluator &eval, CustomAttr *attr,
 
   return type;
 }
+
+Type DoCatchExplicitThrownTypeRequest::evaluate(
+    Evaluator &evaluator, DeclContext *dc, DoCatchStmt *stmt
+) const {
+  if (stmt->getThrowsLoc().isInvalid())
+    return Type();
+
+  // If typed throws is not enabled, complain.
+  ASTContext &ctx = dc->getASTContext();
+  if (!ctx.LangOpts.hasFeature(Feature::TypedThrows)) {
+    ctx.Diags.diagnose(stmt->getThrowsLoc(), diag::experimental_typed_throws);
+    return Type();
+}
+
+  auto typeRepr = stmt->getThrownTypeRepr();
+
+  // If there is no explicitly-specified thrown error type, it's 'any Error'.
+  if (!typeRepr) {
+    return ctx.getErrorExistentialType();
+  }
+
+  return TypeResolution::resolveContextualType(
+      typeRepr, dc, TypeResolutionOptions(TypeResolverContext::None),
+      /*unboundTyOpener*/ nullptr, PlaceholderType::get,
+      /*packElementOpener*/ nullptr);
+}

lib/Sema/TypeChecker.h

@@ -1176,7 +1176,7 @@ llvm::Optional<Type> canThrow(ASTContext &ctx, Expr *expr);
 ///
 /// The error type is used in the catch clauses and, for a nonexhausive
 /// do-catch, is implicitly rethrown out of the do...catch block.
-Type catchErrorType(ASTContext &ctx, DoCatchStmt *stmt);
+Type catchErrorType(DeclContext *dc, DoCatchStmt *stmt);
 
 /// Given two error types, merge them into the "union" of both error types
 /// that is a supertype of both error types.