[Requirement machine] Ignore unavailable conformances on superclass constraints.

When determining whether a superclass conforms to a particular protocol,
skip unavailable conformances. This way, we don't minimize away a
constraint that might only apply to subclasses of the specified
superclass.

Fixes rdar://91853658.

Author: DougGregor

include/swift/AST/Module.h

@@ -631,11 +631,18 @@ class ModuleDecl
   /// might include "missing" conformances, which are synthesized for some
   /// protocols as an error recovery mechanism.
   ///
+  /// \param allowUnavailable When \c true, the resulting conformance reference
+  /// might include "unavailable" conformances, meaning that the conformance
+  /// cannot actually be used and will be diagnosed if used later. Pass
+  /// \c false here for queries that want to determine whether the conformance
+  /// is likely to be usable.
+  ///
   /// \returns The result of the conformance search, which will be
   /// None if the type does not conform to the protocol or contain a
   /// ProtocolConformanceRef if it does conform.
   ProtocolConformanceRef lookupConformance(Type type, ProtocolDecl *protocol,
-                                           bool allowMissing = false);
+                                           bool allowMissing = false,
+                                           bool allowUnavailable = true);
 
   /// Look for the conformance of the given existential type to the given
   /// protocol.

include/swift/AST/ProtocolConformanceRef.h

@@ -106,6 +106,10 @@ class ProtocolConformanceRef {
     return Union.get<ProtocolDecl*>();
   }
 
+  /// Determine whether this conformance (or a conformance it depends on)
+  /// involves an always-unavailable conformance.
+  bool hasUnavailableConformance() const;
+
   /// Determine whether this conformance (or a conformance it depends on)
   /// involves a "missing" conformance anywhere. Such conformances
   /// cannot be depended on to always exist.

lib/AST/Module.cpp

@@ -1015,7 +1015,9 @@ ModuleDecl::lookupExistentialConformance(Type type, ProtocolDecl *protocol) {
   // If the existential is class-constrained, the class might conform
   // concretely.
   if (auto superclass = layout.explicitSuperclass) {
-    if (auto result = lookupConformance(superclass, protocol))
+    if (auto result = lookupConformance(
+            superclass, protocol, /*allowMissing=*/false,
+            /*allowUnavailable=*/false))
       return result;
   }
 
@@ -1071,7 +1073,8 @@ ProtocolConformanceRef ProtocolConformanceRef::forMissingOrInvalid(
 
 ProtocolConformanceRef ModuleDecl::lookupConformance(Type type,
                                                      ProtocolDecl *protocol,
-                                                     bool allowMissing) {
+                                                     bool allowMissing,
+                                                     bool allowUnavailable) {
   // If we are recursively checking for implicit conformance of a nominal
   // type to Sendable, fail without evaluating this request. This
   // squashes cycles.
@@ -1088,13 +1091,18 @@ ProtocolConformanceRef ModuleDecl::lookupConformance(Type type,
   auto result = evaluateOrDefault(
       getASTContext().evaluator, request, ProtocolConformanceRef::forInvalid());
 
-  // If we aren't supposed to allow missing conformances through for this
-  // protocol, replace the result with an "invalid" result.
+  // If we aren't supposed to allow missing conformances but we have one,
+  // replace the result with an "invalid" result.
   if (!allowMissing &&
       shouldCreateMissingConformances(type, protocol) &&
       result.hasMissingConformance(this))
     return ProtocolConformanceRef::forInvalid();
 
+  // If we aren't supposed to allow unavailable conformances but we have one,
+  // replace the result with an "invalid" result.
+  if (!allowUnavailable && result.hasUnavailableConformance())
+    return ProtocolConformanceRef::forInvalid();
+
   return result;
 }
 
@@ -1248,7 +1256,9 @@ LookupConformanceInModuleRequest::evaluate(
     // able to be resolved by a substitution that makes the archetype
     // concrete.
     if (auto super = archetype->getSuperclass()) {
-      if (auto inheritedConformance = mod->lookupConformance(super, protocol)) {
+      if (auto inheritedConformance = mod->lookupConformance(
+              super, protocol, /*allowMissing=*/false,
+              /*allowUnavailable=*/false)) {
         return ProtocolConformanceRef(ctx.getInheritedConformance(
             type, inheritedConformance.getConcrete()));
       }

lib/AST/ProtocolConformance.cpp

@@ -1743,6 +1743,28 @@ SourceLoc swift::extractNearestSourceLoc(const ProtocolConformanceRef conformanc
   return SourceLoc();
 }
 
+bool ProtocolConformanceRef::hasUnavailableConformance() const {
+  // Abstract conformances are never unavailable.
+  if (!isConcrete())
+    return false;
+
+  // Check whether this conformance is on an unavailable extension.
+  auto concrete = getConcrete();
+  auto ext = dyn_cast<ExtensionDecl>(concrete->getDeclContext());
+  if (ext && AvailableAttr::isUnavailable(ext))
+    return true;
+
+  // Check the conformances in the substitution map.
+  auto module = concrete->getDeclContext()->getParentModule();
+  auto subMap = concrete->getSubstitutions(module);
+  for (auto subConformance : subMap.getConformances()) {
+    if (subConformance.hasUnavailableConformance())
+      return true;
+  }
+
+  return false;
+}
+
 bool ProtocolConformanceRef::hasMissingConformance(ModuleDecl *module) const {
   return forEachMissingConformance(module,
       [](BuiltinProtocolConformance *builtin) {

lib/AST/RequirementMachine/ConcreteContraction.cpp

@@ -275,8 +275,10 @@ Optional<Type> ConcreteContraction::substTypeParameterRec(
       // 'allowMissing' value here is actually irrelevant.
       auto conformance = ((*substBaseType)->isTypeParameter()
                           ? ProtocolConformanceRef(proto)
-                          : module->lookupConformance(*substBaseType, proto,
-                                                      /*allowMissing=*/false));
+                          : module->lookupConformance(
+                              *substBaseType, proto,
+                              /*allowMissing=*/false,
+                              /*allowUnavailable=*/false));
 
       // The base type doesn't conform, in which case the requirement remains
       // unsubstituted.
@@ -391,7 +393,7 @@ ConcreteContraction::substRequirement(const Requirement &req) const {
 
     if (!substFirstType->isTypeParameter() &&
         !module->lookupConformance(substFirstType, proto,
-                                   allowMissing)) {
+                                   allowMissing, /*allowUnavailable=*/false)) {
       // Handle the case of <T where T : P, T : C> where C is a class and
       // C does not conform to P by leaving the conformance requirement
       // unsubstituted.

lib/AST/RequirementMachine/ConcreteTypeWitness.cpp

@@ -156,7 +156,7 @@ void PropertyMap::concretizeNestedTypesFromConcreteParent(
     auto conformance = module->lookupConformance(concreteType,
                                                  const_cast<ProtocolDecl *>(proto),
                                                  allowMissing);
-    if (conformance.isInvalid()) {
+    if (conformance.isInvalid() || conformance.hasUnavailableConformance()) {
       // For superclass rules, it is totally fine to have a signature like:
       //
       // protocol P {}

lib/Sema/TypeCheckConcurrency.cpp

@@ -593,29 +593,6 @@ static void addSendableFixIt(const GenericTypeParamDecl *genericArgument,
   }
 }
 
-/// Determine whether there is an unavailable conformance here.
-static bool hasUnavailableConformance(ProtocolConformanceRef conformance) {
-  // Abstract conformances are never unavailable.
-  if (!conformance.isConcrete())
-    return false;
-
-  // Check whether this conformance is on an unavailable extension.
-  auto concrete = conformance.getConcrete();
-  auto ext = dyn_cast<ExtensionDecl>(concrete->getDeclContext());
-  if (ext && AvailableAttr::isUnavailable(ext))
-    return true;
-
-  // Check the conformances in the substitution map.
-  auto module = concrete->getDeclContext()->getParentModule();
-  auto subMap = concrete->getSubstitutions(module);
-  for (auto subConformance : subMap.getConformances()) {
-    if (hasUnavailableConformance(subConformance))
-      return true;
-  }
-
-  return false;
-}
-
 static bool shouldDiagnoseExistingDataRaces(const DeclContext *dc) {
   return contextRequiresStrictConcurrencyChecking(dc, [](const AbstractClosureExpr *) {
     return Type();
@@ -913,7 +890,7 @@ bool swift::diagnoseNonSendableTypes(
 
   // FIXME: More detail for unavailable conformances.
   auto conformance = TypeChecker::conformsToProtocol(type, proto, module);
-  if (conformance.isInvalid() || hasUnavailableConformance(conformance)) {
+  if (conformance.isInvalid() || conformance.hasUnavailableConformance()) {
     return diagnoseSingleNonSendableType(type, fromContext, loc, diagnose);
   }
 
@@ -1062,7 +1039,7 @@ namespace {
           return true;
 
         // If there is an unavailable conformance here, fail.
-        if (hasUnavailableConformance(conformance))
+        if (conformance.hasUnavailableConformance())
           return true;
 
         // Look for missing Sendable conformances.

lib/Sema/TypeCheckProtocol.cpp

@@ -3389,7 +3389,8 @@ void ConformanceChecker::recordTypeWitness(AssociatedTypeDecl *assocType,
     auto overriddenConformance =
       DC->getParentModule()->lookupConformance(Adoptee,
                                                overridden->getProtocol(),
-                                               /*allowMissing=*/true);
+                                               /*allowMissing=*/true,
+                                               /*allowUnavailable=*/false);
     if (overriddenConformance.isInvalid() ||
         !overriddenConformance.isConcrete())
       continue;

test/ClangImporter/objc_async.swift

@@ -374,3 +374,10 @@ func testSender(
   sender.sendPtr(ptr)
   sender.sendStringArray(stringArray)
 }
+
+// Sendable checking
+public struct SomeWrapper<T: AuditedNonSendable> {
+  public let unit: T
+}
+
+extension SomeWrapper: Sendable where T: Sendable {}

test/Concurrency/sendable_checking.swift

@@ -95,3 +95,12 @@ func f() async {
     n.pointee += 1
   }
 }
+
+// Make sure the generic signature doesn't minimize away Sendable requirements.
+@_nonSendable class NSClass { }
+
+struct WrapClass<T: NSClass> {
+  var t: T
+}
+
+extension WrapClass: Sendable where T: Sendable { }

test/Generics/superclass_constraint.swift

@@ -221,3 +221,14 @@ public struct Barn<T: Teddy> {
   // CHECK: Generic signature: <T, S where T : Teddy>
   public func foo<S>(_: S, _: Barn<T>, _: Paddock<T>) {}
 }
+
+
+public class Animal { }
+
+@available(*, unavailable, message: "Not a pony")
+extension Animal: Pony { }
+
+public struct AnimalWrapper<Friend: Animal> { }
+
+// CHECK: Generic signature: <Friend where Friend : Animal, Friend : Pony>
+extension AnimalWrapper: Pony where Friend: Pony { }

test/decl/protocol/req/recursion.swift

@@ -73,7 +73,7 @@ protocol PI {
 }
 
 struct SI<A: PI> : I where A : I, A.T == SI<A> {
-// expected-error@-1 3{{generic struct 'SI' has self-referential generic requirements}}
+// expected-error@-1 5{{generic struct 'SI' has self-referential generic requirements}}
   func ggg<T : I>(t: T.Type) -> T {
     return T()
   }
@@ -104,5 +104,5 @@ struct SU<A: P> where A.T == SU {
 }
 
 struct SIU<A: PI> : I where A : I, A.T == SIU {
-// expected-error@-1 3{{generic struct 'SIU' has self-referential generic requirements}}
+// expected-error@-1 5{{generic struct 'SIU' has self-referential generic requirements}}
 }