swiftlang · compnerd · Oct 6, 2022
@@ -21,6 +21,8 @@
 
 namespace swift {
 
+SWIFT_BEGIN_DECLS
+
 /// Perform a checked dynamic cast of a value to a target type.
 ///
 /// \param dest A buffer into which to write the destination value.
@@ -244,6 +246,8 @@ SWIFT_RUNTIME_EXPORT
 const WitnessTable *swift_conformsToProtocol(const Metadata *type,
                                             const ProtocolDescriptor *protocol);
 
+SWIFT_END_DECLS
+
 } // end namespace swift
 
 #endif // SWIFT_RUNTIME_CASTING_H
@@ -70,30 +70,41 @@ struct AsyncTaskAndContext {
   AsyncContext *InitialContext;
 };
 
+SWIFT_BEGIN_DECLS
+
 /// Create a task object.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-AsyncTaskAndContext swift_task_create(
-    size_t taskCreateFlags,
-    TaskOptionRecord *options,
-    const Metadata *futureResultType,
-    void *closureEntry, HeapObject *closureContext);
+AsyncTaskAndContext swift_task_create(size_t taskCreateFlags,
+                                      TaskOptionRecord *options,
+                                      const Metadata *futureResultType,
+                                      void *closureEntry,
+                                      HeapObject *closureContext);
+
+SWIFT_END_DECLS
 
 /// Caution: not all future-initializing functions actually throw, so
 /// this signature may be incorrect.
 using FutureAsyncSignature =
   AsyncSignature<void(void*), /*throws*/ true>;
 
+SWIFT_BEGIN_DECLS
+
 /// Create a task object.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-AsyncTaskAndContext swift_task_create_common(
-    size_t taskCreateFlags,
-    TaskOptionRecord *options,
-    const Metadata *futureResultType,
-    TaskContinuationFunction *function, void *closureContext,
-    size_t initialContextSize);
+AsyncTaskAndContext
+swift_task_create_common(size_t taskCreateFlags, TaskOptionRecord *options,
+                         const Metadata *futureResultType,
+                         TaskContinuationFunction *function,
+                         void *closureContext,
+                         size_t initialContextSize);
+
+SWIFT_END_DECLS
 
 #if SWIFT_CONCURRENCY_TASK_TO_THREAD_MODEL
 #define SWIFT_TASK_RUN_INLINE_INITIAL_CONTEXT_BYTES 4096
+
+SWIFT_BEGIN_DECLS
+
 /// Begin an async context in the current sync context and run the indicated
 /// closure in it.
 ///
@@ -104,8 +115,13 @@ SWIFT_CC(swift)
 void swift_task_run_inline(OpaqueValue *result, void *closureAFP,
                            OpaqueValue *closureContext,
                            const Metadata *futureResultType);
+
+SWIFT_END_DECLS
+
 #endif
 
+SWIFT_BEGIN_DECLS
+
 /// Allocate memory in a task.
 ///
 /// This must be called synchronously with the task.
@@ -141,8 +157,7 @@ void swift_task_cancel_group_child_tasks(TaskGroup *group);
 /// This has no effect if the task already has at least the given priority.
 /// Returns the priority of the task.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-JobPriority
-swift_task_escalate(AsyncTask *task, JobPriority newPriority);
+JobPriority swift_task_escalate(AsyncTask *task, JobPriority newPriority);
 
 // TODO: "async let wait" and "async let destroy" would be expressed
 //       similar to like TaskFutureWait;
@@ -156,10 +171,9 @@ swift_task_escalate(AsyncTask *task, JobPriority newPriority);
 ///     -> Success
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swiftasync)
-void swift_task_future_wait(OpaqueValue *,
-         SWIFT_ASYNC_CONTEXT AsyncContext *, AsyncTask *,
-         TaskContinuationFunction *,
-         AsyncContext *);
+void
+swift_task_future_wait(OpaqueValue *, SWIFT_ASYNC_CONTEXT AsyncContext *,
+                       AsyncTask *, TaskContinuationFunction *, AsyncContext *);
 
 /// Wait for a potentially-throwing future task to complete.
 ///
@@ -170,12 +184,12 @@ void swift_task_future_wait(OpaqueValue *,
 ///    async throws -> Success
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swiftasync)
-void swift_task_future_wait_throwing(
-  OpaqueValue *,
-  SWIFT_ASYNC_CONTEXT AsyncContext *,
-  AsyncTask *,
-  ThrowingTaskFutureWaitContinuationFunction *,
-  AsyncContext *);
+void
+swift_task_future_wait_throwing(OpaqueValue *,
+                                SWIFT_ASYNC_CONTEXT AsyncContext *,
+                                AsyncTask *,
+                                ThrowingTaskFutureWaitContinuationFunction *,
+                                AsyncContext *);
 
 /// Wait for a readyQueue of a Channel to become non empty.
 ///
@@ -187,12 +201,13 @@ void swift_task_future_wait_throwing(
 ///     group: Builtin.RawPointer
 /// ) async -> T
 /// \endcode
-SWIFT_EXPORT_FROM(swift_Concurrency)
-SWIFT_CC(swiftasync)
-void swift_taskGroup_wait_next_throwing(
-    OpaqueValue *resultPointer, SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
-    TaskGroup *group, ThrowingTaskFutureWaitContinuationFunction *resumeFn,
-    AsyncContext *callContext);
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swiftasync)
+void
+swift_taskGroup_wait_next_throwing(OpaqueValue *resultPointer,
+                                   SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
+                                   TaskGroup *group,
+                                   ThrowingTaskFutureWaitContinuationFunction *resumeFn,
+                                   AsyncContext *callContext);
 
 /// Initialize a `TaskGroup` in the passed `group` memory location.
 /// The caller is responsible for retaining and managing the group's lifecycle.
@@ -322,12 +337,16 @@ void swift_asyncLet_begin(AsyncLet *alet,
                           void *closureEntryPoint, HeapObject *closureContext,
                           void *resultBuffer);
 
+SWIFT_END_DECLS
+
 /// This matches the ABI of a closure `<T>(Builtin.RawPointer) async -> T`
 using AsyncLetWaitSignature =
     SWIFT_CC(swiftasync)
     void(OpaqueValue *,
          SWIFT_ASYNC_CONTEXT AsyncContext *, AsyncTask *, Metadata *);
 
+SWIFT_BEGIN_DECLS
+
 /// DEPRECATED. swift_asyncLet_get is used instead.
 /// Wait for a non-throwing async-let to complete.
 ///
@@ -608,6 +627,8 @@ void swift_task_localValuePop();
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_localsCopyTo(AsyncTask* target);
 
+SWIFT_END_DECLS
+
 /// This should have the same representation as an enum like this:
 ///    enum NearestTaskDeadline {
 ///      case none
@@ -626,12 +647,13 @@ struct NearestTaskDeadline {
   Kind ValueKind;
 };
 
+SWIFT_BEGIN_DECLS
+
 /// Returns the nearest deadline that's been registered with this task.
 ///
 /// This must be called synchronously with the task.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-NearestTaskDeadline
-swift_task_getNearestDeadline(AsyncTask *task);
+NearestTaskDeadline swift_task_getNearestDeadline(AsyncTask *task);
 
 /// Switch the current task to a new executor if we aren't already
 /// running on a compatible executor.
@@ -680,9 +702,13 @@ void swift_task_enqueue(Job *job, ExecutorRef executor);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_enqueueGlobal(Job *job);
 
+SWIFT_END_DECLS
+
 /// A count in nanoseconds.
 using JobDelay = unsigned long long;
 
+SWIFT_BEGIN_DECLS
+
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_enqueueGlobalWithDelay(JobDelay delay, Job *job);
 
@@ -694,48 +720,72 @@ void swift_task_enqueueGlobalWithDeadline(long long sec, long long nsec,
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_enqueueMainExecutor(Job *job);
 
+SWIFT_END_DECLS
+
 #if SWIFT_CONCURRENCY_ENABLE_DISPATCH
 
+SWIFT_BEGIN_DECLS
+
 /// Enqueue the given job on the main executor.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_enqueueOnDispatchQueue(Job *job, HeapObject *queue);
 
+SWIFT_END_DECLS
+
 #endif
 
 /// A hook to take over global enqueuing.
 typedef SWIFT_CC(swift) void (*swift_task_enqueueGlobal_original)(Job *job);
-SWIFT_EXPORT_FROM(swift_Concurrency)
-SWIFT_CC(swift) void (*swift_task_enqueueGlobal_hook)(
+
+SWIFT_BEGIN_DECLS
+
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+extern void (*swift_task_enqueueGlobal_hook)(
     Job *job, swift_task_enqueueGlobal_original original);
 
+SWIFT_END_DECLS
+
 /// A hook to take over global enqueuing with delay.
 typedef SWIFT_CC(swift) void (*swift_task_enqueueGlobalWithDelay_original)(
     unsigned long long delay, Job *job);
-SWIFT_EXPORT_FROM(swift_Concurrency)
-SWIFT_CC(swift) void (*swift_task_enqueueGlobalWithDelay_hook)(
+
+SWIFT_BEGIN_DECLS
+
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+extern void (*swift_task_enqueueGlobalWithDelay_hook)(
     unsigned long long delay, Job *job,
     swift_task_enqueueGlobalWithDelay_original original);
 
+SWIFT_END_DECLS
+
 typedef SWIFT_CC(swift) void (*swift_task_enqueueGlobalWithDeadline_original)(
     long long sec,
     long long nsec,
     long long tsec,
     long long tnsec,
     int clock, Job *job);
-SWIFT_EXPORT_FROM(swift_Concurrency)
-SWIFT_CC(swift) void (*swift_task_enqueueGlobalWithDeadline_hook)(
+
+SWIFT_BEGIN_DECLS
+
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+extern void (*swift_task_enqueueGlobalWithDeadline_hook)(
     long long sec,
     long long nsec,
     long long tsec,
     long long tnsec,
     int clock, Job *job,
     swift_task_enqueueGlobalWithDeadline_original original);
 
+SWIFT_END_DECLS
+
 /// A hook to take over main executor enqueueing.
 typedef SWIFT_CC(swift) void (*swift_task_enqueueMainExecutor_original)(
     Job *job);
-SWIFT_EXPORT_FROM(swift_Concurrency)
-SWIFT_CC(swift) void (*swift_task_enqueueMainExecutor_hook)(
+
+SWIFT_BEGIN_DECLS
+
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+extern void (*swift_task_enqueueMainExecutor_hook)(
     Job *job, swift_task_enqueueMainExecutor_original original);
 
 /// Initialize the runtime storage for a default actor.
@@ -756,8 +806,7 @@ void swift_defaultActor_deallocateResilient(HeapObject *actor);
 
 /// Initialize the runtime storage for a distributed remote actor.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-OpaqueValue*
-swift_distributedActor_remote_initialize(const Metadata *actorType);
+OpaqueValue* swift_distributedActor_remote_initialize(const Metadata *actorType);
 
 /// Enqueue a job on the default actor implementation.
 ///
@@ -817,7 +866,7 @@ void swift_continuation_throwingResumeWithError(AsyncTask *continuation,
                                                 /* +1 */ SwiftError *error);
 
 /// SPI helper to log a misuse of a `CheckedContinuation` to the appropriate places in the OS.
-extern "C" SWIFT_CC(swift)
+SWIFT_CC(swift)
 void swift_continuation_logFailedCheck(const char *message);
 
 /// Drain the queue
@@ -854,15 +903,21 @@ void swift_task_reportUnexpectedExecutor(
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 JobPriority swift_task_getCurrentThreadPriority(void);
 
+SWIFT_END_DECLS
+
 #if SWIFT_CONCURRENCY_COOPERATIVE_GLOBAL_EXECUTOR
 
+SWIFT_BEGIN_DECLS
+
 /// Donate this thread to the global executor until either the
 /// given condition returns true or we've run out of cooperative
 /// tasks to run.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_donateThreadToGlobalExecutorUntil(bool (*condition)(void*),
                                                   void *context);
 
+SWIFT_END_DECLS
+
 #endif
 
 enum swift_clock_id : int {

@@ -243,25 +243,25 @@ void _swift_reportToDebugger(uintptr_t flags, const char *message,
                              RuntimeErrorDetails *details = nullptr);
 
 SWIFT_RUNTIME_STDLIB_SPI
-bool _swift_reportFatalErrorsToDebugger;
+extern bool _swift_reportFatalErrorsToDebugger;
 
 SWIFT_RUNTIME_STDLIB_SPI
 bool _swift_shouldReportFatalErrorsToDebugger();
 
 SWIFT_RUNTIME_STDLIB_SPI
-bool _swift_debug_metadataAllocationIterationEnabled;
+extern bool _swift_debug_metadataAllocationIterationEnabled;
 
 SWIFT_RUNTIME_STDLIB_SPI
-const void * const _swift_debug_allocationPoolPointer;
+extern const void * const _swift_debug_allocationPoolPointer;
 
 SWIFT_RUNTIME_STDLIB_SPI
-std::atomic<const void *> _swift_debug_metadataAllocationBacktraceList;
+extern std::atomic<const void *> _swift_debug_metadataAllocationBacktraceList;
 
 SWIFT_RUNTIME_STDLIB_SPI
-const void * const _swift_debug_protocolConformanceStatePointer;
+extern const void * const _swift_debug_protocolConformanceStatePointer;
 
 SWIFT_RUNTIME_STDLIB_SPI
-const uint64_t _swift_debug_multiPayloadEnumPointerSpareBitsMask;
+extern const uint64_t _swift_debug_multiPayloadEnumPointerSpareBitsMask;
 
 // namespace swift
 }