Merge pull request #35264 from DougGregor/concurrent-value-protocol

[Concurrency] Introduce "ConcurrentValue" protocol and checking.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4305,6 +4305,32 @@ ERROR(global_actor_isolated_requirement_witness_conflict,none,
       "requirement from protocol %3 isolated to global actor %4",
       (DescriptiveDeclKind, DeclName, Type, Identifier, Type))
 
+WARNING(non_concurrent_param_type,none,
+        "cannot pass argument of non-concurrent-value type %0 across actors",
+        (Type))
+WARNING(non_concurrent_result_type,none,
+        "cannot call function returning non-concurrent-value type %0 across "
+        "actors", (Type))
+WARNING(non_concurrent_property_type,none,
+        "cannot use %0 %1 with a non-concurrent-value type %2 "
+        "%select{across actors|from concurrently-executed code}3",
+        (DescriptiveDeclKind, DeclName, Type, bool))
+WARNING(non_concurrent_function_type,none,
+        "`@concurrent` %select{function type|closure}0 has "
+        "non-concurrent-value %select{parameter|result}1 type %2",
+        (bool, bool, 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",
+      (bool, DeclName, DescriptiveDeclKind, DeclName, Type))
+ERROR(concurrent_value_class_mutable_property,none,
+      "stored property %0 of 'ConcurrentValue'-conforming %1 %2 is mutable",
+      (DeclName, DescriptiveDeclKind, DeclName))
+ERROR(concurrent_value_outside_source_file,none,
+      "conformance 'ConcurrentValue' must occur in the same source file as "
+      "%0 %1; use 'UnsafeConcurrentValue' for retroactive conformance",
+      (DescriptiveDeclKind, DeclName))
+
 ERROR(actorindependent_let,none,
       "'@actorIndependent' is meaningless on 'let' declarations because "
       "they are immutable",

include/swift/AST/KnownProtocols.def

@@ -80,6 +80,9 @@ PROTOCOL(CodingKey)
 PROTOCOL(Encodable)
 PROTOCOL(Decodable)
 
+PROTOCOL(ConcurrentValue)
+PROTOCOL(UnsafeConcurrentValue)
+
 PROTOCOL_(ObjectiveCBridgeable)
 PROTOCOL_(DestructorSafeContainer)
 

include/swift/Basic/LangOptions.h

@@ -244,6 +244,9 @@ namespace swift {
     /// Enable experimental concurrency model.
     bool EnableExperimentalConcurrency = false;
 
+    /// Enable experimental ConcurrentValue checking.
+    bool EnableExperimentalConcurrentValueChecking = false;
+
     /// Disable the implicit import of the _Concurrency module.
     bool DisableImplicitConcurrencyModuleImport = false;
 

include/swift/Option/FrontendOptions.td

@@ -221,7 +221,12 @@ let Flags = [FrontendOption, NoDriverOption, HelpHidden, ModuleInterfaceOption]
 def enable_experimental_concurrency :
   Flag<["-"], "enable-experimental-concurrency">,
   HelpText<"Enable experimental concurrency model">;
-  def enable_resilience : Flag<["-"], "enable-resilience">,
+
+def enable_experimental_concurrent_value_checking :
+  Flag<["-"], "enable-experimental-concurrent-value-checking">,
+  HelpText<"Enable ConcurrentValue checking">;
+
+def enable_resilience : Flag<["-"], "enable-resilience">,
      HelpText<"Deprecated, use -enable-library-evolution instead">;
 }
 

lib/Frontend/CompilerInvocation.cpp

@@ -385,6 +385,8 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
 
   Opts.EnableExperimentalConcurrency |=
     Args.hasArg(OPT_enable_experimental_concurrency);
+  Opts.EnableExperimentalConcurrentValueChecking |=
+    Args.hasArg(OPT_enable_experimental_concurrent_value_checking);
 
   Opts.DisableImplicitConcurrencyModuleImport |=
     Args.hasArg(OPT_disable_implicit_concurrency_module_import);

lib/IRGen/GenMeta.cpp

@@ -5138,6 +5138,8 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::Differentiable:
   case KnownProtocolKind::FloatingPoint:
   case KnownProtocolKind::Actor:
+  case KnownProtocolKind::ConcurrentValue:
+  case KnownProtocolKind::UnsafeConcurrentValue:
     return SpecialProtocol::None;
   }
 

lib/Sema/TypeCheckAttr.cpp

@@ -128,7 +128,6 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   IGNORED_ATTR(OriginallyDefinedIn)
   IGNORED_ATTR(NoDerivative)
   IGNORED_ATTR(SpecializeExtension)
-  IGNORED_ATTR(Concurrent)
 #undef IGNORED_ATTR
 
   void visitAlignmentAttr(AlignmentAttr *attr) {
@@ -420,6 +419,22 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
       }
     }
   }
+
+  void visitConcurrentAttr(ConcurrentAttr *attr) {
+    auto VD = dyn_cast<ValueDecl>(D);
+    if (!VD)
+      return;
+
+    auto innermostDC = VD->getInnermostDeclContext();
+    SubstitutionMap subs;
+    if (auto genericEnv = innermostDC->getGenericEnvironmentOfContext()) {
+      subs = genericEnv->getForwardingSubstitutionMap();
+    }
+
+    (void)diagnoseNonConcurrentTypesInReference(
+        ConcreteDeclRef(VD, subs), innermostDC, VD->getLoc(),
+        ConcurrentReferenceKind::ConcurrentFunction);
+  }
 };
 } // end anonymous namespace