[Concurrency] Address some review comments.

Tweaked diagnostic to use a string instead of a type.  Renamed the
feature in `FeatureAvailability.def` (and added the `TaskExecutor`
feature to 6.2).  Also fixed the `swift_getActiveExecutor()`
function to return the main executor only when on the main thread.

rdar://141348916

Author: al45tair

include/swift/AST/DiagnosticsSIL.def

@@ -1137,7 +1137,8 @@ NOTE(rbi_add_generic_parameter_sendable_conformance,none,
 ERROR(cannot_find_executor_factory_type, none,
       "the specified executor factory '%0' could not be found", (StringRef))
 ERROR(executor_factory_must_conform, none,
-      "the executor factory '%0' does not conform to 'ExecutorFactory'", (Type))
+      "the executor factory '%0' does not conform to 'ExecutorFactory'",
+      (StringRef))
 ERROR(executor_factory_not_supported, none,
       "deployment target too low for executor factory specification", ())
 

include/swift/AST/FeatureAvailability.def

@@ -80,9 +80,9 @@ FEATURE(IsolatedDeinit,                                 (6, 1))
 
 FEATURE(ValueGenericType,                               (6, 2))
 FEATURE(InitRawStructMetadata2,                         (6, 2))
-FEATURE(CustomExecutors,                                (6, 2))
+FEATURE(CustomGlobalExecutors,                          (6, 2))
+FEATURE(TaskExecutor,                                   (6, 2))
 
-FEATURE(TaskExecutor,                                   FUTURE)
 FEATURE(Differentiation,                                FUTURE)
 FEATURE(ClearSensitive,                                 FUTURE)
 FEATURE(UpdatePureObjCClassMetadata,                    FUTURE)

lib/SILGen/SILGen.cpp

@@ -511,7 +511,7 @@ FuncDecl *SILGenModule::getExit() {
   return exitFunction;
 }
 
-Type SILGenModule::getExecutorFactory() {
+Type SILGenModule::getConfiguredExecutorFactory() {
   auto &ctx = getASTContext();
 
   ModuleDecl *module;
@@ -545,12 +545,6 @@ Type SILGenModule::getDefaultExecutorFactory() {
   return ctx.getNamedSwiftType(module, "DefaultExecutorFactory");
 }
 
-ProtocolDecl *SILGenModule::getExecutorFactoryProtocol() {
-  auto &ctx = getASTContext();
-
-  return ctx.getProtocol(KnownProtocolKind::ExecutorFactory);
-}
-
 ProtocolConformance *SILGenModule::getNSErrorConformanceToError() {
   if (NSErrorConformanceToError)
     return *NSErrorConformanceToError;

lib/SILGen/SILGen.h

@@ -559,15 +559,12 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
   // Retrieve the _SwiftConcurrencyShims.exit intrinsic.
   FuncDecl *getExit();
 
-  /// Get the ExecutorFactory type.
-  Type getExecutorFactory();
+  /// Get the configured ExecutorFactory type.
+  Type getConfiguredExecutorFactory();
 
   /// Get the DefaultExecutorFactory type.
   Type getDefaultExecutorFactory();
 
-  /// Get the ExecutorFactory protocol.
-  ProtocolDecl *getExecutorFactoryProtocol();
-
   /// Get the swift_createExecutors function.
   FuncDecl *getCreateExecutors();
 

lib/SILGen/SILGenFunction.cpp

@@ -1400,8 +1400,8 @@ static bool isCreateExecutorsFunctionAvailable(SILGenModule &SGM) {
   if (!ctx.LangOpts.DisableAvailabilityChecking) {
     auto deploymentAvailability = AvailabilityRange::forDeploymentTarget(ctx);
     auto runtimeAvailability = AvailabilityRange::forRuntimeTarget(ctx);
-    auto declAvailability = ctx.getCustomExecutorsAvailability();
-    auto declRtAvailability = ctx.getCustomExecutorsRuntimeAvailability();
+    auto declAvailability = ctx.getCustomGlobalExecutorsAvailability();
+    auto declRtAvailability = ctx.getCustomGlobalExecutorsRuntimeAvailability();
     return deploymentAvailability.isContainedIn(declAvailability)
       && runtimeAvailability.isContainedIn(declRtAvailability);
   }
@@ -1429,21 +1429,23 @@ void SILGenFunction::emitAsyncMainThreadStart(SILDeclRef entryPoint) {
     if (!isCreateExecutorsFunctionAvailable(SGM)) {
       ctx.Diags.diagnose(SourceLoc(), diag::executor_factory_not_supported);
     } else {
-      CanType factoryTy = SGM.getExecutorFactory()->getCanonicalType();
+      CanType factoryTy = SGM.getConfiguredExecutorFactory()->getCanonicalType();
 
       if (!factoryTy) {
         ctx.Diags.diagnose(SourceLoc(), diag::cannot_find_executor_factory_type,
                            *ctx.LangOpts.ExecutorFactory);
       }
 
-      ProtocolDecl *executorFactoryProtocol = SGM.getExecutorFactoryProtocol();
+      ProtocolDecl *executorFactoryProtocol
+        = ctx.getProtocol(KnownProtocolKind::ExecutorFactory);
       auto conformance = lookupConformance(factoryTy, executorFactoryProtocol);
 
       if (conformance.isInvalid()) {
         // If this type doesn't conform, ignore it and use the default factory
         SourceLoc loc = extractNearestSourceLoc(factoryTy);
 
-        ctx.Diags.diagnose(loc, diag::executor_factory_must_conform, factoryTy);
+        ctx.Diags.diagnose(loc, diag::executor_factory_must_conform,
+                           *ctx.LangOpts.ExecutorFactory);
 
         factoryTy = SGM.getDefaultExecutorFactory()->getCanonicalType();
         conformance = lookupConformance(factoryTy, executorFactoryProtocol);
@@ -1464,7 +1466,7 @@ void SILGenFunction::emitAsyncMainThreadStart(SILDeclRef entryPoint) {
       SILValue factorySILMetaTy
         = B.createMetatype(moduleLoc, getLoweredType(factoryThickMetaTy));
       auto ceSubs = SubstitutionMap::getProtocolSubstitutions(
-        conformance.getRequirement(), factoryTy, conformance);
+        conformance.getProtocol(), factoryTy, conformance);
       B.createApply(moduleLoc, createExecutorsFunc, ceSubs, { factorySILMetaTy });
     }
   }

stdlib/public/Concurrency/Actor.cpp

@@ -290,6 +290,16 @@ static SerialExecutorRef swift_task_getCurrentExecutorImpl() {
   return result;
 }
 
+/// Determine whether we are currently executing on the main thread
+/// independently of whether we know that we are on the main actor.
+static bool isExecutingOnMainThread() {
+#if SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY
+  return true;
+#else
+  return Thread::onMainThread();
+#endif
+}
+
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
 
@@ -303,7 +313,13 @@ SerialExecutorRef _swift_getActiveExecutor() {
       return SerialExecutorRef::generic();
     return executor;
   }
-  return swift_getMainExecutor();
+
+  // If there's no tracking and we're on the main thread, then the main
+  // executor is notionally active.
+  if (isExecutingOnMainThread())
+    return swift_getMainExecutor();
+
+  return SerialExecutorRef::generic();
 }
 
 extern "C" SWIFT_CC(swift)
@@ -324,16 +340,6 @@ TaskExecutorRef _swift_getPreferredTaskExecutor() {
 
 #pragma clang diagnostic pop
 
-/// Determine whether we are currently executing on the main thread
-/// independently of whether we know that we are on the main actor.
-static bool isExecutingOnMainThread() {
-#if SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY
-  return true;
-#else
-  return Thread::onMainThread();
-#endif
-}
-
 JobPriority swift::swift_task_getCurrentThreadPriority() {
 #if SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY
   return JobPriority::UserInitiated;

stdlib/public/Concurrency/PartialAsyncTask.swift

@@ -470,8 +470,7 @@ extension ExecutorJob {
   /// runtime.
   ///
   /// N.B. Because this allocator is stack disciplined, explicitly
-  /// deallocating memory will also deallocate all memory allocated
-  /// after the block being deallocated.
+  /// deallocating memory out-of-order will cause your program to abort.
   public struct LocalAllocator {
     internal var context: Builtin.Job
 

stdlib/public/Concurrency/Task.cpp

@@ -381,13 +381,6 @@ static SerialExecutorRef executorForEnqueuedJob(Job *job) {
     return swift_task_getMainExecutor();
   }
 
-  // It is no longer valid to return a Dispatch Queue as the "identity" here.
-  //
-  //if (auto identity = reinterpret_cast<HeapObject *>(jobQueue)) {
-  //  return SerialExecutorRef::forOrdinary(
-  //      identity, _swift_task_getDispatchQueueSerialExecutorWitnessTable());
-  //}
-
   return SerialExecutorRef::generic();
 #endif
 }