Merge pull request #38691 from DougGregor/missing-sendable-conformances

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/Decl.h

@@ -3251,7 +3251,8 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   ///
   /// This is used by deserialization of module files to report
   /// conformances.
-  void registerProtocolConformance(ProtocolConformance *conformance);
+  void registerProtocolConformance(ProtocolConformance *conformance,
+                                   bool synthesized = false);
 
   void setConformanceLoader(LazyMemberLoader *resolver, uint64_t contextData);
 

include/swift/AST/DiagnosticsSema.def

@@ -4518,6 +4518,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/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/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 {

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/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/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,14 +991,41 @@ 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 when appropriate, so that type checking
+  // (and even code generation) can continue.
+  ASTContext &ctx = proto->getASTContext();
+  if (shouldCreateMissingConformances(proto)) {
+    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 +1049,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 +1109,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 +1124,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 +1139,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 +1181,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 +1206,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 +1228,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 +1243,7 @@ LookupConformanceInModuleRequest::evaluate(
       conformances.clear();
       conformances.push_back(conformance);
     } else {
-      return ProtocolConformanceRef::forInvalid();
+      return getInvalidOrMissingConformance(type, protocol);
     }
   }