Merge branch 'main' into 73992299-1

Author: nkcsgexi

include/swift/ABI/Metadata.h

@@ -4290,6 +4290,10 @@ class TargetClassDescriptor final
     return FieldOffsetVectorOffset;
   }
 
+  bool isActor() const {
+    return this->getTypeContextDescriptorFlags().class_isActor();
+  }
+
   bool isDefaultActor() const {
     return this->getTypeContextDescriptorFlags().class_isDefaultActor();
   }

include/swift/ABI/MetadataValues.h

@@ -1395,6 +1395,11 @@ class TypeContextDescriptorFlags : public FlagSet<uint16_t> {
 
     // Type-specific flags:
 
+    /// Set if the class is an actor.
+    ///
+    /// Only meaningful for class descriptors.
+    Class_IsActor = 7,
+
     /// Set if the class is a default actor class.  Note that this is
     /// based on the best knowledge available to the class; actor
     /// classes with resilient superclassess might be default actors
@@ -1485,6 +1490,9 @@ class TypeContextDescriptorFlags : public FlagSet<uint16_t> {
   FLAGSET_DEFINE_FLAG_ACCESSORS(Class_IsDefaultActor,
                                 class_isDefaultActor,
                                 class_setIsDefaultActor)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Class_IsActor,
+                                class_isActor,
+                                class_setIsActor)
 
   FLAGSET_DEFINE_FIELD_ACCESSORS(Class_ResilientSuperclassReferenceKind,
                                  Class_ResilientSuperclassReferenceKind_width,
@@ -2007,6 +2015,7 @@ class JobFlags : public FlagSet<size_t> {
     Task_IsChildTask      = 24,
     Task_IsFuture         = 25,
     Task_IsGroupChildTask = 26,
+    Task_IsContinuingAsyncTask      = 27,
   };
 
   explicit JobFlags(size_t bits) : FlagSet(bits) {}
@@ -2036,6 +2045,9 @@ class JobFlags : public FlagSet<size_t> {
   FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsGroupChildTask,
                                 task_isGroupChildTask,
                                 task_setIsGroupChildTask)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsContinuingAsyncTask,
+                                task_isContinuingAsyncTask,
+                                task_setIsContinuingAsyncTask)
 };
 
 /// Kinds of task status record.

include/swift/ABI/Task.h

@@ -50,7 +50,7 @@ class alignas(2 * alignof(void*)) Job :
     NextWaitingTaskIndex = 0,
 
     // The Dispatch object header is one pointer and two ints, which is
-    // equvialent to three pointers on 32-bit and two pointers 64-bit. Set the
+    // equivalent to three pointers on 32-bit and two pointers 64-bit. Set the
     // indexes accordingly so that DispatchLinkageIndex points to where Dispatch
     // expects.
     DispatchHasLongObjectHeader = sizeof(void *) == sizeof(int),
@@ -243,14 +243,13 @@ class AsyncTask : public Job {
 
   // ==== Task Local Values ----------------------------------------------------
 
-  void localValuePush(const Metadata *keyType,
+  void localValuePush(const HeapObject *key,
                       /* +1 */ OpaqueValue *value, const Metadata *valueType) {
-    Local.pushValue(this, keyType, value, valueType);
+    Local.pushValue(this, key, value, valueType);
   }
 
-  OpaqueValue* localValueGet(const Metadata *keyType,
-                             TaskLocal::TaskLocalInheritance inherit) {
-    return Local.getValue(this, keyType, inherit);
+  OpaqueValue* localValueGet(const HeapObject *key) {
+    return Local.getValue(this, key);
   }
 
   void localValuePop() {

include/swift/ABI/TaskLocal.h

@@ -34,73 +34,50 @@ class TaskLocal {
 public:
   /// Type of the pointed at `next` task local item.
   enum class NextLinkType : uintptr_t {
-    /// This task is known to be a "terminal" node in the lookup of task locals.
-    /// In other words, even if it had a parent, the parent (and its parents)
-    /// are known to not contain any any more task locals, and thus any further
-    /// search beyond this task.
-    IsTerminal = 0b00,
     /// The storage pointer points at the next TaskLocal::Item in this task.
-    IsNext = 0b01,
+    IsNext = 0b00,
     /// The storage pointer points at a item stored by another AsyncTask.
     ///
     /// Note that this may not necessarily be the same as the task's parent
     /// task -- we may point to a super-parent if we know / that the parent
     /// does not "contribute" any task local values. This is to speed up
     /// lookups by skipping empty parent tasks during get(), and explained
     /// in depth in `createParentLink`.
-    IsParent = 0b11
-  };
-
-  /// Values must match `TaskLocalInheritance` declared in `TaskLocal.swift`.
-  enum class TaskLocalInheritance : uint8_t {
-    /// Default task local value behavior
-    ///
-    /// Values declared with a default-inherited key are accessible from:
-    /// - the current task that has bound the value,
-    /// - any child task of the current task (e.g. created by async let or groups)
-    ///
-    /// Such values are *not* carried through detached tasks.
-    Default = 0,
-
-    /// Special semantics which confine a task's local value to *only* the current
-    /// task. In other words, they ave never inherited by any child task created
-    /// by the current task.
-    ///
-    /// Values declared with a never-inherited key only accessible:
-    /// - specifically from the current task itself
-    ///
-    /// Such values are *not* accessible from child tasks or detached tasks.
-    Never   = 1
+    IsParent = 0b01,
   };
 
   class Item {
   private:
     /// Mask used for the low status bits in a task local chain item.
     static const uintptr_t statusMask = 0x03;
 
-    /// Pointer to the next task local item; be it in this task or in a parent.
-    /// Low bits encode `NextLinkType`.
-    /// Item *next = nullptr;
+    /// Pointer to one of the following:
+    /// - next task local item as OpaqueValue* if it is task-local allocated
+    /// - next task local item as HeapObject* if it is heap allocated "heavy"
+    /// - the parent task's TaskLocal::Storage
+    ///
+    /// Low bits encode `NextLinkType`, based on which the type of the pointer
+    /// is determined.
     uintptr_t next;
 
   public:
     /// The type of the key with which this value is associated.
-    const Metadata *keyType;
+    const HeapObject *key;
     /// The type of the value stored by this item.
     const Metadata *valueType;
 
     // Trailing storage for the value itself. The storage will be
     // uninitialized or contain an instance of \c valueType.
 
-  private:
+  protected:
     explicit Item()
       : next(0),
-        keyType(nullptr),
+        key(nullptr),
         valueType(nullptr) {}
 
-    explicit Item(const Metadata *keyType, const Metadata *valueType)
+    explicit Item(const HeapObject *key, const Metadata *valueType)
       : next(0),
-        keyType(keyType),
+        key(key),
         valueType(valueType) {}
 
   public:
@@ -116,7 +93,7 @@ class TaskLocal {
     static Item *createParentLink(AsyncTask *task, AsyncTask *parent);
 
     static Item *createLink(AsyncTask *task,
-                            const Metadata *keyType,
+                            const HeapObject *key,
                             const Metadata *valueType);
 
     void destroy(AsyncTask *task);
@@ -125,13 +102,13 @@ class TaskLocal {
       return reinterpret_cast<Item *>(next & ~statusMask);
     }
 
-    NextLinkType getNextLinkType() {
+    NextLinkType getNextLinkType() const {
       return static_cast<NextLinkType>(next & statusMask);
     }
 
     /// Item does not contain any actual value, and is only used to point at
     /// a specific parent item.
-    bool isEmpty() {
+    bool isEmpty() const {
       return !valueType;
     }
 
@@ -144,6 +121,7 @@ class TaskLocal {
     /// Compute the offset of the storage from the base of the item.
     static size_t storageOffset(const Metadata *valueType) {
       size_t offset = sizeof(Item);
+
       if (valueType) {
         size_t alignment = valueType->vw_alignment();
         return (offset + alignment - 1) & ~(alignment - 1);
@@ -162,7 +140,6 @@ class TaskLocal {
     }
   };
 
-
   class Storage {
     friend class TaskLocal::Item;
   private:
@@ -202,12 +179,10 @@ class TaskLocal {
     void initializeLinkParent(AsyncTask *task, AsyncTask *parent);
 
     void pushValue(AsyncTask *task,
-                   const Metadata *keyType,
+                   const HeapObject *key,
                    /* +1 */ OpaqueValue *value, const Metadata *valueType);
 
-    OpaqueValue* getValue(AsyncTask *task,
-                          const Metadata *keyType,
-                          TaskLocalInheritance inheritance);
+    OpaqueValue* getValue(AsyncTask *task, const HeapObject *key);
 
     void popValue(AsyncTask *task);
 

include/swift/AST/Attr.def

@@ -657,6 +657,12 @@ SIMPLE_DECL_ATTR(_inheritActorContext, InheritActorContext,
   ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIBreakingToRemove,
   116)
 
+CONTEXTUAL_SIMPLE_DECL_ATTR(spawn, Spawn,
+  DeclModifier | OnVar | ConcurrencyOnly |
+  ABIBreakingToAdd | ABIBreakingToRemove |
+  APIBreakingToAdd | APIBreakingToRemove,
+  117)
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/Attr.h

@@ -2077,9 +2077,10 @@ class CompletionHandlerAsyncAttr final : public DeclAttribute {
   CompletionHandlerAsyncAttr(AbstractFunctionDecl &asyncFunctionDecl,
                              size_t completionHandlerIndex,
                              SourceLoc completionHandlerIndexLoc,
-                             SourceLoc atLoc, SourceRange range)
+                             SourceLoc atLoc, SourceRange range,
+                             bool implicit)
       : DeclAttribute(DAK_CompletionHandlerAsync, atLoc, range,
-                      /*implicit*/ false),
+                      implicit),
         AsyncFunctionDecl(&asyncFunctionDecl) ,
         CompletionHandlerIndex(completionHandlerIndex),
         CompletionHandlerIndexLoc(completionHandlerIndexLoc) {}

include/swift/AST/Decl.h

@@ -1862,7 +1862,7 @@ class PatternBindingDecl final : public Decl,
   bool isComputingPatternBindingEntry(const VarDecl *vd) const;
 
   /// Is this an "async let" declaration?
-  bool isAsyncLet() const;
+  bool isSpawnLet() const;
 
   /// Gets the text of the initializer expression for the pattern entry at the
   /// given index, stripping out inactive branches of any #ifs inside the
@@ -4942,7 +4942,7 @@ class VarDecl : public AbstractStorageDecl {
   bool isLet() const { return getIntroducer() == Introducer::Let; }
 
   /// Is this an "async let" property?
-  bool isAsyncLet() const;
+  bool isSpawnLet() const;
 
   Introducer getIntroducer() const {
     return Introducer(Bits.VarDecl.Introducer);

include/swift/AST/DiagnosticsParse.def

@@ -966,6 +966,8 @@ ERROR(statement_begins_with_closure,none,
       "top-level statement cannot begin with a closure expression", ())
 ERROR(statement_same_line_without_semi,none,
       "consecutive statements on a line must be separated by ';'", ())
+ERROR(statement_same_line_without_newline,none,
+      "consecutive statements on a line must be separated by a newline", ())
 ERROR(invalid_label_on_stmt,none,
       "labels are only valid on loops, if, and switch statements", ())
 ERROR(labeled_block_needs_do,none,
@@ -1330,6 +1332,7 @@ ERROR(expr_selector_expected_rparen,PointsToFirstBadToken,
 ERROR(expr_dynamictype_deprecated,PointsToFirstBadToken,
       "'.dynamicType' is deprecated. Use 'type(of: ...)' instead", ())
 
+// '#assert'
 ERROR(pound_assert_disabled,PointsToFirstBadToken,
       "#assert is an experimental feature that is currently disabled", ())
 ERROR(pound_assert_expected_lparen,PointsToFirstBadToken,
@@ -1341,6 +1344,10 @@ ERROR(pound_assert_expected_expression,PointsToFirstBadToken,
 ERROR(pound_assert_expected_string_literal,PointsToFirstBadToken,
       "expected a string literal", ())
 
+// Postfix '#if' expressions.
+ERROR(expr_postfix_ifconfig_unexpectedtoken,none,
+      "unexpected tokens in '#if' expression body", ())
+
 //------------------------------------------------------------------------------
 // MARK: Attribute-parsing diagnostics
 //------------------------------------------------------------------------------

include/swift/AST/DiagnosticsSema.def

@@ -4231,8 +4231,8 @@ ERROR(throwing_interpolation_without_try,none,
       "interpolation can throw but is not marked with 'try'", ())
 ERROR(throwing_call_without_try,none,
       "call can throw but is not marked with 'try'", ())
-ERROR(throwing_async_let_without_try,none,
-      "reading 'async let' can throw but is not marked with 'try'", ())
+ERROR(throwing_spawn_let_without_try,none,
+      "reading 'spawn let' can throw but is not marked with 'try'", ())
 ERROR(throwing_prop_access_without_try,none,
       "property access can throw but is not marked with 'try'", ())
 ERROR(throwing_subscript_access_without_try,none,
@@ -4261,8 +4261,8 @@ NOTE(async_access_without_await,none,
 
 NOTE(async_call_without_await_in_autoclosure,none,
       "call is 'async' in an autoclosure argument", ())
-NOTE(async_call_without_await_in_async_let,none,
-      "call is 'async' in an 'async let' initializer", ())
+NOTE(async_call_without_await_in_spawn_let,none,
+      "call is 'async' in an 'spawn let' initializer", ())
 
 WARNING(no_async_in_await,none,
         "no 'async' operations occur within 'await' expression", ())
@@ -4275,7 +4275,7 @@ ERROR(await_in_illegal_context,none,
       "%select{<<ERROR>>|a default argument|a property wrapper initializer|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}0",
       (unsigned))
 ERROR(async_in_nonasync_function,none,
-      "%select{'async'|'async' call|'await'|'async let'|'async' property access|'async' subscript access}0 in "
+      "%select{'async'|'async' call|'await'|'spawn let'|'async' property access|'async' subscript access}0 in "
       "%select{a function|an autoclosure}1 that does not support concurrency",
       (unsigned, bool))
 NOTE(note_add_async_to_function,none,
@@ -4302,18 +4302,21 @@ NOTE(protocol_witness_async_conflict,none,
 ERROR(async_autoclosure_nonasync_function,none,
       "'async' autoclosure parameter in a non-'async' function", ())
 
-ERROR(async_not_let,none,
-      "'async' can only be used with 'let' declarations", ())
-ERROR(async_let_not_local,none,
-      "'async let' can only be used on local declarations", ())
-ERROR(async_let_not_initialized,none,
-      "'async let' binding requires an initializer expression", ())
-ERROR(async_let_no_variables,none,
-      "'async let' requires at least one named variable", ())
-NOTE(async_let_without_await,none,
-      "reference to async let %0 is 'async'", (DeclName))
-ERROR(async_let_in_illegal_context,none,
-      "async let %0 cannot be referenced in "
+WARNING(async_let_is_spawn_let,none,
+      "'async let' is now 'spawn let'", ())
+
+ERROR(spawn_not_let,none,
+      "'spawn' can only be used with 'let' declarations", ())
+ERROR(spawn_let_not_local,none,
+      "'spawn let' can only be used on local declarations", ())
+ERROR(spawn_let_not_initialized,none,
+      "'spawn let' binding requires an initializer expression", ())
+ERROR(spawn_let_no_variables,none,
+      "'spawn let' requires at least one named variable", ())
+NOTE(spawn_let_without_await,none,
+      "reference to spawn let %0 is 'async'", (DeclName))
+ERROR(spawn_let_in_illegal_context,none,
+      "spawn let %0 cannot be referenced in "
       "%select{<<ERROR>>|a default argument|a property wrapper initializer|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}1",
       (DeclName, unsigned))
 
@@ -4403,8 +4406,8 @@ ERROR(actor_isolated_from_concurrent_closure,none,
 ERROR(actor_isolated_from_concurrent_function,none,
         "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from a concurrent function",
         (DescriptiveDeclKind, DeclName, unsigned))
-ERROR(actor_isolated_from_async_let,none,
-        "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from 'async let' initializer",
+ERROR(actor_isolated_from_spawn_let,none,
+        "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from 'spawn let' initializer",
         (DescriptiveDeclKind, DeclName, unsigned))
 ERROR(actor_isolated_keypath_component,none,
       "cannot form key path to actor-isolated %0 %1",
@@ -5606,6 +5609,11 @@ ERROR(property_wrapper_dynamic_self_type, none,
       "property wrapper %select{wrapped value|projected value}0 cannot have "
       "dynamic Self type", (bool))
 
+ERROR(property_wrapper_var_must_be_static, none,
+      "property %0, must be static because property wrapper %1 can only "
+      "be applied to static properties",
+      (Identifier, Type))
+
 ERROR(property_wrapper_attribute_not_on_property, none,
       "property wrapper attribute %0 can only be applied to a property",
       (Identifier))