swift-mirror/stdlib/public/CompatibilityOverride/CompatibilityOverrideConcurrency.def

//===--- CompatibilityOverridesConcurrency.def - Overrides Info -*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// This file defines x-macros used for metaprogramming with the set of
// compatibility override functions.  See CompatibilityOverride.h for
// a detailed explanation of how this system works.
//
//===----------------------------------------------------------------------===//

/// #define OVERRIDE(name, ret, attrs, ccAttrs, namespace, typedArgs, namedArgs)
///   Provides information about an overridable function.
///   - name is the name of the function, without any leading swift_ or
///     namespace.
///   - ret is the return type of the function.
///   - attrs is the attributes, if any, applied to the function definition.
///   - ccAttrs is the calling convention attributes, if any, applied to the
///     function definition and corresponding typedefs
///   - namespace is the namespace, if any, the function is in, including a
///     trailing ::
///   - typedArgs is the argument list, including types, surrounded by
///     parentheses
///   - namedArgs is the list of argument names, with no types, surrounded by
///     parentheses
///
/// The entries are organized by group. A user may define OVERRIDE to get all
/// entries, or define one or more of the more specific OVERRIDE_* variants to
/// get only those entries.  The more specific OVERRIDE_* variants group
/// entries into the functions that are emitted in the specified file;
/// for example, OVERRIDE_ACTOR identifies the functions that are defined
/// in Actor.cpp.

// NOTE: the entries in this file are used to build the struct layout for
// the OverrideSection in the CompatibilityOverride.cpp that is built into
// the concurrency runtime.  A matching file must be used to build the
// ConcurrencyOverrideSection in Overrides.cpp for future compatibility
// override libraries that target this release.
//
// Because compatibility override libraries target a specific release of
// Swift, there is no inherent reason the entries in this file cannot be
// arbitrarily rearranged between release cycles, as long as a matching
// file is used to build any future compatibility override library
// targeting this release.  However, the targeting of compatibility
// override libraries is precise only to a specific major+minor release
// number (e.g. 5.6).  Therefore, care must be taken to avoid ABI breaks
// in this file between patch releases, or else it will become impossible
// to create a compatibility override library for this release:
//
// - Moving or removing entries in this file will break the ABI.
//
// - Changing an entry to use a different implementation file is allowed,
//   but do not move the entry to be grouped with the other entries for
//   the implementation file, as this will break the ABI.
//
// - New entries can be added to the end without breaking the ABI.  This
//   is possible even if there have already been patch releases for this
//   major+minor release, since older patch releases of the runtime will
//   simply not read the new fields.  It is not possible if a compatibility
//   override library has already been released for this major+minor
//   release, but that is unlikely for releases under active development.
//
// When creating a new compatibility override library, always clone the
// last .def files from the appropriate release branch and edit this comment.

#ifdef OVERRIDE
#  define OVERRIDE_ACTOR OVERRIDE
#  define OVERRIDE_TASK OVERRIDE
#  define OVERRIDE_ASYNC_LET OVERRIDE
#  define OVERRIDE_TASK_GROUP OVERRIDE
#  define OVERRIDE_TASK_LOCAL OVERRIDE
#  define OVERRIDE_TASK_STATUS OVERRIDE
#ifndef HOOKED_OVERRIDE_TASK_NORETURN
# define HOOKED_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(...)
#  endif
#  ifndef OVERRIDE_TASK
#    define OVERRIDE_TASK(...)
#  endif
#  ifndef OVERRIDE_ASYNC_LET
#    define OVERRIDE_ASYNC_LET(...)
#  endif
#  ifndef OVERRIDE_TASK_GROUP
#    define OVERRIDE_TASK_GROUP(...)
#  endif
#  ifndef OVERRIDE_TASK_LOCAL
#    define OVERRIDE_TASK_LOCAL(...)
#  endif
#  ifndef OVERRIDE_TASK_STATUS
#    define OVERRIDE_TASK_STATUS(...)
#  endif
#  ifndef HOOKED_OVERRIDE_TASK_NORETURN
#    define HOOKED_OVERRIDE_TASK_NORETURN(...)
#  endif
#endif

OVERRIDE_ACTOR(task_enqueue, void,
               SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
               swift::, (Job *job, SerialExecutorRef executor),
               (job, executor))

OVERRIDE_ACTOR(job_run, void,
               SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
               swift::, (Job *job, SerialExecutorRef executor),
               (job, executor))

OVERRIDE_ACTOR(job_run_on_task_executor, void,
               SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
               swift::, (Job *job, TaskExecutorRef executor),
               (job, executor))

OVERRIDE_ACTOR(job_run_on_serial_and_task_executor, void,
               SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
               swift::, (Job *job,
                         SerialExecutorRef serialExecutor,
                         TaskExecutorRef taskExecutor),
               (job, serialExecutor, taskExecutor))

OVERRIDE_ACTOR(task_getCurrentExecutor, SerialExecutorRef,
               SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
               swift::, ,)

OVERRIDE_ACTOR(task_isCurrentExecutor, bool,
               SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
               swift::, (SerialExecutorRef executor), (executor))

OVERRIDE_ACTOR(task_isCurrentExecutorWithFlags, bool,
               SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
               (SerialExecutorRef executor, swift_task_is_current_executor_flag flags),
               (executor, flags))

OVERRIDE_ACTOR(task_switch, void,
               SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
               swift::, (SWIFT_ASYNC_CONTEXT AsyncContext *resumeToContext,
               TaskContinuationFunction *resumeFunction, SerialExecutorRef newExecutor),
               (resumeToContext, resumeFunction, newExecutor))

OVERRIDE_ACTOR(task_deinitOnExecutor, void,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
              (void *object, DeinitWorkFunction *work, SerialExecutorRef newExecutor, size_t flags),
              (object, work, newExecutor, flags))

OVERRIDE_TASK(task_create_common, AsyncTaskAndContext,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
              (size_t taskCreateFlags,
               TaskOptionRecord *options,
               const Metadata *futureResultType,
               TaskContinuationFunction *function,
               void *closureContext,
               size_t initialContextSize),
              (taskCreateFlags, options, futureResultType, function,
               closureContext, initialContextSize))

OVERRIDE_TASK(task_future_wait, void, SWIFT_EXPORT_FROM(swift_Concurrency),
              SWIFT_CC(swiftasync), swift::,
              (OpaqueValue *result,
               SWIFT_ASYNC_CONTEXT AsyncContext *callerContext, AsyncTask *task,
               TaskContinuationFunction *resumeFunction,
               AsyncContext *callContext),
              (result, callerContext, task, resumeFunction, callContext))

OVERRIDE_TASK(task_future_wait_throwing, void,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
              swift::,
              (OpaqueValue *result,
               SWIFT_ASYNC_CONTEXT AsyncContext *callerContext, AsyncTask *task,
               ThrowingTaskFutureWaitContinuationFunction *resumeFunction,
               AsyncContext *callContext),
              (result, callerContext, task, resumeFunction, callContext))

OVERRIDE_TASK(continuation_resume, void, SWIFT_EXPORT_FROM(swift_Concurrency),
              SWIFT_CC(swift), swift::,
              (AsyncTask *continuation),
              (continuation))

OVERRIDE_TASK(continuation_throwingResume, void,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
              (AsyncTask *continuation),
              (continuation))

OVERRIDE_TASK(continuation_throwingResumeWithError, void,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
              (AsyncTask *continuation, SwiftError *error),
              (continuation, error))

OVERRIDE_TASK(task_addCancellationHandler,
              CancellationNotificationStatusRecord *,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
              (CancellationNotificationStatusRecord::FunctionType handler,
               void *context),
              (handler, context))

OVERRIDE_TASK(task_removeCancellationHandler, void,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
              (CancellationNotificationStatusRecord *record), (record))

OVERRIDE_TASK(task_addPriorityEscalationHandler,
              EscalationNotificationStatusRecord *,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
              (EscalationNotificationStatusRecord::FunctionType handler,
               void *context),
              (handler, context))

OVERRIDE_TASK(task_removePriorityEscalationHandler, void,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
              (EscalationNotificationStatusRecord *record), (record))

OVERRIDE_TASK(task_createNullaryContinuationJob, NullaryContinuationJob *,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
              (size_t priority,
               AsyncTask *continuation), (priority, continuation))

HOOKED_OVERRIDE_TASK_NORETURN(task_asyncMainDrainQueue,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
              swift::, ,)


OVERRIDE_TASK(task_suspend, AsyncTask *,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
              swift::, ,)

OVERRIDE_TASK(task_enqueueTaskOnExecutor, void,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
              (AsyncTask *task, SerialExecutorRef newExecutor), (task, newExecutor))

OVERRIDE_TASK(continuation_init, AsyncTask *,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
              swift::, (ContinuationAsyncContext *context,
                        AsyncContinuationFlags flags),
              (context, flags))

OVERRIDE_TASK(continuation_await, void,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
              swift::, (ContinuationAsyncContext *context),
              (context))

OVERRIDE_ASYNC_LET(asyncLet_wait, void, SWIFT_EXPORT_FROM(swift_Concurrency),
                   SWIFT_CC(swiftasync), swift::,
                   (OpaqueValue *result,
                       SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
                       AsyncLet *alet, TaskContinuationFunction *resumeFn,
                       AsyncContext *callContext),
                   (result, callerContext, alet, resumeFn, callContext))

OVERRIDE_ASYNC_LET(asyncLet_wait_throwing, void,
                   SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
                   swift::,
                   (OpaqueValue *result,
                       SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
                       AsyncLet *alet,
                       ThrowingTaskFutureWaitContinuationFunction *resume,
                       AsyncContext *callContext),
                   (result, callerContext, alet, resume, callContext))

OVERRIDE_ASYNC_LET(asyncLet_end, void,
                   SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                   swift::, (AsyncLet *alet), (alet))

OVERRIDE_ASYNC_LET(asyncLet_get, void,
                   SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
                   swift::,
                   (SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
                    AsyncLet *alet, void *resultBuffer,
                    TaskContinuationFunction *resumeFn,
                    AsyncContext *callContext),
                   (callerContext, alet, resultBuffer, resumeFn, callContext))

OVERRIDE_ASYNC_LET(asyncLet_get_throwing, void,
                   SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
                   swift::,
                   (SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
                    AsyncLet *alet, void *resultBuffer,
                    ThrowingTaskFutureWaitContinuationFunction *resumeFn,
                    AsyncContext *callContext),
                   (callerContext, alet, resultBuffer, resumeFn, callContext))

OVERRIDE_ASYNC_LET(asyncLet_consume, void,
                   SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
                   swift::,
                   (SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
                    AsyncLet *alet, void *resultBuffer,
                    TaskContinuationFunction *resumeFn,
                    AsyncContext *callContext),
                   (callerContext, alet, resultBuffer, resumeFn, callContext))

OVERRIDE_ASYNC_LET(asyncLet_consume_throwing, void,
                   SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
                   swift::,
                   (SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
                    AsyncLet *alet, void *resultBuffer,
                    ThrowingTaskFutureWaitContinuationFunction *resumeFn,
                    AsyncContext *callContext),
                   (callerContext, alet, resultBuffer, resumeFn, callContext))

OVERRIDE_ASYNC_LET(asyncLet_finish, void,
                   SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
                   swift::,
                   (SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
                    AsyncLet *alet, void *resultBuffer,
                    TaskContinuationFunction *resumeFn,
                    AsyncContext *callContext),
                   (callerContext, alet, resultBuffer, resumeFn, callContext))

OVERRIDE_TASK_GROUP(taskGroup_initialize, void,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                    swift::, (TaskGroup *group, const Metadata *T), (group, T))

OVERRIDE_TASK_GROUP(taskGroup_initializeWithFlags, void,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                    swift::, (size_t flags, TaskGroup *group, const Metadata *T), (flags, group, T))

OVERRIDE_TASK_GROUP(taskGroup_initializeWithOptions, void,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                    swift::, (size_t flags, TaskGroup *group, const Metadata *T, TaskOptionRecord *options), (flags, group, T, options))

OVERRIDE_TASK_STATUS(taskGroup_attachChild, void,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                    swift::, (TaskGroup *group, AsyncTask *child),
                    (group, child))

OVERRIDE_TASK_GROUP(taskGroup_destroy, void,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                    swift::, (TaskGroup *group), (group))

OVERRIDE_TASK_GROUP(taskGroup_wait_next_throwing, void,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
                    swift::,
                    (OpaqueValue *resultPointer,
                     SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
                     TaskGroup *_group,
                     ThrowingTaskFutureWaitContinuationFunction *resumeFn,
                     AsyncContext *callContext),
                    (resultPointer, callerContext, _group, resumeFn,
                    callContext))

OVERRIDE_TASK_GROUP(taskGroup_isEmpty, bool,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                    swift::, (TaskGroup *group), (group))

OVERRIDE_TASK_GROUP(taskGroup_isCancelled, bool,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                    swift::, (TaskGroup *group), (group))

OVERRIDE_TASK_GROUP(taskGroup_cancelAll, void,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                    swift::, (TaskGroup *group), (group))

OVERRIDE_TASK_GROUP(taskGroup_addPending, bool,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                    swift::, (TaskGroup *group, bool unconditionally),
                    (group, unconditionally))

OVERRIDE_TASK_GROUP(taskGroup_waitAll, void,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
                    swift::,
                    (OpaqueValue *resultPointer,
                        SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
                        TaskGroup *_group,
                        SwiftError *bodyError,
                        ThrowingTaskFutureWaitContinuationFunction *resumeFn,
                        AsyncContext *callContext),
                    (resultPointer, callerContext, _group, bodyError,
                        resumeFn, callContext))

OVERRIDE_TASK_LOCAL(task_reportIllegalTaskLocalBindingWithinWithTaskGroup, void,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
                    (const unsigned char *file, uintptr_t fileLength,
                        bool fileIsASCII, uintptr_t line),
                    (file, fileLength, fileIsASCII, line))

OVERRIDE_TASK_LOCAL(task_localValuePush, void,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                    swift::,
                    (const HeapObject *key, OpaqueValue *value,
                     const Metadata *valueType),
                    (key, value, valueType))

OVERRIDE_TASK_LOCAL(task_localValueGet, OpaqueValue *,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                    swift::,
                    (const HeapObject *key),
                    (key))

OVERRIDE_TASK_LOCAL(task_localValuePop, void,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                    swift::, ,)

OVERRIDE_TASK_LOCAL(task_localsCopyTo, void,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                    swift::,
                    (AsyncTask *target),
                    (target))

OVERRIDE_TASK_STATUS(task_hasTaskGroupStatusRecord, bool,
                     SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                     swift::, , )

OVERRIDE_TASK_STATUS(task_cancel, void, SWIFT_EXPORT_FROM(swift_Concurrency),
                     SWIFT_CC(swift), swift::, (AsyncTask *task), (task))

OVERRIDE_TASK_GROUP(task_cancel_group_child_tasks, void,
                    SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                    swift::, (TaskGroup *group), (group))

OVERRIDE_TASK_STATUS(task_escalate, JobPriority,
                     SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                     swift::, (AsyncTask *task, JobPriority newPriority),
                     (task, newPriority))

OVERRIDE_TASK_STATUS(task_getPreferredTaskExecutor, TaskExecutorRef,
                     SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                     swift::, , )

OVERRIDE_TASK_STATUS(task_pushTaskExecutorPreference,
                     TaskExecutorPreferenceStatusRecord*,
                     SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                     swift::, (TaskExecutorRef executor),
                     (executor))

OVERRIDE_TASK_STATUS(task_popTaskExecutorPreference, void,
                     SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                     swift::, (TaskExecutorPreferenceStatusRecord *record),
                     (record))

OVERRIDE_TASK(task_startOnMainActor, void,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
              swift::, (AsyncTask *task), (task))

// In ACTOR since we need ExecutorTracking info
OVERRIDE_ACTOR(task_immediate, void,
               SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
               swift::, (AsyncTask *task, SerialExecutorRef targetExecutor),
               (task, targetExecutor))

#undef OVERRIDE
#undef OVERRIDE_ACTOR
#undef OVERRIDE_TASK
#undef OVERRIDE_ASYNC_LET
#undef OVERRIDE_TASK_GROUP
#undef OVERRIDE_TASK_LOCAL
#undef OVERRIDE_TASK_STATUS
#undef HOOKED_OVERRIDE_TASK_NORETURN