Merge pull request #2071 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

include/swift/ABI/MetadataKind.def

@@ -85,6 +85,10 @@ METADATAKIND(HeapGenericLocalVariable,
 METADATAKIND(ErrorObject,
              1 | MetadataKindIsNonType | MetadataKindIsRuntimePrivate)
 
+/// A heap-allocated simple task.
+METADATAKIND(SimpleTask,
+             2 | MetadataKindIsNonType | MetadataKindIsRuntimePrivate)
+
 // getEnumeratedMetadataKind assumes that all the enumerated values here
 // will be <= LastEnumeratedMetadataKind.
 

include/swift/ABI/MetadataValues.h

@@ -1914,9 +1914,8 @@ class JobFlags : public FlagSet<size_t> {
 
     // Kind-specific flags.
 
-    Task_IsHeapObject = 24,
-    Task_IsChildTask  = 25,
-    Task_IsFuture     = 26
+    Task_IsChildTask  = 24,
+    Task_IsFuture     = 25
   };
 
   explicit JobFlags(size_t bits) : FlagSet(bits) {}
@@ -1933,9 +1932,6 @@ class JobFlags : public FlagSet<size_t> {
     return getKind() == JobKind::Task;
   }
 
-  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsHeapObject,
-                                task_isHeapObject,
-                                task_setIsHeapObject)
   FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsChildTask,
                                 task_isChildTask,
                                 task_setIsChildTask)
@@ -2034,8 +2030,8 @@ class AsyncContextFlags : public FlagSet<uint32_t> {
   /// allocated as part of the caller's context, or if the callee will
   /// be called multiple times.
   FLAGSET_DEFINE_FLAG_ACCESSORS(ShouldNotDeallocate,
-                                shouldNotDeallocateInCaller,
-                                setShouldNotDeallocateInCaller)
+                                shouldNotDeallocateInCallee,
+                                setShouldNotDeallocateInCallee)
 };
 
 } // end namespace swift

include/swift/ABI/Task.h

@@ -17,6 +17,7 @@
 #ifndef SWIFT_ABI_TASK_H
 #define SWIFT_ABI_TASK_H
 
+#include "swift/Basic/RelativePointer.h"
 #include "swift/ABI/HeapObject.h"
 #include "swift/ABI/MetadataValues.h"
 #include "swift/Runtime/Config.h"
@@ -32,7 +33,21 @@ class TaskStatusRecord;
 
 /// An ExecutorRef isn't necessarily just a pointer to an executor
 /// object; it may have other bits set.
-using ExecutorRef = Executor *;
+struct ExecutorRef {
+  Executor *Pointer;
+
+  /// Get an executor ref that represents a lack of preference about
+  /// where execution resumes.  This is only valid in continuations,
+  /// return contexts, and so on; it is not generally passed to
+  /// executing functions.
+  static ExecutorRef noPreference() {
+    return { nullptr };
+  }
+
+  bool operator==(ExecutorRef other) const {
+    return Pointer == other.Pointer;
+  }
+};
 
 using JobInvokeFunction =
   SWIFT_CC(swift)
@@ -42,6 +57,33 @@ using TaskContinuationFunction =
   SWIFT_CC(swift)
   void (AsyncTask *, ExecutorRef, AsyncContext *);
 
+template <class Fn>
+struct AsyncFunctionTypeImpl;
+template <class Result, class... Params>
+struct AsyncFunctionTypeImpl<Result(Params...)> {
+  // TODO: expand and include the arguments in the parameters.
+  using type = TaskContinuationFunction;
+};
+
+template <class Fn>
+using AsyncFunctionType = typename AsyncFunctionTypeImpl<Fn>::type;
+
+/// A "function pointer" for an async function.
+///
+/// Eventually, this will always be signed with the data key
+/// using a type-specific discriminator.
+template <class FnType>
+class AsyncFunctionPointer {
+public:
+  /// The function to run.
+  RelativeDirectPointer<AsyncFunctionType<FnType>,
+                        /*nullable*/ false,
+                        int32_t> Function;
+
+  /// The expected size of the context.
+  uint32_t ExpectedContextSize;
+};
+
 /// A schedulable job.
 class alignas(2 * alignof(void*)) Job {
 public:
@@ -76,7 +118,7 @@ class alignas(2 * alignof(void*)) Job {
   }
 
   /// Run this job.
-  void run(Executor *currentExecutor);
+  void run(ExecutorRef currentExecutor);
 };
 
 // The compiler will eventually assume these.
@@ -128,7 +170,7 @@ class ActiveTaskStatus {
 /// An asynchronous task.  Tasks are the analogue of threads for
 /// asynchronous functions: that is, they are a persistent identity
 /// for the overall async computation.
-class AsyncTask : public Job {
+class AsyncTask : public HeapObject, public Job {
 public:
   /// The context for resuming the job.  When a task is scheduled
   /// as a job, the next continuation should be installed as the
@@ -146,9 +188,10 @@ class AsyncTask : public Job {
   /// Reserved for the use of the task-local stack allocator.
   void *AllocatorPrivate[4];
 
-  AsyncTask(JobFlags flags, TaskContinuationFunction *run,
+  AsyncTask(const HeapMetadata *metadata, JobFlags flags,
+            TaskContinuationFunction *run,
             AsyncContext *initialContext)
-    : Job(flags, run),
+    : HeapObject(metadata), Job(flags, run),
       ResumeContext(initialContext),
       Status(ActiveTaskStatus()) {
     assert(flags.isAsyncTask());
@@ -164,12 +207,6 @@ class AsyncTask : public Job {
     return Status.load(std::memory_order_relaxed).isCancelled();
   }
 
-  bool isHeapObject() const { return Flags.task_isHeapObject(); }
-  HeapObject *heapObjectHeader() {
-    assert(isHeapObject());
-    return reinterpret_cast<HeapObject*>(this) - 1;
-  }
-
   /// A fragment of an async task structure that happens to be a child task.
   class ChildFragment {
     /// The parent task of this task.
@@ -182,6 +219,8 @@ class AsyncTask : public Job {
     AsyncTask *NextChild = nullptr;
 
   public:
+    ChildFragment(AsyncTask *parent) : Parent(parent) {}
+
     AsyncTask *getParent() const {
       return Parent;
     }
@@ -191,6 +230,8 @@ class AsyncTask : public Job {
     }
   };
 
+  bool isFuture() const { return Flags.task_isFuture(); }
+
   bool hasChildFragment() const { return Flags.task_isChildTask(); }
   ChildFragment *childFragment() {
     assert(hasChildFragment());
@@ -205,7 +246,7 @@ class AsyncTask : public Job {
 };
 
 // The compiler will eventually assume these.
-static_assert(sizeof(AsyncTask) == 10 * sizeof(void*),
+static_assert(sizeof(AsyncTask) == 12 * sizeof(void*),
               "AsyncTask size is wrong");
 static_assert(alignof(AsyncTask) == 2 * alignof(void*),
               "AsyncTask alignment is wrong");
@@ -237,6 +278,9 @@ class alignas(MaximumAlignment) AsyncContext {
   TaskContinuationFunction * __ptrauth_swift_async_context_resume
     ResumeParent;
 
+  /// The executor that the parent needs to be resumed on.
+  ExecutorRef ResumeParentExecutor;
+
   /// Flags describing this context.
   ///
   /// Note that this field is only 32 bits; any alignment padding
@@ -245,31 +289,44 @@ class alignas(MaximumAlignment) AsyncContext {
   /// is of course interrupted by the YieldToParent field.
   AsyncContextFlags Flags;
 
-  // Fields following this point may not be valid in all instances
-  // of AsyncContext.
-
-  /// The function to call to temporarily resume running in the
-  /// parent context temporarily.  Generally this means a semantic
-  /// yield.  Requires Flags.hasYieldFunction().
-  TaskContinuationFunction * __ptrauth_swift_async_context_yield
-    YieldToParent;
-
-  AsyncContext(AsyncContextFlags flags,
-               TaskContinuationFunction *resumeParent,
-               AsyncContext *parent)
-    : Parent(parent), ResumeParent(resumeParent), Flags(flags) {}
-
   AsyncContext(AsyncContextFlags flags,
                TaskContinuationFunction *resumeParent,
-               TaskContinuationFunction *yieldToParent,
+               ExecutorRef resumeParentExecutor,
                AsyncContext *parent)
-    : Parent(parent), ResumeParent(resumeParent), Flags(flags),
-      YieldToParent(yieldToParent) {}
+    : Parent(parent), ResumeParent(resumeParent),
+      ResumeParentExecutor(resumeParentExecutor),
+      Flags(flags) {}
 
   AsyncContext(const AsyncContext &) = delete;
   AsyncContext &operator=(const AsyncContext &) = delete;
 };
 
+/// An async context that supports yielding.
+class YieldingAsyncContext : public AsyncContext {
+public:
+  /// The function to call to temporarily resume running in the
+  /// parent context.  Generally this means a semantic yield.
+  TaskContinuationFunction * __ptrauth_swift_async_context_yield
+    YieldToParent;
+
+  /// The executor that the parent context needs to be yielded to on.
+  ExecutorRef YieldToParentExecutor;
+
+  YieldingAsyncContext(AsyncContextFlags flags,
+                       TaskContinuationFunction *resumeParent,
+                       ExecutorRef resumeParentExecutor,
+                       TaskContinuationFunction *yieldToParent,
+                       ExecutorRef yieldToParentExecutor,
+                       AsyncContext *parent)
+    : AsyncContext(flags, resumeParent, resumeParentExecutor, parent),
+      YieldToParent(yieldToParent),
+      YieldToParentExecutor(yieldToParentExecutor) {}
+
+  static bool classof(const AsyncContext *context) {
+    return context->Flags.getKind() == AsyncContextKind::Yielding;
+  }
+};
+
 } // end namespace swift
 
 #endif

include/swift/ABI/TaskStatus.h

@@ -82,7 +82,7 @@ class TaskStatusRecord {
   }
 };
 
-TaskStatusRecord *
+inline TaskStatusRecord *
 ActiveTaskStatus::getStatusRecordParent(TaskStatusRecord *ptr) {
   return ptr->getParent();
 }

include/swift/AST/AbstractSourceFileDepGraphFactory.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_AST_SOURCE_FILE_DEP_GRAPH_CONSTRUCTOR_H
 #define SWIFT_AST_SOURCE_FILE_DEP_GRAPH_CONSTRUCTOR_H
 
+#include "swift/AST/Decl.h"
 #include "swift/AST/DeclContext.h"
 #include "swift/AST/FineGrainedDependencies.h"
 
@@ -72,6 +73,21 @@ class AbstractSourceFileDepGraphFactory {
                        Optional<StringRef> fingerprint);
 
   void addAUsedDecl(const DependencyKey &def, const DependencyKey &use);
+
+  static Optional<std::string> getFingerprintIfAny(
+      std::pair<const NominalTypeDecl *, const ValueDecl *>) {
+    return None;
+  }
+
+  static Optional<std::string> getFingerprintIfAny(const Decl *d) {
+    if (const auto *idc = dyn_cast<IterableDeclContext>(d)) {
+      auto result = idc->getBodyFingerprint();
+      assert((!result || !result->empty()) &&
+             "Fingerprint should never be empty");
+      return result;
+    }
+    return None;
+  }
 };
 
 } // namespace fine_grained_dependencies

include/swift/AST/Decl.h

@@ -950,9 +950,6 @@ class alignas(1 << DeclAlignInBits) Decl {
   /// If this returns true, the decl can be safely casted to ValueDecl.
   bool isPotentiallyOverridable() const;
 
-  /// Returns true if this Decl cannot be seen by any other source file
-  bool isPrivateToEnclosingFile() const;
-
   /// Retrieve the global actor attribute that applies to this declaration,
   /// if any.
   ///
@@ -4763,11 +4760,19 @@ class VarDecl : public AbstractStorageDecl {
 
   /// Determines if this var has an initializer expression that should be
   /// exposed to clients.
+  ///
   /// There's a very narrow case when we would: if the decl is an instance
   /// member with an initializer expression and the parent type is
   /// @frozen and resides in a resilient module.
   bool isInitExposedToClients() const;
-  
+
+  /// Determines if this var is exposed as part of the layout of a
+  /// @frozen struct.
+  ///
+  /// From the standpoint of access control and exportability checking, this
+  /// var will behave as if it was public, even if it is internal or private.
+  bool isLayoutExposedToClients() const;
+
   /// Is this a special debugger variable?
   bool isDebuggerVar() const { return Bits.VarDecl.IsDebuggerVar; }
   void setDebuggerVar(bool IsDebuggerVar) {

include/swift/AST/DiagnosticsSema.def

@@ -5061,12 +5061,12 @@ ERROR(local_type_in_inlinable_function,
       (Identifier, unsigned))
 
 ERROR(resilience_decl_unavailable,
-      none, DECL_OR_ACCESSOR "4 %1 is %select{private|fileprivate|internal|'@_spi'|'@_spi'}2 and "
+      none, DECL_OR_ACCESSOR "4 %1 is %select{private|fileprivate|internal|%error|%error}2 and "
       "cannot be referenced from " FRAGILE_FUNC_KIND "3",
       (DescriptiveDeclKind, DeclName, AccessLevel, unsigned, bool))
 
 WARNING(resilience_decl_unavailable_warn,
-        none, DECL_OR_ACCESSOR "4 %1 is %select{private|fileprivate|internal|'@_spi'|'@_spi'}2 and "
+        none, DECL_OR_ACCESSOR "4 %1 is %select{private|fileprivate|internal|%error|%error}2 and "
         "should not be referenced from " FRAGILE_FUNC_KIND "3",
         (DescriptiveDeclKind, DeclName, AccessLevel, unsigned, bool))
 

include/swift/Basic/StringExtras.h

@@ -442,6 +442,8 @@ class InheritedNameSet {
 ///
 /// \param allPropertyNames The set of property names in the enclosing context.
 ///
+/// \param isAsync Whether this is a function imported as 'async'.
+///
 /// \param scratch Scratch space that will be used for modifications beyond
 /// just chopping names.
 ///
@@ -455,6 +457,7 @@ bool omitNeedlessWords(StringRef &baseName,
                        bool returnsSelf,
                        bool isProperty,
                        const InheritedNameSet *allPropertyNames,
+                       bool isAsync,
                        StringScratchSpace &scratch);
 
 } // end namespace swift

include/swift/Driver/Job.h

@@ -308,6 +308,23 @@ class Job {
   /// The modification time of the main input file, if any.
   llvm::sys::TimePoint<> InputModTime = llvm::sys::TimePoint<>::max();
 
+#ifndef NDEBUG
+  /// The "wave" of incremental jobs that this \c Job was scheduled into.
+  ///
+  /// The first "wave" of jobs is computed by the driver from the set of inputs
+  /// and external files that have been mutated by the user. From there, as
+  /// jobs from the first wave finish executing, we reload their \c swiftdeps
+  /// files and re-integrate them into the dependency graph to discover
+  /// the jobs for the second "wave".
+  ///
+  /// In +asserts builds, we ensure that no more than two "waves" occur for
+  /// any given incremental compilation session. This is a consequence of
+  /// 1) transitivity in dependency arcs
+  /// 2) dependency tracing from uses that affect a def's interfaces to that
+  ///    def's uses.
+  mutable unsigned Wave = 1;
+#endif
+
 public:
   Job(const JobAction &Source, SmallVectorImpl<const Job *> &&Inputs,
       std::unique_ptr<CommandOutput> Output, const char *Executable,
@@ -399,6 +416,11 @@ class Job {
   /// Assumes that, if a compile job, has one primary swift input
   /// May return empty if none.
   StringRef getFirstSwiftPrimaryInput() const;
+
+#ifndef NDEBUG
+  unsigned getWave() const { return Wave; }
+  void setWave(unsigned WaveNum) const { Wave = WaveNum; }
+#endif
 };
 
 /// A BatchJob comprises a _set_ of jobs, each of which is sufficiently similar