Manually merge branch 'main' into rebranch

Author: bnbarham

include/swift/ABI/Executor.h

@@ -67,6 +67,7 @@ class ExecutorRef {
     : Identity(identity), Implementation(implementation) {}
 
 public:
+
   /// A generic execution environment.  When running in a generic
   /// environment, it's presumed to be okay to switch synchronously
   /// to an actor.  As an executor request, this represents a request

include/swift/ABI/TaskStatus.h

@@ -22,6 +22,7 @@
 
 #include "swift/ABI/MetadataValues.h"
 #include "swift/ABI/Task.h"
+#include "swift/ABI/Executor.h"
 #include "swift/Runtime/HeapObject.h"
 
 namespace swift {
@@ -61,25 +62,10 @@ class TaskStatusRecord {
 
   TaskStatusRecord *getParent() const { return Parent; }
 
-  /// Change the parent of this unregistered status record to the
-  /// given record.
-  ///
-  /// This should be used when the record has been previously initialized
-  /// without knowing what the true parent is.  If we decide to cache
-  /// important information (e.g. the earliest timeout) in the innermost
-  /// status record, this is the method that should fill that in
-  /// from the parent.
+  /// Change the parent of this status record to the given record.
   void resetParent(TaskStatusRecord *newParent) {
     Parent = newParent;
-    // TODO: cache
   }
-
-  /// Splice a record out of the status-record chain.
-  ///
-  /// Unlike resetParent, this assumes that it's just removing one or
-  /// more records from the chain and that there's no need to do any
-  /// extra cache manipulation.
-  void spliceParent(TaskStatusRecord *newParent) { Parent = newParent; }
 };
 
 /// A status record which states that a task has one or
@@ -293,22 +279,23 @@ class EscalationNotificationStatusRecord : public TaskStatusRecord {
 // This record is allocated for a task to record what it is dependent on before
 // the task can make progress again.
 class TaskDependencyStatusRecord : public TaskStatusRecord {
-  // A word sized storage which references what this task is suspended waiting
-  // for. Note that this is different from the waitQueue in the future fragment
-  // of a task since that denotes all the tasks which this specific task, will
-  // unblock.
+  // A word sized storage which references what this task is waiting for. Note
+  // that this is different from the waitQueue in the future fragment of a task
+  // since that denotes all the tasks which this specific task, will unblock.
   //
   // This field is only really pointing to something valid when the
-  // ActiveTaskStatus specifies that the task is suspended. It can be accessed
-  // asynchronous to the task during escalation which will therefore require the
-  // task status record lock for synchronization.
+  // ActiveTaskStatus specifies that the task is suspended or enqueued. It can
+  // be accessed asynchronous to the task during escalation which will therefore
+  // require the task status record lock for synchronization.
   //
   // When a task has TaskDependencyStatusRecord in the status record list, it
   // must be the innermost status record, barring the status record lock which
   // could be taken while this record is present.
   //
   // The type of thing we are waiting on, is specified in the enum below
-  union {
+  union Dependent {
+    constexpr Dependent() {}
+
     // This task is suspended waiting on another task. This could be an async
     // let child task or it could be another unstructured task.
     AsyncTask *Task;
@@ -325,40 +312,68 @@ class TaskDependencyStatusRecord : public TaskStatusRecord {
     // the duration of the wait. We do not need to take an additional +1 on this
     // task group in this dependency record.
     TaskGroup *TaskGroup;
-  } WaitingOn;
+
+    // The task is enqueued waiting on an executor. It could be any kind of
+    // executor - the generic executor, the default actor's executor, or an
+    // actor with a custom executor.
+    //
+    // This information is helpful to know *where* a task is enqueued into
+    // (potentially intrusively), so that the appropriate escalation effect
+    // (which may be different for each type of executor) can happen if a task
+    // is escalated while enqueued.
+    ExecutorRef Executor;
+  } DependentOn;
 
   // Enum specifying the type of dependency this task has
   enum DependencyKind {
     WaitingOnTask = 1,
     WaitingOnContinuation,
     WaitingOnTaskGroup,
+
+    EnqueuedOnExecutor,
   } DependencyKind;
 
+  // The task that has this task status record - ie a backpointer from the
+  // record to the task with the record. This is not its own +1, we rely on the
+  // fact that since this status record is linked into a task, the task is
+  // already alive and maintained by someone and we can safely borrow the
+  // reference.
+  AsyncTask *WaitingTask;
+
 public:
-  TaskDependencyStatusRecord(AsyncTask *task) :
+  TaskDependencyStatusRecord(AsyncTask *waitingTask, AsyncTask *task) :
     TaskStatusRecord(TaskStatusRecordKind::TaskDependency),
-        DependencyKind(WaitingOnTask) {
-      WaitingOn.Task = task;
+        DependencyKind(WaitingOnTask), WaitingTask(waitingTask) {
+      DependentOn.Task = task;
   }
 
-  TaskDependencyStatusRecord(ContinuationAsyncContext *context) :
+  TaskDependencyStatusRecord(AsyncTask *waitingTask, ContinuationAsyncContext *context) :
     TaskStatusRecord(TaskStatusRecordKind::TaskDependency),
-        DependencyKind(WaitingOnContinuation) {
-      WaitingOn.Continuation = context;
+        DependencyKind(WaitingOnContinuation), WaitingTask(waitingTask) {
+      DependentOn.Continuation = context;
   }
 
-  TaskDependencyStatusRecord(TaskGroup *taskGroup) :
+  TaskDependencyStatusRecord(AsyncTask *waitingTask, TaskGroup *taskGroup) :
     TaskStatusRecord(TaskStatusRecordKind::TaskDependency),
-        DependencyKind(WaitingOnTaskGroup) {
-      WaitingOn.TaskGroup = taskGroup;
+        DependencyKind(WaitingOnTaskGroup), WaitingTask(waitingTask){
+      DependentOn.TaskGroup = taskGroup;
   }
 
-  void destroy() { }
+  TaskDependencyStatusRecord(AsyncTask *waitingTask, ExecutorRef executor) :
+    TaskStatusRecord(TaskStatusRecordKind::TaskDependency),
+        DependencyKind(EnqueuedOnExecutor), WaitingTask(waitingTask) {
+      DependentOn.Executor = executor;
+  }
 
   static bool classof(const TaskStatusRecord *record) {
     return record->getKind() == TaskStatusRecordKind::TaskDependency;
   }
 
+  void updateDependencyToEnqueuedOn(ExecutorRef executor) {
+    DependencyKind = EnqueuedOnExecutor;
+    DependentOn.Executor = executor;
+  }
+
   void performEscalationAction(JobPriority newPriority);
 };
 

include/swift/AST/ASTSynthesis.h

@@ -239,7 +239,9 @@ template <class S>
 struct SpecifiedParamSynthesizer { ParamSpecifier specifier; S sub; };
 template <class G>
 constexpr SpecifiedParamSynthesizer<G> _owned(G sub) {
-  return {ParamSpecifier::Owned, sub};
+  // TODO: We should probably synthesize decls to use the standard `consuming`
+  // modifier, once we're certain doing so won't break anything.
+  return {ParamSpecifier::LegacyOwned, sub};
 }
 template <class G>
 constexpr SpecifiedParamSynthesizer<G> _inout(G sub) {
@@ -257,10 +259,8 @@ FunctionType::Param synthesizeParamType(SynthesisContext &SC,
                                         const SpecifiedParamSynthesizer<S> &s) {
   auto param = synthesizeParamType(SC, s.sub);
   auto flags = param.getParameterFlags();
-  if (s.specifier == ParamSpecifier::Owned)
-    flags = flags.withOwned(true);
-  if (s.specifier == ParamSpecifier::InOut)
-    flags = flags.withInOut(true);
+  if (s.specifier != ParamSpecifier::Default)
+    flags = flags.withValueOwnership(s.specifier);
   return param.withFlags(flags);
 }
 

include/swift/AST/ASTWalker.h

@@ -79,6 +79,24 @@ enum class LazyInitializerWalking {
   InAccessor
 };
 
+/// Specifies the behavior for walking a macro expansion, whether we want to
+/// see the macro arguments, the expansion, or both.
+enum class MacroWalking {
+  /// Walk into the expansion of the macro, to see the semantic effect of
+  /// the macro expansion.
+  Expansion,
+
+  /// Walk into the arguments of the macro as written in the source code.
+  ///
+  /// The actual arguments walked may not make it into the program itself,
+  /// because they can be translated by the macro in arbitrary ways.
+  Arguments,
+
+  /// Walk into both the arguments of the macro as written in the source code
+  /// and also the macro expansion.
+  ArgumentsAndExpansion
+};
+
 /// An abstract class used to traverse an AST.
 class ASTWalker {
 public:
@@ -504,6 +522,26 @@ class ASTWalker {
     return LazyInitializerWalking::InPatternBinding;
   }
 
+  /// This method configures how the walker should walk into uses of macros.
+  virtual MacroWalking getMacroWalkingBehavior() const {
+    return MacroWalking::ArgumentsAndExpansion;
+  }
+
+  /// Determine whether we should walk macro arguments (as they appear in
+  /// source) and the expansion (which is semantically part of the program).
+  std::pair<bool, bool> shouldWalkMacroArgumentsAndExpansion() const {
+    switch (getMacroWalkingBehavior()) {
+    case MacroWalking::Expansion:
+      return std::make_pair(false, true);
+
+    case MacroWalking::Arguments:
+      return std::make_pair(true, false);
+
+    case MacroWalking::ArgumentsAndExpansion:
+      return std::make_pair(true, true);
+    }
+  }
+
   /// This method configures whether the walker should visit the body of a
   /// closure that was checked separately from its enclosing expression.
   ///
@@ -541,10 +579,6 @@ class ASTWalker {
   /// TODO: Consider changing this to false by default.
   virtual bool shouldWalkSerializedTopLevelInternalDecls() { return true; }
 
-  /// Whether we should walk into expanded macros, whether it be from a
-  /// \c MacroExpansionExpr or declarations created by attached macros.
-  virtual bool shouldWalkMacroExpansions() { return true; }
-
   /// walkToParameterListPre - This method is called when first visiting a
   /// ParameterList, before walking into its parameters.
   ///

include/swift/AST/Decl.h

@@ -410,12 +410,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   );
 
   SWIFT_INLINE_BITFIELD(ParamDecl, VarDecl, 1+2+NumDefaultArgumentKindBits,
-    /// Whether we've computed the specifier yet.
-    SpecifierComputed : 1,
-
-    /// The specifier associated with this parameter.  This determines
-    /// the storage semantics of the value e.g. mutability.
-    Specifier : 2,
+    /// The specifier associated with this parameter + 1, or zero if the
+    /// specifier has not been computed yet.  This determines
+    /// the ownership semantics of the parameter.
+    OwnershipSpecifier : 3,
 
     /// Information about a symbolic default argument, like #file.
     defaultArgumentKind : NumDefaultArgumentKindBits
@@ -5983,11 +5981,27 @@ class VarDecl : public AbstractStorageDecl {
   }
 };
 
+/// The various spellings of ownership modifier that can be used in source.
 enum class ParamSpecifier : uint8_t {
+  /// No explicit ownership specifier was provided. The parameter will use the
+  /// default ownership convention for the declaration.
   Default = 0,
+
+  /// `inout`, indicating exclusive mutable access to the argument for the
+  /// duration of a call.
   InOut = 1,
-  Shared = 2,
-  Owned = 3,
+
+  /// `borrowing`, indicating nonexclusive access to the argument for the
+  /// duration of a call.
+  Borrowing = 2,
+  /// `consuming`, indicating ownership transfer of the argument from caller
+  /// to callee.
+  Consuming = 3,
+
+  /// `__shared`, a legacy spelling of `borrowing`.
+  LegacyShared = 4,
+  /// `__owned`, a legacy spelling of `consuming`.
+  LegacyOwned = 5,
 };
 
 /// A function parameter declaration.
@@ -6276,8 +6290,8 @@ class ParamDecl : public VarDecl {
   using Specifier = ParamSpecifier;
 
   Optional<Specifier> getCachedSpecifier() const {
-    if (Bits.ParamDecl.SpecifierComputed)
-      return Specifier(Bits.ParamDecl.Specifier);
+    if (Bits.ParamDecl.OwnershipSpecifier != 0)
+      return Specifier(Bits.ParamDecl.OwnershipSpecifier - 1);
 
     return None;
   }
@@ -6288,20 +6302,18 @@ class ParamDecl : public VarDecl {
 
   /// Is the type of this parameter 'inout'?
   bool isInOut() const { return getSpecifier() == Specifier::InOut; }
-  /// Is this an immutable 'shared' property?
-  bool isShared() const { return getSpecifier() == Specifier::Shared; }
-  /// Is this an immutable 'owned' property?
-  bool isOwned() const { return getSpecifier() == Specifier::Owned; }
 
-  bool isImmutable() const {
-    return isImmutableSpecifier(getSpecifier());
+  bool isImmutableInFunctionBody() const {
+    return isSpecifierImmutableInFunctionBody(getSpecifier());
   }
-  static bool isImmutableSpecifier(Specifier sp) {
+  static bool isSpecifierImmutableInFunctionBody(Specifier sp) {
     switch (sp) {
     case Specifier::Default:
-    case Specifier::Shared:
-    case Specifier::Owned:
+    case Specifier::Borrowing:
+    case Specifier::LegacyShared:
+    case Specifier::LegacyOwned:
       return true;
+    case Specifier::Consuming:
     case Specifier::InOut:
       return false;
     }
@@ -6314,29 +6326,32 @@ class ParamDecl : public VarDecl {
 
   static ValueOwnership getValueOwnershipForSpecifier(Specifier specifier) {
     switch (specifier) {
-    case Specifier::Default:
-      return ValueOwnership::Default;
-    case Specifier::InOut:
+    case ParamSpecifier::InOut:
       return ValueOwnership::InOut;
-    case Specifier::Shared:
+    case ParamSpecifier::Borrowing:
+    case ParamSpecifier::LegacyShared:
       return ValueOwnership::Shared;
-    case Specifier::Owned:
+    case ParamSpecifier::Consuming:
+    case ParamSpecifier::LegacyOwned:
       return ValueOwnership::Owned;
+    case ParamSpecifier::Default:
+      return ValueOwnership::Default;
     }
-    llvm_unreachable("unhandled specifier");
+    llvm_unreachable("invalid ParamSpecifier");
   }
 
   static Specifier
   getParameterSpecifierForValueOwnership(ValueOwnership ownership) {
+    // TODO: switch over to consuming/borrowing once they're fully supported
     switch (ownership) {
     case ValueOwnership::Default:
       return Specifier::Default;
     case ValueOwnership::Shared:
-      return Specifier::Shared;
+      return Specifier::LegacyShared; // should become Borrowing
     case ValueOwnership::InOut:
       return Specifier::InOut;
     case ValueOwnership::Owned:
-      return Specifier::Owned;
+      return Specifier::LegacyOwned; // should become Consuming
     }
     llvm_unreachable("unhandled ownership");
   }
@@ -6349,6 +6364,9 @@ class ParamDecl : public VarDecl {
   static bool classof(const Decl *D) { 
     return D->getKind() == DeclKind::Param;
   }
+  
+  /// Get the source code spelling of a parameter specifier value as a string.
+  static StringRef getSpecifierSpelling(Specifier spec);
 };
 
 /// Describes the kind of subscripting used in Objective-C.

include/swift/AST/DiagnosticsFrontend.def

@@ -221,6 +221,10 @@ ERROR(error_mode_requires_one_sil_multi_sib,none,
       "this mode requires .sil for primary-file and only .sib for other inputs",
       ())
 
+ERROR(error_clang_validate_once_requires_session_file,none,
+      "'-validate-clang-modules-once' also requires a '-clang-build-session-file' argument",
+      ())
+
 ERROR(error_no_output_filename_specified,none,
       "an %0 filename was not specified for a mode which requires an "
       "%0 filename", (StringRef))