Fix asyncMainDrainQueue noreturn warning

The async main drain queue function is noreturn, but was emitting a
warning due to the override compatibility returning the result of the
overridden function in the wrapper override function. To work around
this, I've added the `OVERRIDE_TASK_NORETURN` macro, which provides an
override point for noreturn functions in the concurrency library that
doesn't return the result from the wrapped function, avoiding the
warning. In the event that the function is not set, the macro is set to
the normal `OVERRIDE` with the return type set to `void`.

Author: etcwilde

stdlib/public/CompatibilityOverride/CompatibilityOverride.cpp

@@ -89,6 +89,15 @@ static OverrideSection *getOverrideSectionPtr() {
       return nullptr;                                               \
     return Section->name;                                           \
   }
+
+#define OVERRIDE_NORETURN(name, attrs, ccAttrs, namespace, typedArgs, namedArgs) \
+  Override_ ## name swift::getOverride_ ## name() {                 \
+    auto *Section = getOverrideSectionPtr();                        \
+    if (Section == nullptr)                                         \
+      nullptr;                                               \
+    Section->name;                                           \
+  }
+
 #include COMPATIBILITY_OVERRIDE_INCLUDE_PATH
 
 #endif // #ifdef SWIFT_STDLIB_SUPPORT_BACK_DEPLOYMENT

stdlib/public/CompatibilityOverride/CompatibilityOverrideConcurrency.def

@@ -77,6 +77,11 @@
 #  define OVERRIDE_TASK_GROUP OVERRIDE
 #  define OVERRIDE_TASK_LOCAL OVERRIDE
 #  define OVERRIDE_TASK_STATUS OVERRIDE
+#ifndef OVERRIDE_TASK_NORETURN
+# define OVERRIDE_TASK_NORETURN(name, attrs, ccAttrs, namespace, typedArgs, \
+                                namedArgs) \
+  OVERRIDE(name, void, attrs, ccAttrs, namespace, typedArgs, namedArgs)
+#endif
 #else
 #  ifndef OVERRIDE_ACTOR
 #    define OVERRIDE_ACTOR(...)
@@ -96,6 +101,9 @@
 #  ifndef OVERRIDE_TASK_STATUS
 #    define OVERRIDE_TASK_STATUS(...)
 #  endif
+#  ifndef OVERRIDE_TASK_NORETURN
+#    define OVERRIDE_TASK_NORETURN(...)
+#  endif
 #endif
 
 OVERRIDE_ACTOR(task_enqueue, void,
@@ -181,7 +189,7 @@ OVERRIDE_TASK(task_createNullaryContinuationJob, NullaryContinuationJob *,
               (size_t priority,
                AsyncTask *continuation), (priority, continuation))
 
-OVERRIDE_TASK(task_asyncMainDrainQueue, void,
+OVERRIDE_TASK_NORETURN(task_asyncMainDrainQueue,
               SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
               , )
 
@@ -380,3 +388,4 @@ OVERRIDE_TASK_STATUS(task_escalate, JobPriority,
 #undef OVERRIDE_TASK_GROUP
 #undef OVERRIDE_TASK_LOCAL
 #undef OVERRIDE_TASK_STATUS
+#undef OVERRIDE_TASK_NORETURN

stdlib/public/Concurrency/Task.cpp

@@ -1590,4 +1590,33 @@ static void swift_task_asyncMainDrainQueueImpl() {
 }
 
 #define OVERRIDE_TASK COMPATIBILITY_OVERRIDE
+
+#ifdef SWIFT_STDLIB_SUPPORT_BACK_DEPLOYMENT
+/// The original COMPATIBILITY_OVERRIDE defined in CompatibilityOverride.h
+/// returns the result of the impl function and override function. This results
+/// in a warning emitted for noreturn functions. Overriding the override macro
+/// to not return.
+#define OVERRIDE_TASK_NORETURN(name, attrs, ccAttrs, namespace, typedArgs,     \
+                               namedArgs)                                      \
+  attrs ccAttrs void namespace swift_##name COMPATIBILITY_PAREN(typedArgs) {   \
+    static Override_##name Override;                                           \
+    static swift_once_t Predicate;                                             \
+    swift_once(                                                                \
+        &Predicate, [](void *) { Override = getOverride_##name(); }, nullptr); \
+    if (Override != nullptr)                                                   \
+      Override(COMPATIBILITY_UNPAREN_WITH_COMMA(namedArgs)                     \
+                   swift_##name##Impl);                                        \
+    swift_##name##Impl COMPATIBILITY_PAREN(namedArgs);                         \
+  }
+
+#else // ifndef SWIFT_STDLIB_SUPPORT_BACK_DEPLOYMENT
+// Call directly through to the original implementation when we don't support
+// overrides.
+#define OVERRIDE_TASK_NORETURN(name, attrs, ccAttrs, namespace, typedArgs,     \
+                               namedArgs)                                      \
+  attrs ccAttrs void namespace swift_##name COMPATIBILITY_PAREN(typedArgs) {   \
+      swift_##name##Impl COMPATIBILITY_PAREN(namedArgs);                       \
+    }
+#endif // #else SWIFT_STDLIB_SUPPORT_BACK_DEPLOYMENT
+
 #include COMPATIBILITY_OVERRIDE_INCLUDE_PATH

unittests/runtime/CompatibilityOverrideConcurrency.cpp

@@ -44,6 +44,15 @@ ExecutorRef getEmptyValue() {
     Ran = true;                                                                \
     return getEmptyValue<ret>();                                               \
   }
+#define OVERRIDE_TASK_NORETURN(name, attrs, ccAttrs, namespace, typedArgs,     \
+                               namedArgs)                                      \
+  static ccAttrs void name##Override(COMPATIBILITY_UNPAREN_WITH_COMMA(         \
+      typedArgs) Original_##name originalImpl) {                               \
+    if (!EnableOverride)                                                       \
+      originalImpl COMPATIBILITY_PAREN(namedArgs);                             \
+    Ran = true;                                                                \
+  }
+
 #include "../../stdlib/public/CompatibilityOverride/CompatibilityOverrideConcurrency.def"
 
 struct OverrideSection {