Merge remote-tracking branch 'apple/main' into katei/merge-main-2021-04-20

Author: kateinoigakukun

include/swift/ABI/AsyncLet.h

@@ -0,0 +1,52 @@
+//===--- AsyncLet.h - ABI structures for async let -00-----------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Swift ABI describing task groups.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_ABI_TASK_ASYNC_LET_H
+#define SWIFT_ABI_TASK_ASYNC_LET_H
+
+#include "swift/ABI/Task.h"
+#include "swift/ABI/HeapObject.h"
+#include "swift/Runtime/Concurrency.h"
+#include "swift/Runtime/Config.h"
+#include "swift/Basic/RelativePointer.h"
+#include "swift/Basic/STLExtras.h"
+
+namespace swift {
+
+/// Represents an in-flight `async let`, i.e. the Task that is computing the
+/// result of the async let, along with the awaited status and other metadata.
+class alignas(Alignment_AsyncLet) AsyncLet {
+public:
+  // These constructors do not initialize the AsyncLet instance, and the
+  // destructor does not destroy the AsyncLet instance; you must call
+  // swift_asyncLet_{start,end} yourself.
+  constexpr AsyncLet()
+    : PrivateData{} {}
+
+  // FIXME: not sure how many words we should reserve
+  void *PrivateData[NumWords_AsyncLet];
+
+  // TODO: we could offer a "was awaited on" check here
+
+  /// Returns the child task that is associated with this async let.
+  /// The tasks completion is used to fulfil the value represented by this async let.
+  AsyncTask *getTask() const;
+
+};
+
+} // end namespace swift
+
+#endif // SWIFT_ABI_TASK_ASYNC_LET_H

include/swift/ABI/MetadataValues.h

@@ -49,6 +49,9 @@ enum {
 
   /// The number of words in a task group.
   NumWords_TaskGroup = 32,
+
+  /// The number of words in an AsyncLet (flags + task pointer)
+  NumWords_AsyncLet = 8, // TODO: not sure how much is enough, these likely could be pretty small
 };
 
 struct InProcess;
@@ -127,6 +130,9 @@ const size_t Alignment_DefaultActor = MaximumAlignment;
 /// The alignment of a TaskGroup.
 const size_t Alignment_TaskGroup = MaximumAlignment;
 
+/// The alignment of an AsyncLet.
+const size_t Alignment_AsyncLet = MaximumAlignment;
+
 /// Flags stored in the value-witness table.
 template <typename int_type>
 class TargetValueWitnessFlags {

include/swift/ABI/TaskGroup.h

@@ -29,8 +29,8 @@ namespace swift {
 /// The task group is responsible for maintaining dynamically created child tasks.
 class alignas(Alignment_TaskGroup) TaskGroup {
 public:
-  // These constructors do not initialize the actor instance, and the
-  // destructor does not destroy the actor instance; you must call
+  // These constructors do not initialize the group instance, and the
+  // destructor does not destroy the group instance; you must call
   // swift_taskGroup_{initialize,destroy} yourself.
   constexpr TaskGroup()
     : PrivateData{} {}
@@ -43,4 +43,4 @@ class alignas(Alignment_TaskGroup) TaskGroup {
 
 } // end namespace swift
 
-#endif
+#endif // SWIFT_ABI_TASK_GROUP_H

include/swift/AST/Builtins.def

@@ -782,6 +782,19 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(GetCurrentAsyncTask, "getCurrentAsyncTask", "
 /// Cancel the given asynchronous task.
 BUILTIN_MISC_OPERATION_WITH_SILGEN(CancelAsyncTask, "cancelAsyncTask", "", Special)
 
+/// startAsyncLet()<T>: (
+///     __owned @Sendable @escaping () async throws -> T
+/// ) -> Builtin.RawPointer
+///
+/// Create, initialize and start a new async-let and associated task.
+/// Returns an AsyncLet* that must be passed to endAsyncLet for destruction.
+BUILTIN_MISC_OPERATION(StartAsyncLet, "startAsyncLet", "", Special)
+
+/// asyncLetEnd(): (Builtin.RawPointer) -> Void
+///
+/// Ends and destroys an async-let.
+BUILTIN_MISC_OPERATION_WITH_SILGEN(EndAsyncLet, "endAsyncLet", "", Special)
+
 /// createAsyncTaskFuture(): (
 ///     Int, Builtin.NativeObject?, @escaping () async throws -> T
 /// ) -> Builtin.NativeObject

include/swift/AST/DiagnosticsSIL.def

@@ -250,17 +250,25 @@ NOTE(designated_init_c_struct_fix,none,
 
 
 // Control flow diagnostics.
-ERROR(missing_return,none,
-      "missing return in a %select{function|closure}1 expected to return %0",
-      (Type, unsigned))
-ERROR(missing_return_last_expr,none,
-      "missing return in a %select{function|closure}1 expected to return %0; "
-      "did you mean to return the last expression?",
-      (Type, unsigned))
-ERROR(missing_never_call,none,
-      "%select{function|closure}1 with uninhabited return type %0 is missing "
+ERROR(missing_return_closure,none,
+      "missing return in closure expected to return %0",
+      (Type))
+ERROR(missing_never_call_closure,none,
+      "closure with uninhabited return type %0 is missing "
+      "call to another never-returning function on all paths",
+      (Type))
+
+ERROR(missing_return_decl,none,
+      "missing return in %1 expected to return %0",
+      (Type, DescriptiveDeclKind))
+ERROR(missing_never_call_decl,none,
+      "%1 with uninhabited return type %0 is missing "
       "call to another never-returning function on all paths",
-      (Type, unsigned))
+      (Type, DescriptiveDeclKind))
+
+NOTE(missing_return_last_expr_note,none,
+    "did you mean to return the last expression?", ())
+
 ERROR(guard_body_must_not_fallthrough,none,
       "'guard' body must not fall through, consider using a 'return' or 'throw'"
       " to exit the scope", ())

include/swift/Frontend/FrontendOptions.h

@@ -397,6 +397,10 @@ class FrontendOptions {
   ///
   /// \sa SymbolGraphASTWalker
   std::string SymbolGraphOutputDir;
+  
+  /// Whether to emit doc comment information in symbol graphs for symbols
+  /// which are inherited through classes or default implementations.
+  bool SkipInheritedDocs = false;
 
 private:
   static bool canActionEmitDependencies(ActionType);

include/swift/Option/Options.td

@@ -1225,4 +1225,10 @@ def minimum_access_level : Separate<["-"], "minimum-access-level">,
   HelpText<"Include symbols with this access level or more">,
   MetaVarName<"<level>">;
 
+def skip_inherited_docs : Flag<["-"], "skip-inherited-docs">,
+  Flags<[SwiftSymbolGraphExtractOption, FrontendOption,
+         NoInteractiveOption, SupplementaryOutput, HelpHidden]>,
+  HelpText<"Skip emitting doc comments for members inherited through classes or "
+           "default implementations">;
+
 include "FrontendOptions.td"

include/swift/Runtime/Concurrency.h

@@ -18,6 +18,7 @@
 #define SWIFT_RUNTIME_CONCURRENCY_H
 
 #include "swift/ABI/TaskGroup.h"
+#include "swift/ABI/AsyncLet.h"
 #include "swift/ABI/TaskStatus.h"
 
 #pragma clang diagnostic push
@@ -49,15 +50,17 @@ using FutureAsyncSignature =
 /// closure.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create_future(
-    JobFlags flags, const Metadata *futureResultType,
+    JobFlags flags,
+    const Metadata *futureResultType,
     void *closureEntryPoint,
     HeapObject * /* +1 */ closureContext);
 
 /// Create a task object with a future which will run the given
 /// function.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create_future_f(
-    JobFlags flags, const Metadata *futureResultType,
+    JobFlags flags,
+    const Metadata *futureResultType,
     FutureAsyncSignature::FunctionType *function,
     size_t initialContextSize);
 
@@ -74,7 +77,8 @@ AsyncTaskAndContext swift_task_create_group_future(
 /// function, and offer its result to the task group
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create_group_future_f(
-    JobFlags flags, TaskGroup *group,
+    JobFlags flags,
+    TaskGroup *group,
     const Metadata *futureResultType,
     FutureAsyncSignature::FunctionType *function,
     size_t initialContextSize);
@@ -169,7 +173,7 @@ SWIFT_CC(swiftasync)
 /// \code
 /// func swift_taskGroup_wait_next_throwing(
 ///     waitingTask: Builtin.NativeObject, // current task
-///     group: UnsafeRawPointer
+///     group: Builtin.RawPointer
 /// ) async -> T
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency)
@@ -184,8 +188,7 @@ void swift_taskGroup_wait_next_throwing(
 /// Its Swift signature is
 ///
 /// \code
-/// func swift_taskGroup_initialize(group: Builtin.RawPointer
-/// )
+/// func swift_taskGroup_initialize(group: Builtin.RawPointer)
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_taskGroup_initialize(TaskGroup *group);
@@ -202,7 +205,6 @@ void swift_taskGroup_initialize(TaskGroup *group);
 /// \code
 /// func swift_taskGroup_attachChild(
 ///     group: Builtin.RawPointer,
-///     parent: Builtin.NativeObject,
 ///     child: Builtin.NativeObject
 /// )
 /// \endcode
@@ -214,7 +216,7 @@ void swift_taskGroup_attachChild(TaskGroup *group, AsyncTask *child);
 /// This function MUST be called from the AsyncTask running the task group.
 ///
 /// \code
-/// func swift_taskGroup_destroy(_ group: UnsafeRawPointer)
+/// func swift_taskGroup_destroy(_ group: Builtin.RawPointer)
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_taskGroup_destroy(TaskGroup *group);
@@ -244,7 +246,7 @@ bool swift_taskGroup_addPending(TaskGroup *group, bool unconditionally);
 /// Its Swift signature is
 ///
 /// \code
-/// func swift_taskGroup_cancelAll(group: UnsafeRawPointer)
+/// func swift_taskGroup_cancelAll(group: Builtin.RawPointer)
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_taskGroup_cancelAll(TaskGroup *group);
@@ -257,7 +259,7 @@ void swift_taskGroup_cancelAll(TaskGroup *group);
 /// This can be called from any thread. Its Swift signature is
 ///
 /// \code
-/// func swift_taskGroup_isCancelled(group: UnsafeRawPointer)
+/// func swift_taskGroup_isCancelled(group: Builtin.RawPointer)
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 bool swift_taskGroup_isCancelled(TaskGroup *group);
@@ -274,6 +276,63 @@ bool swift_taskGroup_isCancelled(TaskGroup *group);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 bool swift_taskGroup_isEmpty(TaskGroup *group);
 
+/// Its Swift signature is
+///
+/// \code
+/// func swift_asyncLet_start<T>(
+///     _ alet: Builtin.RawPointer,
+///     operation: __owned @Sendable @escaping () async throws -> T
+/// )
+/// \endcode
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_asyncLet_start(
+    AsyncLet *alet,
+    const Metadata *futureResultType,
+    void *closureEntryPoint,
+    HeapObject * /* +1 */ closureContext);
+
+/// 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 *);
+
+/// Wait for a non-throwing async-let to complete.
+///
+/// This can be called from any thread. Its Swift signature is
+///
+/// \code
+/// func swift_asyncLet_wait(
+///     _ asyncLet: _owned Builtin.RawPointer
+/// ) async -> Success
+/// \endcode
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swiftasync)
+void swift_asyncLet_wait(OpaqueValue *,
+                         SWIFT_ASYNC_CONTEXT AsyncContext *,
+                         AsyncLet *, Metadata *);
+
+/// Wait for a potentially-throwing async-let to complete.
+///
+/// This can be called from any thread. Its Swift signature is
+///
+/// \code
+/// func swift_asyncLet_wait_throwing(
+///     _ asyncLet: _owned Builtin.RawPointer
+/// ) async throws -> Success
+/// \endcode
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swiftasync)
+void swift_asyncLet_wait_throwing(OpaqueValue *,
+                                  SWIFT_ASYNC_CONTEXT AsyncContext *,
+                                  AsyncLet *, Metadata *);
+
+/// Its Swift signature is
+///
+/// \code
+/// func swift_asyncLet_end(_ alet: Builtin.RawPointer)
+/// \endcode
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_asyncLet_end(AsyncLet *alet);
+
 /// Add a status record to a task.  The record should not be
 /// modified while it is registered with a task.
 ///
@@ -314,8 +373,7 @@ bool swift_task_removeStatusRecord(TaskStatusRecord *record);
 /// The record must be removed with by the parent invoking
 /// `swift_task_detachChild` when the child has completed.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-ChildTaskStatusRecord*
-swift_task_attachChild(AsyncTask *child);
+ChildTaskStatusRecord* swift_task_attachChild(AsyncTask *child);
 
 /// Remove a child task from the parent tracking it.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)