Revert "[Typed throws] Support overrides that are contravariant in the thrown error"

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -3366,9 +3366,6 @@ ERROR(override_class_declaration_in_extension,none,
 ERROR(override_with_more_effects,none,
       "cannot override non-%1 %0 with %1 %0",
       (DescriptiveDeclKind, StringRef))
-ERROR(override_typed_throws,none,
-      "%0 that throws %1 cannot override one that throws %2",
-      (DescriptiveDeclKind, Type, Type))
 ERROR(override_throws_objc,none,
       "overriding a throwing @objc %select{method|initializer}0 with "
       "a non-throwing %select{method|initializer}0 is not supported", (bool))

include/swift/AST/ExtInfo.h

@@ -544,7 +544,7 @@ class ASTExtInfoBuilder {
     return bits == other.bits &&
       (useClangTypes ? (clangTypeInfo == other.clangTypeInfo) : true) &&
       globalActor.getPointer() == other.globalActor.getPointer() &&
-      thrownError.getPointer() == other.thrownError.getPointer();
+      thrownError.getPointer() == thrownError.getPointer();
   }
 
   constexpr std::tuple<unsigned, const void *, const void *, const void *>

lib/AST/Type.cpp

@@ -3421,8 +3421,7 @@ static bool matchesFunctionType(CanAnyFunctionType fn1, CanAnyFunctionType fn2,
   if (matchMode.contains(TypeMatchFlags::AllowOverride)) {
     // Removing 'throwing' is ABI-compatible for synchronous functions, but
     // not for async ones.
-    if (ext2.isThrowing() && !ext1.isThrowing() &&
-        ext2.getThrownError().isNull() &&
+    if (ext2.isThrowing() &&
         !(ext2.isAsync() &&
           matchMode.contains(TypeMatchFlags::AllowABICompatible))) {
       ext1 = ext1.withThrows(true, ext2.getThrownError());

lib/Sema/TypeCheckDeclOverride.cpp

@@ -17,7 +17,6 @@
 #include "TypeCheckAvailability.h"
 #include "TypeCheckConcurrency.h"
 #include "TypeCheckDecl.h"
-#include "TypeCheckEffects.h"
 #include "TypeCheckObjC.h"
 #include "TypeChecker.h"
 #include "swift/AST/ASTVisitor.h"
@@ -2037,54 +2036,16 @@ static bool checkSingleOverride(ValueDecl *override, ValueDecl *base) {
       diags.diagnose(base, diag::overridden_here);
     }
   }
-
-  // Check effects.
+  // If the overriding declaration is 'throws' but the base is not,
+  // complain. Do the same for 'async'
   if (auto overrideFn = dyn_cast<AbstractFunctionDecl>(override)) {
-    // Determine the thrown errors in the base and override declarations.
-    auto baseFn = cast<AbstractFunctionDecl>(base);
-    Type overrideThrownError =
-        overrideFn->getEffectiveThrownErrorType().value_or(ctx.getNeverType());
-    Type baseThrownError =
-        baseFn->getEffectiveThrownErrorType().value_or(ctx.getNeverType());
-
-    if (baseThrownError && baseThrownError->hasTypeParameter()) {
-      auto subs = SubstitutionMap::getOverrideSubstitutions(base, override);
-      baseThrownError = baseThrownError.subst(subs);
-      baseThrownError = overrideFn->mapTypeIntoContext(baseThrownError);
-    }
-
-    if (overrideThrownError)
-      overrideThrownError = overrideFn->mapTypeIntoContext(overrideThrownError);
-
-    // Check for a subtyping relationship.
-    switch (compareThrownErrorsForSubtyping(
-                overrideThrownError, baseThrownError, overrideFn)) {
-    case ThrownErrorSubtyping::DropsThrows:
+    if (overrideFn->hasThrows() &&
+        !cast<AbstractFunctionDecl>(base)->hasThrows()) {
       diags.diagnose(override, diag::override_with_more_effects,
                      override->getDescriptiveKind(), "throwing");
       diags.diagnose(base, diag::overridden_here);
-      break;
-
-    case ThrownErrorSubtyping::Mismatch:
-      diags.diagnose(override, diag::override_typed_throws,
-                     override->getDescriptiveKind(), overrideThrownError,
-                     baseThrownError);
-      diags.diagnose(base, diag::overridden_here);
-      break;
-
-    case ThrownErrorSubtyping::ExactMatch:
-    case ThrownErrorSubtyping::Subtype:
-      // Proper subtyping.
-      break;
-
-    case ThrownErrorSubtyping::Dependent:
-      // Only in already ill-formed code.
-      assert(ctx.Diags.hadAnyError());
-      break;
     }
 
-    // If the override is 'async' but the base declaration is not, we have a
-    // problem.
     if (overrideFn->hasAsync() &&
         !cast<AbstractFunctionDecl>(base)->hasAsync()) {
       diags.diagnose(override, diag::override_with_more_effects,

lib/Sema/TypeCheckEffects.cpp

@@ -3595,13 +3595,6 @@ ThrownErrorSubtyping
 swift::compareThrownErrorsForSubtyping(
     Type subThrownError, Type superThrownError, DeclContext *dc
 ) {
-  // Deal with NULL errors. This should only occur when there is no standard
-  // library.
-  if (!subThrownError || !superThrownError) {
-    assert(!dc->getASTContext().getStdlibModule() && "NULL thrown error type");
-    return ThrownErrorSubtyping::ExactMatch;
-  }
-
   // Easy case: exact match.
   if (superThrownError->isEqual(subThrownError))
     return ThrownErrorSubtyping::ExactMatch;

stdlib/public/core/CMakeLists.txt

@@ -298,7 +298,7 @@ endif()
 # STAGING: Temporarily avoids having to write #fileID in Swift.swiftinterface.
 list(APPEND swift_stdlib_compile_flags "-Xfrontend" "-enable-experimental-concise-pound-file")
 
-list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "TypedThrows")
+list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "Macros")
 list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "FreestandingMacros")
 list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "Extern")
 

stdlib/public/core/Collection.swift

@@ -1190,10 +1190,9 @@ extension Collection {
   /// - Returns: An array containing the transformed elements of this
   ///   sequence.
   @inlinable
-  @_alwaysEmitIntoClient
-  public func map<T, E>(
-    _ transform: (Element) throws(E) -> T
-  ) throws(E) -> [T] {
+  public func map<T>(
+    _ transform: (Element) throws -> T
+  ) rethrows -> [T] {
     // TODO: swift-3-indexing-model - review the following
     let n = self.count
     if n == 0 {
@@ -1214,17 +1213,6 @@ extension Collection {
     return Array(result)
   }
 
-  // ABI-only entrypoint for the rethrows version of map, which has been
-  // superseded by the typed-throws version. Expressed as "throws", which is
-  // ABI-compatible with "rethrows".
-  @usableFromInline
-  @_silgen_name("$sSlsE3mapySayqd__Gqd__7ElementQzKXEKlF")
-  func __rethrows_map<T>(
-    _ transform: (Element) throws -> T
-  ) throws -> [T] {
-    try map(transform)
-  }
-
   /// Returns a subsequence containing all but the given number of initial
   /// elements.
   ///

stdlib/public/core/ExistentialCollection.swift

@@ -175,7 +175,7 @@ internal class _AnySequenceBox<Element> {
   @inlinable
   internal func _map<T>(
     _ transform: (Element) throws -> T
-  ) throws -> [T] {
+  ) rethrows -> [T] {
     _abstract()
   }
 
@@ -525,8 +525,8 @@ internal final class _SequenceBox<S: Sequence>: _AnySequenceBox<S.Element> {
   @inlinable
   internal override func _map<T>(
     _ transform: (Element) throws -> T
-  ) throws -> [T] {
-    try _base.map(transform)
+  ) rethrows -> [T] {
+    return try _base.map(transform)
   }
   @inlinable
   internal override func _filter(
@@ -618,8 +618,8 @@ internal final class _CollectionBox<S: Collection>: _AnyCollectionBox<S.Element>
   @inlinable
   internal override func _map<T>(
     _ transform: (Element) throws -> T
-  ) throws -> [T] {
-    try _base.map(transform)
+  ) rethrows -> [T] {
+    return try _base.map(transform)
   }
   @inlinable
   internal override func _filter(
@@ -813,8 +813,8 @@ internal final class _BidirectionalCollectionBox<S: BidirectionalCollection>
   @inlinable
   internal override func _map<T>(
     _ transform: (Element) throws -> T
-  ) throws -> [T] {
-    try _base.map(transform)
+  ) rethrows -> [T] {
+    return try _base.map(transform)
   }
   @inlinable
   internal override func _filter(
@@ -1026,8 +1026,8 @@ internal final class _RandomAccessCollectionBox<S: RandomAccessCollection>
   @inlinable
   internal override func _map<T>(
     _ transform: (Element) throws -> T
-  ) throws -> [T] {
-    try _base.map(transform)
+  ) rethrows -> [T] {
+    return try _base.map(transform)
   }
   @inlinable
   internal override func _filter(
@@ -1303,26 +1303,10 @@ extension AnySequence {
   }
 
   @inlinable
-  @_alwaysEmitIntoClient
-  public func map<T, E>(
-    _ transform: (Element) throws(E) -> T
-  ) throws(E) -> [T] {
-    do {
-      return try _box._map(transform)
-    } catch {
-      throw error as! E
-    }
-  }
-
-  // ABI-only entrypoint for the rethrows version of map, which has been
-  // superseded by the typed-throws version. Expressed as "throws", which is
-  // ABI-compatible with "rethrows".
-  @usableFromInline
-  @_silgen_name("$ss11AnySequenceV3mapySayqd__Gqd__xKXEKlF")
-  func __rethrows_map<T>(
+  public func map<T>(
     _ transform: (Element) throws -> T
-  ) throws -> [T] {
-    try map(transform)
+  ) rethrows -> [T] {
+    return try _box._map(transform)
   }
 
   @inlinable
@@ -1406,26 +1390,10 @@ extension AnyCollection {
   }
 
   @inlinable
-  @_alwaysEmitIntoClient
-  public func map<T, E>(
-    _ transform: (Element) throws(E) -> T
-  ) throws(E) -> [T] {
-    do {
-      return try _box._map(transform)
-    } catch {
-      throw error as! E
-    }
-  }
-
-  // ABI-only entrypoint for the rethrows version of map, which has been
-  // superseded by the typed-throws version. Expressed as "throws", which is
-  // ABI-compatible with "rethrows".
-  @usableFromInline
-  @_silgen_name("$ss13AnyCollectionV3mapySayqd__Gqd__xKXEKlF")
-  func __rethrows_map<T>(
+  public func map<T>(
     _ transform: (Element) throws -> T
-  ) throws -> [T] {
-    try map(transform)
+  ) rethrows -> [T] {
+    return try _box._map(transform)
   }
 
   @inlinable
@@ -1515,26 +1483,10 @@ extension AnyBidirectionalCollection {
   }
 
   @inlinable
-  @_alwaysEmitIntoClient
-  public func map<T, E>(
-    _ transform: (Element) throws(E) -> T
-  ) throws(E) -> [T] {
-    do {
-      return try _box._map(transform)
-    } catch {
-      throw error as! E
-    }
-  }
-
-  // ABI-only entrypoint for the rethrows version of map, which has been
-  // superseded by the typed-throws version. Expressed as "throws", which is
-  // ABI-compatible with "rethrows".
-  @usableFromInline
-  @_silgen_name("$ss26AnyBidirectionalCollectionV3mapySayqd__Gqd__xKXEKlF")
-  func __rethrows_map<T>(
+  public func map<T>(
     _ transform: (Element) throws -> T
-  ) throws -> [T] {
-    try map(transform)
+  ) rethrows -> [T] {
+    return try _box._map(transform)
   }
 
   @inlinable
@@ -1626,26 +1578,10 @@ extension AnyRandomAccessCollection {
   }
 
   @inlinable
-  @_alwaysEmitIntoClient
-  public func map<T, E>(
-    _ transform: (Element) throws(E) -> T
-  ) throws(E) -> [T] {
-    do {
-      return try _box._map(transform)
-    } catch {
-      throw error as! E
-    }
-  }
-
-  // ABI-only entrypoint for the rethrows version of map, which has been
-  // superseded by the typed-throws version. Expressed as "throws", which is
-  // ABI-compatible with "rethrows".
-  @usableFromInline
-  @_silgen_name("$ss25AnyRandomAccessCollectionV3mapySayqd__Gqd__xKXEKlF")
-  func __rethrows_map<T>(
+  public func map<T>(
     _ transform: (Element) throws -> T
-  ) throws -> [T] {
-    try map(transform)
+  ) rethrows -> [T] {
+    return try _box._map(transform)
   }
 
   @inlinable

stdlib/public/core/Misc.swift

@@ -159,17 +159,6 @@ public func _unsafePerformance<T>(_ c: () -> T) -> T {
   return c()
 }
 
-// Helper function that exploits a bug in rethrows checking to
-// allow us to call rethrows functions from generic typed-throws functions
-// and vice-versa.
-@usableFromInline
-@_alwaysEmitIntoClient
-@inline(__always)
-func _rethrowsViaClosure(_ fn: () throws -> ()) rethrows {
-  try fn()
-}
-
-
 /// This marker protocol represents types that support copying.
 /// This type is not yet available for use to express explicit
 /// constraints on generics in your programs. It is currently

stdlib/public/core/Sequence.swift

@@ -670,10 +670,9 @@ extension Sequence {
   ///
   /// - Complexity: O(*n*), where *n* is the length of the sequence.
   @inlinable
-  @_alwaysEmitIntoClient
-  public func map<T, E>(
-    _ transform: (Element) throws(E) -> T
-  ) throws(E) -> [T] {
+  public func map<T>(
+    _ transform: (Element) throws -> T
+  ) rethrows -> [T] {
     let initialCapacity = underestimatedCount
     var result = ContiguousArray<T>()
     result.reserveCapacity(initialCapacity)
@@ -691,17 +690,6 @@ extension Sequence {
     return Array(result)
   }
 
-  // ABI-only entrypoint for the rethrows version of map, which has been
-  // superseded by the typed-throws version. Expressed as "throws", which is
-  // ABI-compatible with "rethrows".
-  @usableFromInline
-  @_silgen_name("$sSTsE3mapySayqd__Gqd__7ElementQzKXEKlF")
-  func __rethrows_map<T>(
-    _ transform: (Element) throws -> T
-  ) throws -> [T] {
-    try map(transform)
-  }
-
   /// Returns an array containing, in order, the elements of the sequence
   /// that satisfy the given predicate.
   ///