Use any Error for caught error type of an exhaustive, non-throwing do..catch

lib/Sema/TypeCheckEffects.cpp

@@ -3628,8 +3628,17 @@ Type TypeChecker::catchErrorType(DeclContext *dc, DoCatchStmt *stmt) {
       stmt->getBody(), EffectKind::Throws);
 
   // If it doesn't throw at all, the type is Never.
-  if (!classification.hasThrows())
+  if (!classification.hasThrows()) {
+    // Source compatibility: if the do..catch was already exhaustive,
+    // and we aren't doing full typed throws, treat the caught error
+    // type as 'any Error' to allow pattern-matches to continue to
+    // type check.
+    if (!ctx.LangOpts.hasFeature(Feature::FullTypedThrows) &&
+        stmt->isSyntacticallyExhaustive())
+      return ctx.getErrorExistentialType();
+
     return ctx.getNeverType();
+  }
 
   return classification.getThrownError();
 }

test/Constraints/patterns.swift

@@ -347,11 +347,20 @@ struct One<Two> { // expected-note{{'Two' declared as parameter to type 'One'}}
     }
 }
 
+enum HomeworkError: Error {
+case dogAteIt
+case forgot
+}
+
 func testOne() {
   do {
   } catch let error { // expected-warning{{'catch' block is unreachable because no errors are thrown in 'do' block}}
     if case One.E.SomeError = error {} // expected-error{{generic parameter 'Two' could not be inferred}}
   }
+  do {
+  } catch HomeworkError.forgot { // expected-warning{{'catch' block is unreachable because no errors are thrown in 'do' block}}
+  } catch {
+  }
 }
 
 // https://github.com/apple/swift/issues/50875

test/IDE/complete_exception.swift

@@ -147,14 +147,14 @@ func test006() {
   } catch {
     #^INSIDE_CATCH1^#
   }
-// IMPLICIT_ERROR: Decl[LocalVar]/Local:  error[#Never#]; name=error
+// IMPLICIT_ERROR: Decl[LocalVar]/Local:  error[#any Error#]; name=error
 }
 func test007() {
   do {
   } catch let e {
     #^INSIDE_CATCH2^#
   }
-// EXPLICIT_ERROR_E: Decl[LocalVar]/Local: e[#Never#]; name=e
+// EXPLICIT_ERROR_E: Decl[LocalVar]/Local: e[#any Error#]; name=e
 }
 func test008() {
   do {
@@ -195,7 +195,7 @@ func test012() {
     error.#^INSIDE_CATCH_ERR_DOT1^#
   }
 }
-// ERROR_DOT: Keyword[self]/CurrNominal: self[#Never#]; name=self
+// ERROR_DOT: Keyword[self]/CurrNominal: self[#any Error#]; name=self
 func test013() {
   do {
   } catch let e {

test/Parse/errors.swift

@@ -19,14 +19,12 @@ func one() {
   do {
 
   } catch { // expected-warning {{'catch' block is unreachable because no errors are thrown in 'do' block}}
-    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}}
+    let error2 = error
   }
 
   do {
   } catch where true { // expected-warning {{'catch' block is unreachable because no errors are thrown in 'do' block}}
-    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}}
+    let error2 = error
   } catch {
   }
 

test/stmt/typed_throws.swift

@@ -139,6 +139,17 @@ func testTryIncompatibleTyped(cond: Bool) throws(HomeworkError) {
   }
 }
 
+func doSomethingWithoutThrowing() { }
+
+func testDoCatchWithoutThrowing() {
+  do {
+    try doSomethingWithoutThrowing() // expected-warning{{no calls to throwing functions occur within 'try' expression}}
+  } catch HomeworkError.forgot { // expected-warning{{'catch' block is unreachable because no errors are thrown in 'do' block}}
+    // expected-error@-1{{pattern of type 'HomeworkError' cannot match 'Never'}}
+  } catch {
+  }
+}
+
 // "Rethrow-like" functions are only allowed to be called from rethrows
 // functions as a compatibility hack, which is removed under FullTypedThrows.
 func rethrowsLike<E>(_ body: () throws(E) -> Void) throws(E) { }