[TaskToThread] No unstructured tasks.

In this mode, the following are disabled:

- task creation
- global actors
- MainActor
- custom executors

Author: nate-chandler

include/swift/AST/DiagnosticsSema.def

@@ -6375,5 +6375,17 @@ NOTE(candidate_result_requires_explicit_coercion,none,
      "loss of generic requirements",
      (Type))
 
+ERROR(concurrency_task_to_thread_model_custom_executor,none,
+      "custom executors are not permitted within %0", (StringRef))
+ERROR(concurrency_task_to_thread_model_async_main,none,
+      "async main functions are not permitted within %0", (StringRef))
+ERROR(concurrency_task_to_thread_model_main_actor,none,
+      "MainActor is not permitted within %0", (StringRef))
+ERROR(concurrency_task_to_thread_model_global_actor,none,
+      "globalActor is not permitted within %0", (StringRef))
+ERROR(concurrency_task_to_thread_model_global_actor_annotation,none,
+      "annotating a type with a global actor %0 is not permitted within %1",
+      (TypeRepr*, StringRef))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

lib/Sema/TypeCheckAttr.cpp

@@ -2335,6 +2335,14 @@ SynthesizeMainFunctionRequest::evaluate(Evaluator &evaluator,
   auto where = ExportContext::forDeclSignature(D);
   diagnoseDeclAvailability(mainFunction, attr->getRange(), nullptr, where, None);
 
+  if (mainFunction->hasAsync() &&
+      context.LangOpts.isConcurrencyModelTaskToThread() &&
+      !AvailableAttr::isUnavailable(mainFunction)) {
+    mainFunction->diagnose(diag::concurrency_task_to_thread_model_async_main,
+                           "task-to-thread concurrency model");
+    return nullptr;
+  }
+
   auto *const func = FuncDecl::createImplicit(
       context, StaticSpellingKind::KeywordStatic,
       DeclName(context, DeclBaseName(context.Id_MainEntryPoint),
@@ -3307,6 +3315,15 @@ void AttributeChecker::visitFrozenAttr(FrozenAttr *attr) {
   }
 }
 
+/// Determine whether this is the main actor type.
+/// FIXME: the diagnostics engine and TypeCheckConcurrency both have a copy of
+///        this
+static bool isMainActor(NominalTypeDecl *nominal) {
+  return nominal->getName().is("MainActor") &&
+         nominal->getParentModule()->getName() ==
+             nominal->getASTContext().Id_Concurrency;
+}
+
 void AttributeChecker::visitCustomAttr(CustomAttr *attr) {
   auto dc = D->getDeclContext();
 
@@ -3342,6 +3359,14 @@ void AttributeChecker::visitCustomAttr(CustomAttr *attr) {
     return;
   }
 
+  if (isMainActor(nominal) && Ctx.LangOpts.isConcurrencyModelTaskToThread() &&
+      !AvailableAttr::isUnavailable(D)) {
+    Ctx.Diags.diagnose(attr->getLocation(),
+                       diag::concurrency_task_to_thread_model_main_actor,
+                       "task-to-thread concurrency model");
+    return;
+  }
+
   // If the nominal type is a property wrapper type, we can be delegating
   // through a property.
   if (nominal->getAttrs().hasAttribute<PropertyWrapperAttr>()) {
@@ -6025,6 +6050,15 @@ void AttributeChecker::visitGlobalActorAttr(GlobalActorAttr *attr) {
   if (!nominal)
     return; // already diagnosed
 
+  auto &context = nominal->getASTContext();
+  if (context.LangOpts.isConcurrencyModelTaskToThread() &&
+      !AvailableAttr::isUnavailable(nominal)) {
+    context.Diags.diagnose(attr->getLocation(),
+                           diag::concurrency_task_to_thread_model_global_actor,
+                           "task-to-thread concurrency model");
+    return;
+  }
+
   (void)nominal->isGlobalActor();
 }
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -188,9 +188,18 @@ bool IsDefaultActorRequest::evaluate(
   // If we synthesized the unownedExecutor property, we should've
   // added a semantics attribute to it (if it was actually a default
   // actor).
-  if (auto executorProperty = classDecl->getUnownedExecutorProperty())
-    return executorProperty->getAttrs()
-             .hasSemanticsAttr(SEMANTICS_DEFAULT_ACTOR);
+  if (auto executorProperty = classDecl->getUnownedExecutorProperty()) {
+    bool isDefaultActor =
+        executorProperty->getAttrs().hasSemanticsAttr(SEMANTICS_DEFAULT_ACTOR);
+    if (!isDefaultActor &&
+        classDecl->getASTContext().LangOpts.isConcurrencyModelTaskToThread() &&
+        !AvailableAttr::isUnavailable(classDecl)) {
+      classDecl->diagnose(
+          diag::concurrency_task_to_thread_model_custom_executor,
+          "task-to-thread concurrency model");
+    }
+    return isDefaultActor;
+  }
 
   return true;
 }

lib/Sema/TypeCheckType.cpp

@@ -2332,8 +2332,16 @@ TypeResolver::resolveAttributedType(TypeAttributes &attrs, TypeRepr *repr,
   // Diagnose custom attributes that haven't been processed yet.
   for (auto customAttr : attrs.getCustomAttrs()) {
     // If this was the global actor we matched, ignore it.
-    if (globalActorAttr == customAttr)
+    if (globalActorAttr == customAttr) {
+      Decl *decl = nullptr;
+      if (getASTContext().LangOpts.isConcurrencyModelTaskToThread() &&
+          (decl = getDeclContext()->getAsDecl()) &&
+          !AvailableAttr::isUnavailable(decl))
+        diagnose(customAttr->getLocation(),
+                 diag::concurrency_task_to_thread_model_global_actor_annotation,
+                 customAttr->getTypeRepr(), "task-to-thread concurrency model");
       continue;
+    }
 
     // If this attribute was marked invalid, ignore it.
     if (customAttr->isInvalid())

stdlib/public/Concurrency/MainActor.swift

@@ -12,6 +12,36 @@
 
 import Swift
 
+#if SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+@available(SwiftStdlib 5.1, *)
+@available(*, unavailable, message: "Unavailable in task-to-thread concurrency model")
+@globalActor public final actor MainActor: GlobalActor {
+  public static let shared = MainActor()
+
+  @inlinable
+  public nonisolated var unownedExecutor: UnownedSerialExecutor {
+    #if compiler(>=5.5) && $BuiltinBuildMainExecutor
+    return UnownedSerialExecutor(Builtin.buildMainActorExecutorRef())
+    #else
+    fatalError("Swift compiler is incompatible with this SDK version")
+    #endif
+  }
+
+  @inlinable
+  public static var sharedUnownedExecutor: UnownedSerialExecutor {
+    #if compiler(>=5.5) && $BuiltinBuildMainExecutor
+    return UnownedSerialExecutor(Builtin.buildMainActorExecutorRef())
+    #else
+    fatalError("Swift compiler is incompatible with this SDK version")
+    #endif
+  }
+
+  @inlinable
+  public nonisolated func enqueue(_ job: UnownedJob) {
+    _enqueueOnMain(job)
+  }
+}
+#else
 /// A singleton actor whose executor is equivalent to the main
 /// dispatch queue.
 @available(SwiftStdlib 5.1, *)
@@ -41,7 +71,9 @@ import Swift
     _enqueueOnMain(job)
   }
 }
+#endif
 
+#if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 @available(SwiftStdlib 5.1, *)
 extension MainActor {
   /// Execute the given body closure on the main actor.
@@ -66,3 +98,4 @@ extension MainActor {
     return try await body()
   }
 }
+#endif

stdlib/public/Concurrency/SourceCompatibilityShims.swift

@@ -75,6 +75,17 @@ extension Task where Success == Never, Failure == Never {
 
 @available(SwiftStdlib 5.1, *)
 extension Task where Failure == Error {
+#if SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+  @discardableResult
+  @_alwaysEmitIntoClient
+  @available(*, unavailable, message: "Unavailable in task-to-thread concurrency model")
+  public static func runDetached(
+    priority: TaskPriority? = nil,
+    operation: __owned @Sendable @escaping () async throws -> Success
+  ) -> Task<Success, Failure> {
+    fatalError("Unavailable in task-to-thread concurrency model")
+  }
+#else
   @discardableResult
   @_alwaysEmitIntoClient
   @available(*, deprecated, message: "`Task.runDetached` was replaced by `Task.detached` and will be removed shortly.")
@@ -84,8 +95,21 @@ extension Task where Failure == Error {
   ) -> Task<Success, Failure> {
     detached(priority: priority, operation: operation)
   }
+#endif
 }
 
+#if SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+@discardableResult
+@available(SwiftStdlib 5.1, *)
+@available(*, unavailable, message: "Unavailable in task-to-thread concurrency model")
+@_alwaysEmitIntoClient
+public func detach<T>(
+  priority: TaskPriority? = nil,
+  operation: __owned @Sendable @escaping () async -> T
+) -> Task<T, Never> {
+  fatalError("Unavailable in task-to-thread concurrency model")
+}
+#else
 @discardableResult
 @available(SwiftStdlib 5.1, *)
 @available(*, deprecated, message: "`detach` was replaced by `Task.detached` and will be removed shortly.")
@@ -96,7 +120,20 @@ public func detach<T>(
 ) -> Task<T, Never> {
   Task.detached(priority: priority, operation: operation)
 }
+#endif
 
+#if SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+@discardableResult
+@available(SwiftStdlib 5.1, *)
+@available(*, unavailable, message: "Unavailable in task-to-thread concurrency model")
+@_alwaysEmitIntoClient
+public func detach<T>(
+  priority: TaskPriority? = nil,
+  operation: __owned @Sendable @escaping () async throws -> T
+) -> Task<T, Error> {
+  fatalError("Unavailable in task-to-thread concurrency model")
+}
+#else
 @discardableResult
 @available(SwiftStdlib 5.1, *)
 @available(*, deprecated, message: "`detach` was replaced by `Task.detached` and will be removed shortly.")
@@ -107,7 +144,20 @@ public func detach<T>(
 ) -> Task<T, Error> {
   Task.detached(priority: priority, operation: operation)
 }
+#endif
 
+#if SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+@discardableResult
+@available(SwiftStdlib 5.1, *)
+@available(*, unavailable, message: "Unavailable in task-to-thread concurrency model")
+@_alwaysEmitIntoClient
+public func asyncDetached<T>(
+  priority: TaskPriority? = nil,
+  @_implicitSelfCapture operation: __owned @Sendable @escaping () async -> T
+) -> Task<T, Never> {
+  fatalError("Unavailable in task-to-thread concurrency model")
+}
+#else
 @discardableResult
 @available(SwiftStdlib 5.1, *)
 @available(*, deprecated, message: "`asyncDetached` was replaced by `Task.detached` and will be removed shortly.")
@@ -118,7 +168,20 @@ public func asyncDetached<T>(
 ) -> Task<T, Never> {
   return Task.detached(priority: priority, operation: operation)
 }
+#endif
 
+#if SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+@discardableResult
+@available(SwiftStdlib 5.1, *)
+@available(*, unavailable, message: "Unavailable in task-to-thread concurrency model")
+@_alwaysEmitIntoClient
+public func asyncDetached<T>(
+  priority: TaskPriority? = nil,
+  @_implicitSelfCapture operation: __owned @Sendable @escaping () async throws -> T
+) -> Task<T, Error> {
+  fatalError("Unavailable in task-to-thread concurrency model")
+}
+#else
 @discardableResult
 @available(SwiftStdlib 5.1, *)
 @available(*, deprecated, message: "`asyncDetached` was replaced by `Task.detached` and will be removed shortly.")
@@ -129,7 +192,20 @@ public func asyncDetached<T>(
 ) -> Task<T, Error> {
   return Task.detached(priority: priority, operation: operation)
 }
+#endif
 
+#if SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+@available(SwiftStdlib 5.1, *)
+@available(*, unavailable, message: "Unavailable in task-to-thread concurrency model")
+@discardableResult
+@_alwaysEmitIntoClient
+public func async<T>(
+  priority: TaskPriority? = nil,
+  @_inheritActorContext @_implicitSelfCapture operation: __owned @Sendable @escaping () async -> T
+) -> Task<T, Never> {
+  fatalError("Unavailable in task-to-thread concurrency model")
+}
+#else
 @available(SwiftStdlib 5.1, *)
 @available(*, deprecated, message: "`async` was replaced by `Task.init` and will be removed shortly.")
 @discardableResult
@@ -140,7 +216,20 @@ public func async<T>(
 ) -> Task<T, Never> {
   .init(priority: priority, operation: operation)
 }
+#endif
 
+#if SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+@available(SwiftStdlib 5.1, *)
+@available(*, unavailable, message: "Unavailable in task-to-thread concurrency model")
+@discardableResult
+@_alwaysEmitIntoClient
+public func async<T>(
+  priority: TaskPriority? = nil,
+  @_inheritActorContext @_implicitSelfCapture operation: __owned @Sendable @escaping () async throws -> T
+) -> Task<T, Error> {
+  fatalError("Unavailable in task-to-thread concurrency model")
+}
+#else
 @available(SwiftStdlib 5.1, *)
 @available(*, deprecated, message: "`async` was replaced by `Task.init` and will be removed shortly.")
 @discardableResult
@@ -151,6 +240,7 @@ public func async<T>(
 ) -> Task<T, Error> {
   .init(priority: priority, operation: operation)
 }
+#endif
 
 @available(SwiftStdlib 5.1, *)
 extension Task where Success == Never, Failure == Never {