Implicitly build "missing" conformances to Sendable.

When looking up a conformance to Sendable fails, implicitly create a
"missing" builtin conformance. Such conformances allow type checking
to continue even in the presence of Sendable-related problems.

Diagnose these missing conformances when they are used in an actual
program, as part of availability checking for conformances and when we
are determining Sendability. This allows us to decide between an
error, a warning, and suppressing the diagnostic entirely without
affecting how the program is compiled. This is a step toward enabling
selective enforcement of Sendable.

Part of rdar://78269348.

Author: DougGregor

include/swift/AST/ASTContext.h

@@ -106,6 +106,7 @@ namespace swift {
   class InheritedProtocolConformance;
   class SelfProtocolConformance;
   class SpecializedProtocolConformance;
+  enum class BuiltinConformanceKind;
   class BuiltinProtocolConformance;
   enum class ProtocolConformanceState;
   class Pattern;
@@ -1046,7 +1047,8 @@ class ASTContext final {
   BuiltinProtocolConformance *
   getBuiltinConformance(Type type, ProtocolDecl *protocol,
                         GenericSignature genericSig,
-                        ArrayRef<Requirement> conditionalRequirements);
+                        ArrayRef<Requirement> conditionalRequirements,
+                        BuiltinConformanceKind kind);
 
   /// A callback used to produce a diagnostic for an ill-formed protocol
   /// conformance that was type-checked before we're actually walking the

include/swift/AST/DiagnosticsSema.def

@@ -4516,6 +4516,11 @@ ERROR(concurrent_value_inherit,none,
       "`Sendable` class %1 cannot inherit from another class"
       "%select{| other than 'NSObject'}0",
       (bool, DeclName))
+ERROR(non_sendable_type,none,
+      "type %0 does not conform to the 'Sendable' protocol", (Type))
+ERROR(non_sendable_function_type,none,
+     "function type %0 must be marked '@Sendable' to conform to 'Sendable'",
+      (Type))
 
 WARNING(unchecked_conformance_not_special,none,
       "@unchecked conformance to %0 has no meaning", (Type))

include/swift/AST/ProtocolConformance.h

@@ -993,6 +993,15 @@ class InheritedProtocolConformance : public ProtocolConformance,
   }
 };
 
+/// Describes the kind of a builtin conformance.
+enum class BuiltinConformanceKind {
+  // A builtin conformance that has been synthesized by the implementation.
+  Synthesized = 0,
+  // A missing conformance that we have nonetheless synthesized so that
+  // we can diagnose it later.
+  Missing,
+};
+
 /// A builtin conformance appears when a non-nominal type has a
 /// conformance that is synthesized by the implementation.
 class BuiltinProtocolConformance final : public RootProtocolConformance,
@@ -1002,15 +1011,17 @@ class BuiltinProtocolConformance final : public RootProtocolConformance,
 
   ProtocolDecl *protocol;
   GenericSignature genericSig;
-  size_t numConditionalRequirements;
+  size_t numConditionalRequirements : 31;
+  unsigned builtinConformanceKind : 1;
 
   size_t numTrailingObjects(OverloadToken<Requirement>) const {
     return numConditionalRequirements;
   }
 
   BuiltinProtocolConformance(Type conformingType, ProtocolDecl *protocol,
                              GenericSignature genericSig,
-                             ArrayRef<Requirement> conditionalRequirements);
+                             ArrayRef<Requirement> conditionalRequirements,
+                             BuiltinConformanceKind kind);
 
 public:
   /// Get the protocol being conformed to.
@@ -1024,6 +1035,16 @@ class BuiltinProtocolConformance final : public RootProtocolConformance,
     return genericSig;
   }
 
+  BuiltinConformanceKind getBuiltinConformanceKind() const {
+    return static_cast<BuiltinConformanceKind>(builtinConformanceKind);
+  }
+
+  /// Whether this represents a "missing" conformance that should be diagnosed
+  /// later.
+  bool isMissing() const {
+    return getBuiltinConformanceKind() == BuiltinConformanceKind::Missing;
+  }
+
   /// Get any requirements that must be satisfied for this conformance to apply.
   Optional<ArrayRef<Requirement>>
   getConditionalRequirementsIfAvailable() const {

lib/AST/ASTContext.cpp

@@ -2331,7 +2331,8 @@ BuiltinProtocolConformance *
 ASTContext::getBuiltinConformance(
     Type type, ProtocolDecl *protocol,
     GenericSignature genericSig,
-    ArrayRef<Requirement> conditionalRequirements
+    ArrayRef<Requirement> conditionalRequirements,
+    BuiltinConformanceKind kind
 ) {
   auto key = std::make_pair(type, protocol);
   AllocationArena arena = getArena(type->getRecursiveProperties());
@@ -2343,7 +2344,7 @@ ASTContext::getBuiltinConformance(
         totalSizeToAlloc<Requirement>(conditionalRequirements.size());
     auto mem = this->Allocate(size, alignof(BuiltinProtocolConformance), arena);
     entry = new (mem) BuiltinProtocolConformance(
-        type, protocol, genericSig, conditionalRequirements);
+        type, protocol, genericSig, conditionalRequirements, kind);
   }
   return entry;
 }

lib/AST/Module.cpp

@@ -989,10 +989,29 @@ ProtocolConformanceRef ModuleDecl::lookupConformance(Type type,
       getASTContext().evaluator, request, ProtocolConformanceRef::forInvalid());
 }
 
+/// 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
+  // (and even code generation) can continue.
+  ASTContext &ctx = proto->getASTContext();
+  if (proto->isSpecificProtocol(KnownProtocolKind::Sendable) &&
+      ctx.LangOpts.WarnConcurrency) {
+    return ProtocolConformanceRef(
+        ctx.getBuiltinConformance(
+          type, proto, GenericSignature(), { },
+          BuiltinConformanceKind::Missing));
+  }
+
+  return ProtocolConformanceRef::forInvalid();
+}
+
 /// Synthesize a builtin tuple type conformance to the given protocol, if
 /// appropriate.
 static ProtocolConformanceRef getBuiltinTupleTypeConformance(
-    Type type, const TupleType *tupleType, ProtocolDecl *protocol) {
+    Type type, const TupleType *tupleType, ProtocolDecl *protocol,
+    ModuleDecl *module) {
   // Tuple type are Sendable when all of their element types are Sendable.
   if (protocol->isSpecificProtocol(KnownProtocolKind::Sendable)) {
     ASTContext &ctx = protocol->getASTContext();
@@ -1016,26 +1035,38 @@ static ProtocolConformanceRef getBuiltinTupleTypeConformance(
     // If there were no generic parameters, just form the builtin conformance.
     if (genericParams.empty()) {
       return ProtocolConformanceRef(
-          ctx.getBuiltinConformance(type, protocol, GenericSignature(), { }));
+          ctx.getBuiltinConformance(type, protocol, GenericSignature(), { },
+                                    BuiltinConformanceKind::Synthesized));
     }
 
     // Form a generic conformance of (T1, T2, ..., TN): Sendable with signature
     // <T1, T2, ..., TN> and conditional requirements T1: Sendable,
     // T2: Sendable, ..., TN: Sendable.
     auto genericTupleType = TupleType::get(genericElements, ctx);
-    auto genericSig = GenericSignature::get(genericParams, { });
+    auto genericSig = GenericSignature::get(
+        genericParams, conditionalRequirements);
     auto genericConformance = ctx.getBuiltinConformance(
-        genericTupleType, protocol, genericSig, conditionalRequirements);
+        genericTupleType, protocol, genericSig, conditionalRequirements,
+        BuiltinConformanceKind::Synthesized);
 
     // Compute the substitution map from the generic parameters of the
     // generic conformance to actual types that were in the tuple type.
     // Form a specialized conformance from that.
-    auto subMap = SubstitutionMap::get(genericSig, typeSubstitutions, { });
+    auto subMap = SubstitutionMap::get(
+        genericSig, [&](SubstitutableType *type) {
+          if (auto gp = dyn_cast<GenericTypeParamType>(type)) {
+            if (gp->getDepth() == 0)
+              return typeSubstitutions[gp->getIndex()];
+          }
+
+          return Type(type);
+        },
+        LookUpConformanceInModule(module));
     return ProtocolConformanceRef(
         ctx.getSpecializedConformance(type, genericConformance, subMap));
   }
 
-  return ProtocolConformanceRef::forInvalid();
+  return getInvalidOrMissingConformance(type, protocol);
 }
 
 /// Whether the given function type conforms to Sendable.
@@ -1064,10 +1095,11 @@ static ProtocolConformanceRef getBuiltinFunctionTypeConformance(
       isSendableFunctionType(functionType)) {
     ASTContext &ctx = protocol->getASTContext();
     return ProtocolConformanceRef(
-        ctx.getBuiltinConformance(type, protocol, GenericSignature(), { }));
+        ctx.getBuiltinConformance(type, protocol, GenericSignature(), { },
+                                  BuiltinConformanceKind::Synthesized));
   }
 
-  return ProtocolConformanceRef::forInvalid();
+  return getInvalidOrMissingConformance(type, protocol);
 }
 
 /// Synthesize a builtin metatype type conformance to the given protocol, if
@@ -1078,10 +1110,11 @@ static ProtocolConformanceRef getBuiltinMetaTypeTypeConformance(
   if (protocol->isSpecificProtocol(KnownProtocolKind::Sendable)) {
     ASTContext &ctx = protocol->getASTContext();
     return ProtocolConformanceRef(
-        ctx.getBuiltinConformance(type, protocol, GenericSignature(), { }));
+        ctx.getBuiltinConformance(type, protocol, GenericSignature(), { },
+                                  BuiltinConformanceKind::Synthesized));
   }
 
-  return ProtocolConformanceRef::forInvalid();
+  return getInvalidOrMissingConformance(type, protocol);
 }
 
 /// Synthesize a builtin type conformance to the given protocol, if
@@ -1092,10 +1125,11 @@ static ProtocolConformanceRef getBuiltinBuiltinTypeConformance(
   if (protocol->isSpecificProtocol(KnownProtocolKind::Sendable)) {
     ASTContext &ctx = protocol->getASTContext();
     return ProtocolConformanceRef(
-        ctx.getBuiltinConformance(type, protocol, GenericSignature(), { }));
+        ctx.getBuiltinConformance(type, protocol, GenericSignature(), { },
+                                  BuiltinConformanceKind::Synthesized));
   }
 
-  return ProtocolConformanceRef::forInvalid();
+  return getInvalidOrMissingConformance(type, protocol);
 }
 
 ProtocolConformanceRef
@@ -1133,14 +1167,18 @@ LookupConformanceInModuleRequest::evaluate(
         return ProtocolConformanceRef(protocol);
     }
 
-    return ProtocolConformanceRef::forInvalid();
+    return getInvalidOrMissingConformance(type, protocol);
   }
 
   // An existential conforms to a protocol if the protocol is listed in the
   // existential's list of conformances and the existential conforms to
   // itself.
-  if (type->isExistentialType())
-    return mod->lookupExistentialConformance(type, protocol);
+  if (type->isExistentialType()) {
+    auto result = mod->lookupExistentialConformance(type, protocol);
+    if (result.isInvalid())
+      return getInvalidOrMissingConformance(type, protocol);
+    return result;
+  }
 
   // Type variables have trivial conformances.
   if (type->isTypeVariableOrMember())
@@ -1154,7 +1192,7 @@ LookupConformanceInModuleRequest::evaluate(
 
   // Tuple types can conform to protocols.
   if (auto tupleType = type->getAs<TupleType>()) {
-    return getBuiltinTupleTypeConformance(type, tupleType, protocol);
+    return getBuiltinTupleTypeConformance(type, tupleType, protocol, mod);
   }
 
   // Function types can conform to protocols.
@@ -1176,13 +1214,13 @@ LookupConformanceInModuleRequest::evaluate(
 
   // If we don't have a nominal type, there are no conformances.
   if (!nominal || isa<ProtocolDecl>(nominal))
-    return ProtocolConformanceRef::forInvalid();
+    return getInvalidOrMissingConformance(type, protocol);
 
   // Find the (unspecialized) conformance.
   SmallVector<ProtocolConformance *, 2> conformances;
   if (!nominal->lookupConformance(mod, protocol, conformances)) {
     if (!protocol->isSpecificProtocol(KnownProtocolKind::Sendable))
-      return ProtocolConformanceRef::forInvalid();
+      return getInvalidOrMissingConformance(type, protocol);
 
     // Try to infer Sendable conformance.
     GetImplicitSendableRequest cvRequest{nominal};
@@ -1191,7 +1229,7 @@ LookupConformanceInModuleRequest::evaluate(
       conformances.clear();
       conformances.push_back(conformance);
     } else {
-      return ProtocolConformanceRef::forInvalid();
+      return getInvalidOrMissingConformance(type, protocol);
     }
   }
 

lib/AST/ProtocolConformance.cpp

@@ -1591,10 +1591,13 @@ ProtocolConformanceRef::getCanonicalConformanceRef() const {
 BuiltinProtocolConformance::BuiltinProtocolConformance(
     Type conformingType, ProtocolDecl *protocol,
     GenericSignature genericSig,
-    ArrayRef<Requirement> conditionalRequirements
+    ArrayRef<Requirement> conditionalRequirements,
+    BuiltinConformanceKind kind
 ) : RootProtocolConformance(ProtocolConformanceKind::Builtin, conformingType),
     protocol(protocol), genericSig(genericSig),
-    numConditionalRequirements(conditionalRequirements.size()) {
+    numConditionalRequirements(conditionalRequirements.size()),
+    builtinConformanceKind(static_cast<unsigned>(kind))
+{
   std::uninitialized_copy(conditionalRequirements.begin(),
                           conditionalRequirements.end(),
                           getTrailingObjects<Requirement>());

lib/Sema/TypeCheckAvailability.cpp

@@ -15,6 +15,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "TypeCheckAvailability.h"
+#include "TypeCheckConcurrency.h"
 #include "TypeChecker.h"
 #include "TypeCheckObjC.h"
 #include "MiscDiagnostics.h"
@@ -3478,6 +3479,12 @@ void swift::diagnoseTypeAvailability(const TypeRepr *TR, Type T, SourceLoc loc,
   diagnoseTypeAvailability(T, loc, where, flags);
 }
 
+static void diagnoseMissingConformance(
+    SourceLoc loc, Type type, ProtocolDecl *proto) {
+  assert(proto->isSpecificProtocol(KnownProtocolKind::Sendable));
+  diagnoseMissingSendableConformance(loc, type);
+}
+
 bool
 swift::diagnoseConformanceAvailability(SourceLoc loc,
                                        ProtocolConformanceRef conformance,
@@ -3491,6 +3498,15 @@ swift::diagnoseConformanceAvailability(SourceLoc loc,
   const ProtocolConformance *concreteConf = conformance.getConcrete();
   const RootProtocolConformance *rootConf = concreteConf->getRootConformance();
 
+  // Diagnose "missing" conformances where we needed a conformance but
+  // didn't have one.
+  if (auto builtinConformance = dyn_cast<BuiltinProtocolConformance>(rootConf)){
+    if (builtinConformance->isMissing()) {
+      diagnoseMissingConformance(loc, builtinConformance->getType(),
+                                 builtinConformance->getProtocol());
+    }
+  }
+
   auto *DC = where.getDeclContext();
 
   auto maybeEmitAssociatedTypeNote = [&]() {

lib/Sema/TypeCheckConcurrency.cpp

@@ -546,13 +546,44 @@ 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);
   if (!proto)
     return true;
 
-  return !TypeChecker::conformsToProtocol(type, proto, module).isInvalid();
+  auto conformance = TypeChecker::conformsToProtocol(type, proto, module);
+  if (conformance.isInvalid())
+    return false;
+
+  // Look for missing Sendable conformances.
+  return !hasMissingSendableConformance(module, conformance);
 }
 
 static bool diagnoseNonConcurrentParameter(
@@ -653,6 +684,17 @@ bool swift::diagnoseNonConcurrentTypesInReference(
   return false;
 }
 
+void swift::diagnoseMissingSendableConformance(SourceLoc loc, Type type) {
+  ASTContext &ctx = type->getASTContext();
+  if (type->is<FunctionType>()) {
+    ctx.Diags.diagnose(loc, diag::non_sendable_function_type, type)
+      .warnUntilSwiftVersion(6);
+  } else {
+    ctx.Diags.diagnose(loc, diag::non_sendable_type, type)
+      .warnUntilSwiftVersion(6);
+  }
+}
+
 /// Determine whether this is the main actor type.
 /// FIXME: the diagnostics engine has a copy of this.
 static bool isMainActor(Type type) {