Suppress warnings about Never error types in catch clauses

Enabling typed throws has introduced some spurious warnings about error
values of `Never` type on top of the custom "unreachable" diagnostics
for catch clauses, so suppress the new warnings---they aren't helpful.

Author: DougGregor

lib/Sema/ConstraintSystem.cpp

@@ -373,6 +373,10 @@ void ConstraintSystem::recordPotentialThrowSite(
     ConstraintLocatorBuilder locator) {
   ASTContext &ctx = getASTContext();
 
+  // Only record potential throw sites when typed throws is enabled.
+  if (!ctx.LangOpts.hasFeature(Feature::FullTypedThrows))
+    return;
+
   // Catch node location is determined by the source location.
   auto sourceLoc = locator.getAnchor().getStartLoc();
   if (!sourceLoc)
@@ -428,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/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.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.

test/Parse/errors.swift

@@ -19,12 +19,14 @@ func one() {
   do {
 
   } catch { // expected-warning {{'catch' block is unreachable because no errors are thrown in 'do' block}}
-    let error2 = error
+    let error2 = error // expected-warning{{constant 'error2' inferred to have type 'Never', which is an enum with no cases}}
+    // expected-note@-1{{add an explicit type annotation to silence this warning}}
   }
 
   do {
   } catch where true { // expected-warning {{'catch' block is unreachable because no errors are thrown in 'do' block}}
-    let error2 = error
+    let error2 = error // expected-warning{{constant 'error2' inferred to have type 'Never', which is an enum with no cases}}
+    // expected-note@-1{{add an explicit type annotation to silence this warning}}
   } catch {
   }
 

test/Sema/redeclaration-checking.swift

@@ -87,6 +87,7 @@ func stmtTest() {
   // expected-note@-1 {{'x' previously declared here}}
   // expected-error@-2 {{invalid redeclaration of 'x'}}
   // expected-warning@-3 {{unreachable}}
+  // expected-error@-4{{pattern of type 'MyError' cannot match 'Never'}}
 }
 
 func fullNameTest() {

test/StringProcessing/Parse/forward-slash-regex.swift

@@ -262,7 +262,7 @@ default:
 }
 
 do {} catch /x/ {}
-// expected-error@-1 {{expression pattern of type 'Regex<Substring>' cannot match values of type 'any Error'}}
+// expected-error@-1 {{expression pattern of type 'Regex<Substring>' cannot match values of type 'Never'}}
 // expected-warning@-2 {{'catch' block is unreachable because no errors are thrown in 'do' block}}
 
 switch /x/ {