Merge pull request #70677 from DougGregor/se-0413-typed-throws

Enable SE-0413 "Typed Throws" by default

Author: DougGregor

CHANGELOG.md

@@ -3,6 +3,49 @@
 > **Note**\
 > This is in reverse chronological order, so newer entries are added to the top.
 
+## Swift 5.11
+
+* [SE-0413][]:
+
+  Functions can now specify the type of error that they throw as part of the
+  function signature. For example:
+
+  ```swift
+  func parseRecord(from string: String) throws(ParseError) -> Record { ... }
+  ```
+
+  A call to `parseRecord(from:)` will either return a `Record` instance or throw
+  an error of type `ParseError`. For example, a `do..catch` block will infer
+  the `error` variable as being of type `ParseError`:
+
+  ```swift
+  do {
+    let record = try parseRecord(from: myString)
+  } catch {
+    // error has type ParseError
+  }
+  ```
+
+  Typed throws generalizes over throwing and non-throwing functions. A function
+  that is specified as `throws` (without an explicitly-specified error type) is
+  equivalent to one that specifies `throws(any Error)`, whereas a non-throwing
+  is equivalent to one that specifies `throws(Never)`. Calls to functions that
+  are `throws(Never)` are non-throwing.
+
+  Typed throws can also be used in generic functions to propagate error types
+  from parameters, in a manner that is more precise than `rethrows`. For
+  example, the `Sequence.map` operation can propagate the thrown error type from
+  its closure parameter, indicating that it only throws errors of the same type
+  as that closure does:
+
+  ```swift
+  extension Sequence {
+    func map<T, E>(_ body: (Element) throws(E) -> T) throws(E) -> [T] { ... }
+  }
+  ```
+
+  When given a non-throwing closure as a parameter, `map` will not throw.
+
 * [#70065][]:
 
   With the implementation of [SE-0110][], a closure parameter syntax consisting
@@ -9861,6 +9904,7 @@ using the `.dynamicType` member to retrieve the type of an expression should mig
 [SE-0394]: https://github.com/apple/swift-evolution/blob/main/proposals/0394-swiftpm-expression-macros.md
 [SE-0397]: https://github.com/apple/swift-evolution/blob/main/proposals/0397-freestanding-declaration-macros.md
 [SE-0407]: https://github.com/apple/swift-evolution/blob/main/proposals/0407-member-macro-conformances.md
+[SE-0413]: https://github.com/apple/swift-evolution/blob/main/proposals/0413-typed-throws.md
 [#64927]: <https://github.com/apple/swift/issues/64927>
 [#42697]: <https://github.com/apple/swift/issues/42697>
 [#42728]: <https://github.com/apple/swift/issues/42728>

include/swift/AST/DiagnosticsSema.def

@@ -5238,9 +5238,6 @@ WARNING(no_throw_in_try,none,
 WARNING(no_throw_in_do_with_catch,none,
         "'catch' block is unreachable because no errors are thrown in 'do' block", ())
 
-ERROR(experimental_typed_throws,none,
-      "typed throws is an experimental feature", ())
-
 ERROR(thrown_type_not_error,none,
       "thrown type %0 does not conform to the 'Error' protocol", (Type))
 

include/swift/Basic/Features.def

@@ -116,6 +116,7 @@ LANGUAGE_FEATURE(ParameterPacks, 393, "Value and type parameter packs", true)
 SUPPRESSIBLE_LANGUAGE_FEATURE(LexicalLifetimes, 0, "@_eagerMove/@_noEagerMove/@_lexicalLifetimes annotations", true)
 LANGUAGE_FEATURE(FreestandingMacros, 397, "freestanding declaration macros", true)
 SUPPRESSIBLE_LANGUAGE_FEATURE(RetroactiveAttribute, 364, "@retroactive", true)
+LANGUAGE_FEATURE(TypedThrows, 413, "Typed throws", true)
 
 UPCOMING_FEATURE(ConciseMagicFile, 274, 6)
 UPCOMING_FEATURE(ForwardTrailingClosures, 286, 6)
@@ -249,9 +250,6 @@ EXPERIMENTAL_FEATURE(Embedded, true)
 /// Enables noncopyable generics
 EXPERIMENTAL_FEATURE(NoncopyableGenerics, false)
 
-/// Enables typed throws.
-EXPERIMENTAL_FEATURE(TypedThrows, true)
-
 /// Allow destructuring stored `let` bindings in structs.
 EXPERIMENTAL_FEATURE(StructLetDestructuring, true)
 

lib/ASTGen/Sources/ASTGen/SourceFile.swift

@@ -52,7 +52,6 @@ extension Parser.ExperimentalFeatures {
       }
     }
     mapFeature(.ThenStatements, to: .thenStatements)
-    mapFeature(.TypedThrows, to: .typedThrows)
     mapFeature(.DoExpressions, to: .doExpressions)
     mapFeature(.NonescapableTypes, to: .nonescapableTypes)
     mapFeature(.TransferringArgsAndResults, to: .transferringArgsAndResults)

lib/Sema/ConstraintSystem.cpp

@@ -374,7 +374,7 @@ void ConstraintSystem::recordPotentialThrowSite(
   ASTContext &ctx = getASTContext();
 
   // Only record potential throw sites when typed throws is enabled.
-  if (!ctx.LangOpts.hasFeature(Feature::TypedThrows))
+  if (!ctx.LangOpts.hasFeature(Feature::FullTypedThrows))
     return;
 
   // Catch node location is determined by the source location.
@@ -432,6 +432,9 @@ Type ConstraintSystem::getCaughtErrorType(CatchNode catchNode) {
     return getClosureType(closure)->getEffectiveThrownErrorTypeOrNever();
   }
 
+  if (!ctx.LangOpts.hasFeature(Feature::FullTypedThrows))
+    return ctx.getErrorExistentialType();
+
   // Handle inference of caught error types.
 
   // Collect all of the potential throw sites for this catch node.

lib/Sema/TypeCheckEffects.cpp

@@ -663,8 +663,7 @@ static Expr *removeErasureToExistentialError(Expr *expr) {
     return expr;
 
   ASTContext &ctx = type->getASTContext();
-  if (!ctx.LangOpts.hasFeature(Feature::FullTypedThrows) ||
-      !ctx.LangOpts.hasFeature(Feature::TypedThrows))
+  if (!ctx.LangOpts.hasFeature(Feature::FullTypedThrows))
     return expr;
 
   // Look for an outer erasure expression.

lib/Sema/TypeCheckPattern.cpp

@@ -1239,7 +1239,9 @@ Pattern *TypeChecker::coercePatternToType(
     } else if (auto MTT = diagTy->getAs<AnyMetatypeType>()) {
       if (MTT->getInstanceType()->isAnyObject())
         shouldRequireType = true;
-    } else if (diagTy->isStructurallyUninhabited()) {
+    } else if (diagTy->isStructurallyUninhabited() &&
+               !(options.contains(TypeResolutionFlags::SilenceNeverWarnings) &&
+                 type->isNever())) {
       shouldRequireType = true;
       diag = isOptional ? diag::type_inferred_to_undesirable_type
                         : diag::type_inferred_to_uninhabited_type;
@@ -1428,11 +1430,15 @@ Pattern *TypeChecker::coercePatternToType(
       if (type->hasError()) {
         return nullptr;
       }
-      diags
-          .diagnose(IP->getLoc(), diag::downcast_to_unrelated, type,
-                    IP->getCastType())
-          .highlight(IP->getLoc())
-          .highlight(IP->getCastTypeRepr()->getSourceRange());
+
+      if (!(options.contains(TypeResolutionFlags::SilenceNeverWarnings) &&
+            type->isNever())) {
+        diags
+            .diagnose(IP->getLoc(), diag::downcast_to_unrelated, type,
+                      IP->getCastType())
+            .highlight(IP->getLoc())
+            .highlight(IP->getCastTypeRepr()->getSourceRange());
+      }
 
       IP->setCastKind(CheckedCastKind::ValueCast);
       break;

lib/Sema/TypeCheckStmt.cpp

@@ -1468,6 +1468,7 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
   }
 
   void checkCaseLabelItemPattern(CaseStmt *caseBlock, CaseLabelItem &labelItem,
+                                 CaseParentKind parentKind,
                                  bool &limitExhaustivityChecks,
                                  Type subjectType) {
     Pattern *pattern = labelItem.getPattern();
@@ -1484,6 +1485,9 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
     if (subjectType) {
       auto contextualPattern = ContextualPattern::forRawPattern(pattern, DC);
       TypeResolutionOptions patternOptions(TypeResolverContext::InExpression);
+      if (parentKind == CaseParentKind::DoCatch)
+        patternOptions |= TypeResolutionFlags::SilenceNeverWarnings;
+
       auto coercedPattern = TypeChecker::coercePatternToType(
           contextualPattern, subjectType, patternOptions);
       if (coercedPattern)
@@ -1584,8 +1588,8 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
       for (auto &labelItem : caseLabelItemArray) {
         // Resolve the pattern in our case label if it has not been resolved and
         // check that our var decls follow invariants.
-        checkCaseLabelItemPattern(caseBlock, labelItem, limitExhaustivityChecks,
-                                  subjectType);
+        checkCaseLabelItemPattern(caseBlock, labelItem, parentKind,
+                                  limitExhaustivityChecks, subjectType);
 
         // Check the guard expression, if present.
         if (auto *guard = labelItem.getGuardExpr()) {

lib/Sema/TypeCheckType.cpp

@@ -3720,11 +3720,6 @@ NeverNullType TypeResolver::resolveASTFunctionType(
   Type thrownTy;
   if (auto thrownTypeRepr = repr->getThrownTypeRepr()) {
     ASTContext &ctx = getASTContext();
-    if (!ctx.LangOpts.hasFeature(Feature::TypedThrows)) {
-      diagnoseInvalid(
-          thrownTypeRepr, thrownTypeRepr->getLoc(), diag::experimental_typed_throws);
-    }
-
     auto thrownTypeOptions = options.withoutContext();
     thrownTy = resolveType(thrownTypeRepr, thrownTypeOptions);
     if (thrownTy->hasError()) {
@@ -5694,10 +5689,6 @@ Type ExplicitCaughtTypeRequest::evaluate(
     }
 
     // We have an explicit thrown error type, so resolve it.
-    if (!ctx.LangOpts.hasFeature(Feature::TypedThrows)) {
-      ctx.Diags.diagnose(thrownTypeRepr->getLoc(), diag::experimental_typed_throws);
-    }
-
     auto options = TypeResolutionOptions(TypeResolverContext::None);
     if (func->preconcurrency())
       options |= TypeResolutionFlags::Preconcurrency;
@@ -5713,11 +5704,6 @@ Type ExplicitCaughtTypeRequest::evaluate(
   if (auto closure = catchNode.dyn_cast<ClosureExpr *>()) {
     // Explicit thrown error type.
     if (auto thrownTypeRepr = closure->getExplicitThrownTypeRepr()) {
-      if (!ctx.LangOpts.hasFeature(Feature::TypedThrows)) {
-        ctx.Diags.diagnose(thrownTypeRepr->getLoc(),
-                           diag::experimental_typed_throws);
-      }
-
       return TypeResolution::resolveContextualType(
                thrownTypeRepr, closure,
                TypeResolutionOptions(TypeResolverContext::None),
@@ -5739,18 +5725,9 @@ Type ExplicitCaughtTypeRequest::evaluate(
     // A do..catch block with no explicit 'throws' annotation will infer
     // the thrown error type.
     if (doCatch->getThrowsLoc().isInvalid()) {
-      // Prior to typed throws, the do..catch always throws 'any Error'.
-      if (!ctx.LangOpts.hasFeature(Feature::TypedThrows))
-        return ctx.getErrorExistentialType();
-
       return Type();
     }
 
-    if (!ctx.LangOpts.hasFeature(Feature::TypedThrows)) {
-      ctx.Diags.diagnose(doCatch->getThrowsLoc(), diag::experimental_typed_throws);
-      return ctx.getErrorExistentialType();
-    }
-
     auto typeRepr = doCatch->getCaughtTypeRepr();
 
     // If there is no explicitly-specified thrown error type, it's 'any Error'.

lib/Sema/TypeCheckType.h

@@ -82,6 +82,10 @@ enum class TypeResolutionFlags : uint16_t {
 
   /// Whether this is a resolution based on a pack reference.
   FromPackReference = 1 << 12,
+
+  /// Whether to suppress warnings about conversions from and bindings of type
+  /// Never
+  SilenceNeverWarnings = 1 << 13,
 };
 
 /// Type resolution contexts that require special handling.