Merge pull request #38866 from DougGregor/sendable-task-apis

Adopt Sendable in the Task APIs

Author: DougGregor

include/swift/AST/Decl.h

@@ -598,7 +598,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     HasAnyUnavailableValues : 1
   );
 
-  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1+1+1+1,
     /// If the module is compiled as static library.
     StaticLibrary : 1,
 
@@ -633,7 +633,11 @@ class alignas(1 << DeclAlignInBits) Decl {
     IsMainModule : 1,
 
     /// Whether this module has incremental dependency information available.
-    HasIncrementalInfo : 1
+    HasIncrementalInfo : 1,
+
+    /// Whether this module has been compiled with comprehensive checking for
+    /// concurrency, e.g., Sendable checking.
+    IsConcurrencyChecked : 1
   );
 
   SWIFT_INLINE_BITFIELD(PrecedenceGroupDecl, Decl, 1+2,

include/swift/AST/DiagnosticsSIL.def

@@ -445,7 +445,7 @@ NOTE(constexpr_witness_call_with_no_conformance, none,
     "%select{for this call|for a witness-method invoked during this call}0",
     (bool))
 
-NOTE(constexpr_unknown_control_flow_due_to_skip,none, "branch depends on "
+REMARK(constexpr_unknown_control_flow_due_to_skip,none, "branch depends on "
      "non-constant value produced by an unevaluated instructions", ())
 NOTE(constexpr_returned_by_unevaluated_instruction,none,
      "result of an unevaluated instruction is not a constant", ())

include/swift/AST/DiagnosticsSema.def

@@ -1939,6 +1939,12 @@ NOTE(nonsendable_function_type,none,
 NOTE(nonsendable_tuple_type,none,
      "a tuple type must be composed of 'Sendable' elements to conform to "
      "'Sendable'", ())
+NOTE(non_sendable_nominal,none,
+     "%0 %1 does not conform to the `Sendable` protocol",
+      (DescriptiveDeclKind, DeclName))
+NOTE(add_nominal_sendable_conformance,none,
+     "consider making %0 %1 conform to the 'Sendable' protocol",
+     (DescriptiveDeclKind, DeclName))
 
 NOTE(required_by_opaque_return,none,
     "required by opaque return type of %0 %1", (DescriptiveDeclKind, DeclName))
@@ -4492,20 +4498,20 @@ NOTE(protocol_isolated_to_global_actor_here,none,
 ERROR(isolated_parameter_not_actor,none,
       "'isolated' parameter has non-actor type %0", (Type))
 
-WARNING(non_concurrent_param_type,none,
+WARNING(non_sendable_param_type,none,
         "cannot pass argument of non-sendable type %0 across actors",
         (Type))
-WARNING(non_concurrent_result_type,none,
+WARNING(non_sendable_result_type,none,
         "cannot call function returning non-sendable type %0 across "
         "actors", (Type))
-WARNING(non_concurrent_property_type,none,
-        "cannot use %0 %1 with a non-sendable type %2 "
+WARNING(non_sendable_property_type,none,
+        "cannot use %1 %2 with a non-sendable type %0 "
         "%select{across actors|from concurrently-executed code}3",
-        (DescriptiveDeclKind, DeclName, Type, bool))
-WARNING(non_concurrent_keypath_capture,none,
+        (Type, DescriptiveDeclKind, DeclName, bool))
+WARNING(non_sendable_keypath_capture,none,
         "cannot form key path that captures non-sendable type %0",
         (Type))
-WARNING(non_concurrent_keypath_access,none,
+WARNING(non_sendable_keypath_access,none,
         "cannot form key path that accesses non-sendable type %0",
         (Type))
 ERROR(non_concurrent_type_member,none,
@@ -4528,9 +4534,6 @@ ERROR(concurrent_value_inherit,none,
       (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/Module.h

@@ -513,6 +513,16 @@ class ModuleDecl : public DeclContext, public TypeDecl {
     return Bits.ModuleDecl.IsMainModule;
   }
 
+  /// Whether this module has been compiled with comprehensive checking for
+  /// concurrency, e.g., Sendable checking.
+  bool isConcurrencyChecked() const {
+    return Bits.ModuleDecl.IsConcurrencyChecked;
+  }
+
+  void setIsConcurrencyChecked(bool value = true) {
+    Bits.ModuleDecl.IsConcurrencyChecked = value;
+  }
+
   /// For the main module, retrieves the list of primary source files being
   /// compiled, that is, the files we're generating code for.
   ArrayRef<SourceFile *> getPrimarySourceFiles() const;

include/swift/AST/ProtocolConformanceRef.h

@@ -19,6 +19,8 @@
 #include "swift/Basic/Debug.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/PointerUnion.h"
+#include "llvm/ADT/STLExtras.h"
+#include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/AST/Requirement.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/AST/Type.h"
@@ -29,6 +31,7 @@ namespace llvm {
 
 namespace swift {
 
+class BuiltinProtocolConformance;
 class ConcreteDeclRef;
 class ProtocolConformance;
 enum class EffectKind : uint8_t;
@@ -72,6 +75,11 @@ class ProtocolConformanceRef {
     return ProtocolConformanceRef();
   }
 
+  /// Retrieve an invalid or missing conformance, as appropriate, when a
+  /// legitimate conformance doesn't exist.
+  static ProtocolConformanceRef forMissingOrInvalid(
+      Type type, ProtocolDecl *proto);
+
   bool isInvalid() const {
     return !Union;
   }
@@ -103,6 +111,19 @@ class ProtocolConformanceRef {
   /// cannot be depended on to always exist.
   bool hasMissingConformance(ModuleDecl *module) const;
 
+  /// Enumerate the missing conformances in this conformance.
+  ///
+  /// Calls \c fn with each missing conformance found within this conformance,
+  /// including this conformance or any conditional conformances it depends on.
+  /// If the invocation of \c fn returns \c true, the traversal exits early
+  /// and the overall function returns \c true.
+  ///
+  /// \returns \c true if any invocation of \c fn returned true,
+  /// \c false otherwise.
+  bool forEachMissingConformance(
+      ModuleDecl *module,
+      llvm::function_ref<bool(BuiltinProtocolConformance *missing)> fn) const;
+
   using OpaqueValue = void*;
   OpaqueValue getOpaqueValue() const { return Union.getOpaqueValue(); }
   static ProtocolConformanceRef getFromOpaqueValue(OpaqueValue value) {

include/swift/Option/Options.td

@@ -659,7 +659,7 @@ def warn_swift3_objc_inference : Flag<["-"], "warn-swift3-objc-inference">,
   Flags<[FrontendOption, DoesNotAffectIncrementalBuild, HelpHidden]>;
 
 def warn_concurrency : Flag<["-"], "warn-concurrency">,
-  Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
+  Flags<[FrontendOption, DoesNotAffectIncrementalBuild, ModuleInterfaceOptionIgnorable]>,
   HelpText<"Warn about code that is unsafe according to the Swift Concurrency "
            "model and will become ill-formed in a future language version">;
 

include/swift/Serialization/Validation.h

@@ -103,6 +103,7 @@ class ExtendedValidationInfo {
     unsigned ResilienceStrategy : 2;
     unsigned IsImplicitDynamicEnabled : 1;
     unsigned IsAllowModuleWithCompilerErrorsEnabled : 1;
+    unsigned IsConcurrencyChecked : 1;
   } Bits;
 public:
   ExtendedValidationInfo() : Bits() {}
@@ -155,6 +156,13 @@ class ExtendedValidationInfo {
 
   StringRef getModuleABIName() const { return ModuleABIName; }
   void setModuleABIName(StringRef name) { ModuleABIName = name; }
+
+  bool isConcurrencyChecked() const {
+    return Bits.IsConcurrencyChecked;
+  }
+  void setIsConcurrencyChecked(bool val = true) {
+    Bits.IsConcurrencyChecked = val;
+  }
 };
 
 /// Returns info about the serialized AST in the given data.

lib/AST/GenericSignature.cpp

@@ -458,7 +458,7 @@ GenericSignatureImpl::lookupConformance(CanType type,
   if (type->isTypeParameter())
     return ProtocolConformanceRef(proto);
 
-  return M->lookupConformance(type, proto);
+  return M->lookupConformance(type, proto, /*allowMissing=*/true);
 }
 
 bool GenericSignatureImpl::requiresClass(Type type) const {

lib/AST/Module.cpp

@@ -489,6 +489,7 @@ ModuleDecl::ModuleDecl(Identifier name, ASTContext &ctx,
   Bits.ModuleDecl.IsNonSwiftModule = 0;
   Bits.ModuleDecl.IsMainModule = 0;
   Bits.ModuleDecl.HasIncrementalInfo = 0;
+  Bits.ModuleDecl.IsConcurrencyChecked = 0;
 }
 
 ImplicitImportList ModuleDecl::getImplicitImports() const {
@@ -978,6 +979,21 @@ static bool shouldCreateMissingConformances(ProtocolDecl *proto) {
   return proto->isSpecificProtocol(KnownProtocolKind::Sendable);
 }
 
+ProtocolConformanceRef ProtocolConformanceRef::forMissingOrInvalid(
+    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();
+}
+
 ProtocolConformanceRef ModuleDecl::lookupConformance(Type type,
                                                      ProtocolDecl *protocol,
                                                      bool allowMissing) {
@@ -1007,23 +1023,6 @@ ProtocolConformanceRef ModuleDecl::lookupConformance(Type type,
   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(
@@ -1083,7 +1082,7 @@ static ProtocolConformanceRef getBuiltinTupleTypeConformance(
         ctx.getSpecializedConformance(type, genericConformance, subMap));
   }
 
-  return getInvalidOrMissingConformance(type, protocol);
+  return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 }
 
 /// Whether the given function type conforms to Sendable.
@@ -1116,7 +1115,7 @@ static ProtocolConformanceRef getBuiltinFunctionTypeConformance(
                                   BuiltinConformanceKind::Synthesized));
   }
 
-  return getInvalidOrMissingConformance(type, protocol);
+  return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 }
 
 /// Synthesize a builtin metatype type conformance to the given protocol, if
@@ -1131,7 +1130,7 @@ static ProtocolConformanceRef getBuiltinMetaTypeTypeConformance(
                                   BuiltinConformanceKind::Synthesized));
   }
 
-  return getInvalidOrMissingConformance(type, protocol);
+  return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 }
 
 /// Synthesize a builtin type conformance to the given protocol, if
@@ -1146,7 +1145,7 @@ static ProtocolConformanceRef getBuiltinBuiltinTypeConformance(
                                   BuiltinConformanceKind::Synthesized));
   }
 
-  return getInvalidOrMissingConformance(type, protocol);
+  return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 }
 
 ProtocolConformanceRef
@@ -1184,7 +1183,7 @@ LookupConformanceInModuleRequest::evaluate(
         return ProtocolConformanceRef(protocol);
     }
 
-    return getInvalidOrMissingConformance(type, protocol);
+    return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
   }
 
   // An existential conforms to a protocol if the protocol is listed in the
@@ -1193,7 +1192,7 @@ LookupConformanceInModuleRequest::evaluate(
   if (type->isExistentialType()) {
     auto result = mod->lookupExistentialConformance(type, protocol);
     if (result.isInvalid())
-      return getInvalidOrMissingConformance(type, protocol);
+      return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
     return result;
   }
 
@@ -1231,13 +1230,13 @@ LookupConformanceInModuleRequest::evaluate(
 
   // If we don't have a nominal type, there are no conformances.
   if (!nominal || isa<ProtocolDecl>(nominal))
-    return getInvalidOrMissingConformance(type, protocol);
+    return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 
   // Find the (unspecialized) conformance.
   SmallVector<ProtocolConformance *, 2> conformances;
   if (!nominal->lookupConformance(protocol, conformances)) {
     if (!protocol->isSpecificProtocol(KnownProtocolKind::Sendable))
-      return getInvalidOrMissingConformance(type, protocol);
+      return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 
     // Try to infer Sendable conformance.
     GetImplicitSendableRequest cvRequest{nominal};
@@ -1246,7 +1245,7 @@ LookupConformanceInModuleRequest::evaluate(
       conformances.clear();
       conformances.push_back(conformance);
     } else {
-      return getInvalidOrMissingConformance(type, protocol);
+      return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
     }
   }
 

lib/AST/ProtocolConformance.cpp

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