Parameterize conformance lookup on whether "missing" conformances are allowed.

Many clients of the conformance lookup operations would prefer to get
an invalid conformance (== there is no conformance) rather than a
missing conformance. Parameterize the conformance lookup operations so
that most callers won't see missing conformances, by filtering them
out at the end. Opt-in those callers that do want to see missing
conformances so they can be diagnosed.

Author: DougGregor

include/swift/AST/GenericSignature.h

@@ -373,7 +373,8 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// T: Foo or T == U (etc.) with the information it knows. This includes
   /// checking against global state, if any/all of the types in the requirement
   /// are concrete, not type parameters.
-  bool isRequirementSatisfied(Requirement requirement) const;
+  bool isRequirementSatisfied(
+      Requirement requirement, bool allowMissing = false) const;
 
   /// Return the requirements of this generic signature that are not also
   /// satisfied by \c otherSig.

include/swift/AST/Module.h

@@ -578,10 +578,15 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   ///
   /// \param protocol The protocol to which we are computing conformance.
   ///
+  /// \param allowMissing When \c true, the resulting conformance reference
+  /// might include "missing" conformances, which are synthesized for some
+  /// protocols as an error recovery mechanism.
+  ///
   /// \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);
+  ProtocolConformanceRef lookupConformance(Type type, ProtocolDecl *protocol,
+                                           bool allowMissing = false);
 
   /// Look for the conformance of the given existential type to the given
   /// protocol.

include/swift/AST/ProtocolConformanceRef.h

@@ -98,6 +98,11 @@ class ProtocolConformanceRef {
     return Union.get<ProtocolDecl*>();
   }
 
+  /// Determine whether this conformance (or a conformance it depends on)
+  /// involves a "missing" conformance anywhere. Such conformances
+  /// cannot be depended on to always exist.
+  bool hasMissingConformance(ModuleDecl *module) const;
+
   using OpaqueValue = void*;
   OpaqueValue getOpaqueValue() const { return Union.getOpaqueValue(); }
   static ProtocolConformanceRef getFromOpaqueValue(OpaqueValue value) {

include/swift/AST/Requirement.h

@@ -81,7 +81,8 @@ class Requirement
   /// \param conditionalRequirements An out parameter initialized to an
   /// array of requirements that the caller must check to ensure this
   /// requirement is completely satisfied.
-  bool isSatisfied(ArrayRef<Requirement> &conditionalRequirements) const;
+  bool isSatisfied(ArrayRef<Requirement> &conditionalRequirements,
+                   bool allowMissing = false) const;
 
   /// Determines if this substituted requirement can ever be satisfied,
   /// possibly with additional substitutions.

lib/AST/GenericSignature.cpp

@@ -937,7 +937,7 @@ bool GenericSignatureImpl::areSameTypeParameterInContext(Type type1,
 }
 
 bool GenericSignatureImpl::isRequirementSatisfied(
-    Requirement requirement) const {
+    Requirement requirement, bool allowMissing) const {
   if (requirement.getFirstType()->hasTypeParameter()) {
     auto *genericEnv = getGenericEnvironment();
 
@@ -959,7 +959,7 @@ bool GenericSignatureImpl::isRequirementSatisfied(
   // FIXME: Need to check conditional requirements here.
   ArrayRef<Requirement> conditionalRequirements;
 
-  return requirement.isSatisfied(conditionalRequirements);
+  return requirement.isSatisfied(conditionalRequirements, allowMissing);
 }
 
 SmallVector<Requirement, 4> GenericSignatureImpl::requirementsNotSatisfiedBy(
@@ -1391,12 +1391,14 @@ ProtocolDecl *Requirement::getProtocolDecl() const {
 }
 
 bool
-Requirement::isSatisfied(ArrayRef<Requirement> &conditionalRequirements) const {
+Requirement::isSatisfied(ArrayRef<Requirement> &conditionalRequirements,
+                         bool allowMissing) const {
   switch (getKind()) {
   case RequirementKind::Conformance: {
     auto *proto = getProtocolDecl();
     auto *module = proto->getParentModule();
-    auto conformance = module->lookupConformance(getFirstType(), proto);
+    auto conformance = module->lookupConformance(
+        getFirstType(), proto, allowMissing);
     if (!conformance)
       return false;
 

lib/AST/Module.cpp

@@ -970,8 +970,14 @@ ModuleDecl::lookupExistentialConformance(Type type, ProtocolDecl *protocol) {
   return ProtocolConformanceRef::forInvalid();
 }
 
+/// Whether we should create missing conformances to the given protocol.
+static bool shouldCreateMissingConformances(ProtocolDecl *proto) {
+  return proto->isSpecificProtocol(KnownProtocolKind::Sendable);
+}
+
 ProtocolConformanceRef ModuleDecl::lookupConformance(Type type,
-                                                     ProtocolDecl *protocol) {
+                                                     ProtocolDecl *protocol,
+                                                     bool allowMissing) {
   // If we are recursively checking for implicit conformance of a nominal
   // type to Sendable, fail without evaluating this request. This
   // squashes cycles.
@@ -985,18 +991,27 @@ ProtocolConformanceRef ModuleDecl::lookupConformance(Type type,
     }
   }
 
-  return evaluateOrDefault(
+  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 (!allowMissing &&
+      shouldCreateMissingConformances(protocol) &&
+      result.hasMissingConformance(this))
+    return ProtocolConformanceRef::forInvalid();
+
+  return result;
 }
 
 /// Retrieve an invalid or missing conformance, as appropriate, when a
 /// legitimate conformance doesn't exist.
 static ProtocolConformanceRef getInvalidOrMissingConformance(
     Type type, ProtocolDecl *proto) {
-  // Introduce "missing" conformances to Sendable, so that type checking
+  // Introduce "missing" conformances when appropriate, so that type checking
   // (and even code generation) can continue.
   ASTContext &ctx = proto->getASTContext();
-  if (proto->isSpecificProtocol(KnownProtocolKind::Sendable)) {
+  if (shouldCreateMissingConformances(proto)) {
     return ProtocolConformanceRef(
         ctx.getBuiltinConformance(
           type, proto, GenericSignature(), { },

lib/AST/ProtocolConformance.cpp

@@ -1664,3 +1664,27 @@ SourceLoc swift::extractNearestSourceLoc(const ProtocolConformanceRef conformanc
   }
   return SourceLoc();
 }
+
+bool ProtocolConformanceRef::hasMissingConformance(ModuleDecl *module) const {
+  if (!isConcrete())
+    return false;
+
+  // Is this a missing Sendable conformance?
+  const ProtocolConformance *concreteConf = getConcrete();
+  const RootProtocolConformance *rootConf = concreteConf->getRootConformance();
+  if (auto builtinConformance = dyn_cast<BuiltinProtocolConformance>(rootConf)){
+    if (builtinConformance->isMissing() && builtinConformance->getProtocol()->isSpecificProtocol(
+            KnownProtocolKind::Sendable)) {
+      return true;
+    }
+  }
+
+  // Check conformances that are part of this conformance.
+  auto subMap = concreteConf->getSubstitutions(module);
+  for (auto conformance : subMap.getConformances()) {
+    if (conformance.hasMissingConformance(module))
+      return true;
+  }
+
+  return false;
+}

lib/AST/Type.cpp

@@ -3772,7 +3772,8 @@ operator()(CanType dependentType, Type conformingReplacementType,
     return ProtocolConformanceRef(conformedProtocol);
 
   return M->lookupConformance(conformingReplacementType,
-                              conformedProtocol);
+                              conformedProtocol,
+                              /*allowMissing=*/true);
 }
 
 ProtocolConformanceRef LookUpConformanceInSubstitutionMap::

lib/Sema/CSSimplify.cpp

@@ -6225,7 +6225,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
   case ConstraintKind::LiteralConformsTo: {
     // Check whether this type conforms to the protocol.
     auto conformance = DC->getParentModule()->lookupConformance(
-        type, protocol);
+        type, protocol, /*allowMissing=*/true);
     if (conformance) {
       return recordConformance(conformance);
     }

lib/Sema/TypeCheckConcurrency.cpp

@@ -546,32 +546,6 @@ static bool isSendableClosure(
   return false;
 }
 
-/// Look for missing Sendable conformances
-static bool hasMissingSendableConformance(
-    ModuleDecl *module, ProtocolConformanceRef conformance) {
-  if (!conformance.isConcrete())
-    return false;
-
-  // Is this a missing Sendable conformance?
-  const ProtocolConformance *concreteConf = conformance.getConcrete();
-  const RootProtocolConformance *rootConf = concreteConf->getRootConformance();
-  if (auto builtinConformance = dyn_cast<BuiltinProtocolConformance>(rootConf)){
-    if (builtinConformance->isMissing() && builtinConformance->getProtocol()->isSpecificProtocol(
-            KnownProtocolKind::Sendable)) {
-      return true;
-    }
-  }
-
-  // Check conformances that are part of this conformance.
-  auto subMap = concreteConf->getSubstitutions(module);
-  for (auto conformance : subMap.getConformances()) {
-    if (hasMissingSendableConformance(module, conformance))
-      return true;
-  }
-
-  return false;
-}
-
 /// Determine whether the given type is suitable as a concurrent value type.
 bool swift::isSendableType(ModuleDecl *module, Type type) {
   auto proto = module->getASTContext().getProtocol(KnownProtocolKind::Sendable);
@@ -583,7 +557,7 @@ bool swift::isSendableType(ModuleDecl *module, Type type) {
     return false;
 
   // Look for missing Sendable conformances.
-  return !hasMissingSendableConformance(module, conformance);
+  return !conformance.hasMissingConformance(module);
 }
 
 static bool diagnoseNonConcurrentParameter(