//===--- 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.
//
//===----------------------------------------------------------------------===//

/// #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.

// NOTE: this file is used to build the definition of OverrideSection in
// CompatibilityOverride.cpp, which is part of the ABI. Moving or removing
// entries in this file will break the ABI. Additional entries can be added to
// the end. ABI breaks or version-specific changes can be accommodated by
// changing the name of the override section in that file.

#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
#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
#endif

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

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

OVERRIDE_ACTOR(task_getCurrent, AsyncTask *,
               SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
               swift::, ,)

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

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

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

OVERRIDE_TASK(task_create_group_future_common, AsyncTaskAndContext, , , ,
              (size_t flags, TaskGroup *group,
               const Metadata *futureResultType,
               FutureAsyncSignature::FunctionType *function,
               void *closureContext, bool isAsyncLetTask,
               size_t initialContextSize),
              (flags, group, futureResultType, function, closureContext,
               isAsyncLetTask, initialContextSize))

OVERRIDE_TASK(task_future_wait, void, SWIFT_EXPORT_FROM(swift_Concurrency),
              SWIFT_CC(swiftasync), swift::,
              (OpaqueValue *result,
               SWIFT_ASYNC_CONTEXT AsyncContext *rawContext, AsyncTask *task,
               Metadata *T),
              (result, rawContext, task, T))

OVERRIDE_TASK(task_future_wait_throwing, void,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
              swift::,
              (OpaqueValue *result,
               SWIFT_ASYNC_CONTEXT AsyncContext *rawContext, AsyncTask *task,
               Metadata *T),
              (result, rawContext, task, T))

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_createNullaryContinuationJob, NullaryContinuationJob *,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
              (size_t priority,
               AsyncTask *continuation), (priority, continuation))

OVERRIDE_TASK(task_asyncMainDrainQueue, void,
              SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
              , )

OVERRIDE_ASYNC_LET(asyncLet_start, void,
                   SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                   swift::,
                   (AsyncLet *alet,
                    const Metadata *futureResultType,
                    void *closureEntryPoint,
                    void *closureContext
                   ),
                   (alet, futureResultType,
                    closureEntryPoint, closureContext))

OVERRIDE_ASYNC_LET(asyncLet_wait, void, SWIFT_EXPORT_FROM(swift_Concurrency),
                   SWIFT_CC(swiftasync), swift::,
                   (OpaqueValue *result,
                       SWIFT_ASYNC_CONTEXT AsyncContext *rawContext,
                       AsyncLet *alet, Metadata *T),
                   (result, rawContext, alet, T))

OVERRIDE_ASYNC_LET(asyncLet_wait_throwing, void,
                   SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
                   swift::,
                   (OpaqueValue *result,
                       SWIFT_ASYNC_CONTEXT AsyncContext *rawContext,
                       AsyncLet *alet, Metadata *T),
                   (result, rawContext, alet, T))

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

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

OVERRIDE_TASK_GROUP(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 *rawContext,
                     TaskGroup *_group, const Metadata *successType),
                    (resultPointer, rawContext, _group, successType))

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_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_addStatusRecord, bool,
                     SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                     swift::, (TaskStatusRecord *newRecord), (newRecord))

OVERRIDE_TASK_STATUS(task_tryAddStatusRecord, bool,
                     SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                     swift::, (TaskStatusRecord *newRecord), (newRecord))

OVERRIDE_TASK_STATUS(task_removeStatusRecord, bool,
                     SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                     swift::, (TaskStatusRecord *record), (record))

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

OVERRIDE_TASK_STATUS(task_attachChild, ChildTaskStatusRecord *,
                     SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                     swift::, (AsyncTask *child), (child))

OVERRIDE_TASK_STATUS(task_detachChild, void,
                     SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                     swift::, (ChildTaskStatusRecord *record), (record))

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

OVERRIDE_TASK_STATUS(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_getNearestDeadline, NearestTaskDeadline,
                     SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                     swift::, (AsyncTask *task), (task))

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