Merge pull request #3048 from swiftwasm/main

[pull] swiftwasm from main

Author: MaxDesiatov

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/ASTContext.h

@@ -73,6 +73,7 @@ namespace swift {
   class DerivativeAttr;
   class DifferentiableAttr;
   class ExtensionDecl;
+  struct ExternalSourceLocs;
   class ForeignRepresentationInfo;
   class FuncDecl;
   class GenericContext;
@@ -1184,6 +1185,10 @@ class ASTContext final {
 
 private:
   friend Decl;
+
+  Optional<ExternalSourceLocs *> getExternalSourceLocs(const Decl *D);
+  void setExternalSourceLocs(const Decl *D, ExternalSourceLocs *Locs);
+
   Optional<std::pair<RawComment, bool>> getRawComment(const Decl *D);
   void setRawComment(const Decl *D, RawComment RC, bool FromSerialized);
 

include/swift/AST/Attr.def

@@ -625,7 +625,7 @@ SIMPLE_DECL_ATTR(reasync, AtReasync,
   110)
 
 DECL_ATTR(completionHandlerAsync, CompletionHandlerAsync,
-  OnAbstractFunction | ConcurrencyOnly | LongAttribute |
+  OnAbstractFunction | ConcurrencyOnly | LongAttribute | UserInaccessible |
   ABIStableToAdd | ABIStableToRemove |
   APIStableToAdd | APIStableToRemove,
   111)

include/swift/AST/Decl.h

@@ -62,6 +62,7 @@ namespace swift {
   class DynamicSelfType;
   class Type;
   class Expr;
+  struct ExternalSourceLocs;
   class CaptureListExpr;
   class DeclRefExpr;
   class ForeignAsyncConvention;
@@ -688,14 +689,12 @@ class alignas(1 << DeclAlignInBits) Decl {
   void operator=(const Decl&) = delete;
   SourceLoc getLocFromSource() const;
 
-  struct CachedExternalSourceLocs {
-    SourceLoc Loc;
-    SourceLoc StartLoc;
-    SourceLoc EndLoc;
-    SmallVector<CharSourceRange, 4> DocRanges;
-  };
-  mutable CachedExternalSourceLocs const *CachedSerializedLocs = nullptr;
-  const CachedExternalSourceLocs *getSerializedLocs() const;
+  /// Returns the serialized locations of this declaration from the
+  /// corresponding .swiftsourceinfo file. "Empty" (ie. \c BufferID of 0, an
+  /// invalid \c Loc, and empty \c DocRanges) if either there is no
+  /// .swiftsourceinfo or the buffer could not be created, eg. if the file
+  /// no longer exists.
+  const ExternalSourceLocs *getSerializedLocs() const;
 
   /// Directly set the invalid bit
   void setInvalidBit();

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

@@ -5606,6 +5606,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))

include/swift/AST/FileUnit.h

@@ -164,7 +164,8 @@ class FileUnit : public DeclContext {
     return None;
   }
 
-  virtual Optional<BasicDeclLocs> getBasicLocsForDecl(const Decl *D) const {
+  virtual Optional<ExternalSourceLocs::RawLocs>
+  getExternalRawLocsForDecl(const Decl *D) const {
     return None;
   }
 

include/swift/AST/KnownSDKTypes.def

@@ -40,4 +40,6 @@ KNOWN_SDK_TYPE_DECL(ObjectiveC, ObjCBool, StructDecl, 0)
 KNOWN_SDK_TYPE_DECL(Concurrency, UnsafeContinuation, NominalTypeDecl, 2)
 KNOWN_SDK_TYPE_DECL(Concurrency, MainActor, NominalTypeDecl, 0)
 
+KNOWN_SDK_TYPE_DECL(Concurrency, TaskLocal, ClassDecl, 1)
+
 #undef KNOWN_SDK_TYPE_DECL

include/swift/AST/PropertyWrappers.h

@@ -88,6 +88,10 @@ struct PropertyWrapperTypeInfo {
   /// ability to reason about the enclosing "self".
   SubscriptDecl *enclosingInstanceProjectedSubscript = nullptr;
 
+  /// Forces that the property wrapper must be declared on a static, or
+  /// global–once supported–property.
+  bool requireNoEnclosingInstance = false;
+
   ///
   /// Whether this is a valid property wrapper.
   bool isValid() const {