[SE-0304] Rename ConcurrentValue to Sendable

Author: DougGregor

include/swift/AST/DeclContext.h

@@ -160,7 +160,7 @@ enum class ConformanceLookupKind : unsigned {
   /// All conformances except for inherited ones.
   NonInherited,
   /// All conformances except structurally-derived conformances, of which
-  /// ConcurrentValue is the only one.
+  /// Sendable is the only one.
   NonStructural,
 };
 

include/swift/AST/DiagnosticsSema.def

@@ -4421,20 +4421,20 @@ WARNING(non_concurrent_keypath_access,none,
         (Type))
 ERROR(non_concurrent_type_member,none,
       "%select{stored property %1|associated value %1}0 of "
-      "'ConcurrentValue'-conforming %2 %3 has non-concurrent-value type %4",
+      "'Sendable'-conforming %2 %3 has non-concurrent-value type %4",
       (bool, DeclName, DescriptiveDeclKind, DeclName, Type))
 ERROR(concurrent_value_class_mutable_property,none,
-      "stored property %0 of 'ConcurrentValue'-conforming %1 %2 is mutable",
+      "stored property %0 of 'Sendable'-conforming %1 %2 is mutable",
       (DeclName, DescriptiveDeclKind, DeclName))
 ERROR(concurrent_value_outside_source_file,none,
-      "conformance to 'ConcurrentValue' must occur in the same source file as "
-      "%0 %1; use 'UnsafeConcurrentValue' for retroactive conformance",
+      "conformance to 'Sendable' must occur in the same source file as "
+      "%0 %1; use 'UnsafeSendable' for retroactive conformance",
       (DescriptiveDeclKind, DeclName))
 ERROR(concurrent_value_nonfinal_class,none,
-      "non-final class %0 cannot conform to `ConcurrentValue`; "
-      "use `UnsafeConcurrentValue`", (DeclName))
+      "non-final class %0 cannot conform to `Sendable`; "
+      "use `UnsafeSendable`", (DeclName))
 ERROR(concurrent_value_inherit,none,
-      "`ConcurrentValue` class %1 cannot inherit from another class"
+      "`Sendable` class %1 cannot inherit from another class"
       "%select{| other than 'NSObject'}0",
       (bool, DeclName))
 

include/swift/AST/KnownProtocols.def

@@ -80,8 +80,8 @@ PROTOCOL(CodingKey)
 PROTOCOL(Encodable)
 PROTOCOL(Decodable)
 
-PROTOCOL(ConcurrentValue)
-PROTOCOL(UnsafeConcurrentValue)
+PROTOCOL(Sendable)
+PROTOCOL(UnsafeSendable)
 
 PROTOCOL_(ObjectiveCBridgeable)
 PROTOCOL_(DestructorSafeContainer)

include/swift/AST/TypeCheckRequests.h

@@ -2898,9 +2898,9 @@ class SynthesizeMainFunctionRequest
 };
 
 /// Retrieve the implicit conformance for the given nominal type to
-/// the ConcurrentValue protocol.
-class GetImplicitConcurrentValueRequest :
-    public SimpleRequest<GetImplicitConcurrentValueRequest,
+/// the Sendable protocol.
+class GetImplicitSendableRequest :
+    public SimpleRequest<GetImplicitSendableRequest,
                          NormalProtocolConformance *(NominalTypeDecl *),
                          RequestFlags::Cached> {
 public:

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -317,6 +317,6 @@ SWIFT_REQUEST(TypeChecker, SimpleDidSetRequest,
               bool(AccessorDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, SynthesizeMainFunctionRequest,
               FuncDecl *(Decl *), Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, GetImplicitConcurrentValueRequest,
+SWIFT_REQUEST(TypeChecker, GetImplicitSendableRequest,
               NormalProtocolConformance *(NominalTypeDecl *),
               Cached, NoLocationInfo)

include/swift/Basic/LangOptions.h

@@ -253,8 +253,8 @@ namespace swift {
     /// Enable experimental flow-sensitive concurrent captures.
     bool EnableExperimentalFlowSensitiveConcurrentCaptures = false;
 
-    /// Enable inference of ConcurrentValue conformances for public types.
-    bool EnableInferPublicConcurrentValue = false;
+    /// Enable inference of Sendable conformances for public types.
+    bool EnableInferPublicSendable = false;
 
     /// Enable experimental derivation of `Codable` for enums.
     bool EnableExperimentalEnumCodableDerivation = false;

include/swift/Option/FrontendOptions.td

@@ -194,10 +194,10 @@ def disable_copy_propagation : Flag<["-"], "disable-copy-propagation">,
   HelpText<"Don't run SIL copy propagation to preserve object lifetime.">;
 
 def enable_infer_public_concurrent_value : Flag<["-"], "enable-infer-public-concurrent-value">,
-    HelpText<"Enable inference of ConcurrentValue conformances for public structs and enums">;
+    HelpText<"Enable inference of Sendable conformances for public structs and enums">;
 
 def disable_infer_public_concurrent_value : Flag<["-"], "disable-infer-public-concurrent-value">,
-    HelpText<"Disable inference of ConcurrentValue conformances for public structs and enums">;
+    HelpText<"Disable inference of Sendable conformances for public structs and enums">;
 
 } // end let Flags = [FrontendOption, NoDriverOption]
 

lib/AST/Module.cpp

@@ -968,12 +968,12 @@ ModuleDecl::lookupExistentialConformance(Type type, ProtocolDecl *protocol) {
 ProtocolConformanceRef ModuleDecl::lookupConformance(Type type,
                                                      ProtocolDecl *protocol) {
   // If we are recursively checking for implicit conformance of a nominal
-  // type to ConcurrentValue, fail without evaluating this request. This
+  // type to Sendable, fail without evaluating this request. This
   // squashes cycles.
   LookupConformanceInModuleRequest request{{this, type, protocol}};
-  if (protocol->isSpecificProtocol(KnownProtocolKind::ConcurrentValue)) {
+  if (protocol->isSpecificProtocol(KnownProtocolKind::Sendable)) {
     if (auto nominal = type->getAnyNominal()) {
-      GetImplicitConcurrentValueRequest icvRequest{nominal};
+      GetImplicitSendableRequest icvRequest{nominal};
       if (getASTContext().evaluator.hasActiveRequest(icvRequest) ||
           getASTContext().evaluator.hasActiveRequest(request))
         return ProtocolConformanceRef::forInvalid();
@@ -1047,11 +1047,11 @@ LookupConformanceInModuleRequest::evaluate(
   // Find the (unspecialized) conformance.
   SmallVector<ProtocolConformance *, 2> conformances;
   if (!nominal->lookupConformance(mod, protocol, conformances)) {
-    if (!protocol->isSpecificProtocol(KnownProtocolKind::ConcurrentValue))
+    if (!protocol->isSpecificProtocol(KnownProtocolKind::Sendable))
       return ProtocolConformanceRef::forInvalid();
 
-    // Try to infer ConcurrentValue conformance.
-    GetImplicitConcurrentValueRequest cvRequest{nominal};
+    // Try to infer Sendable conformance.
+    GetImplicitSendableRequest cvRequest{nominal};
     if (auto conformance = evaluateOrDefault(
             ctx.evaluator, cvRequest, nullptr)) {
       conformances.clear();

lib/AST/ProtocolConformance.cpp

@@ -1326,9 +1326,9 @@ IterableDeclContext::getLocalProtocols(ConformanceLookupKind lookupKind) const {
   return result;
 }
 
-/// Find a synthesized ConcurrentValue conformance in this declaration context,
+/// Find a synthesized Sendable conformance in this declaration context,
 /// if there is one.
-static ProtocolConformance *findSynthesizedConcurrentValueConformance(
+static ProtocolConformance *findSynthesizedSendableConformance(
     const DeclContext *dc) {
   auto nominal = dc->getSelfNominalTypeDecl();
   if (!nominal)
@@ -1341,7 +1341,7 @@ static ProtocolConformance *findSynthesizedConcurrentValueConformance(
     return nullptr;
 
   auto cvProto = nominal->getASTContext().getProtocol(
-      KnownProtocolKind::ConcurrentValue);
+      KnownProtocolKind::Sendable);
   if (!cvProto)
     return nullptr;
 
@@ -1438,10 +1438,10 @@ IterableDeclContext::getLocalConformances(ConformanceLookupKind lookupKind)
   switch (lookupKind) {
     case ConformanceLookupKind::All:
     case ConformanceLookupKind::NonInherited: {
-      // Look for a ConcurrentValue conformance globally. If it is synthesized
+      // Look for a Sendable conformance globally. If it is synthesized
       // and matches this declaration context, use it.
       auto dc = getAsGenericContext();
-      if (auto conformance = findSynthesizedConcurrentValueConformance(dc))
+      if (auto conformance = findSynthesizedSendableConformance(dc))
         result.push_back(conformance);
       break;
     }

lib/Frontend/CompilerInvocation.cpp

@@ -385,7 +385,7 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
 
   Opts.EnableExperimentalConcurrency |=
     Args.hasArg(OPT_enable_experimental_concurrency);
-  Opts.EnableInferPublicConcurrentValue |=
+  Opts.EnableInferPublicSendable |=
     Args.hasFlag(OPT_enable_infer_public_concurrent_value,
                  OPT_disable_infer_public_concurrent_value,
                  false);