Merge pull request #2879 from swiftwasm/main

[pull] swiftwasm from main

Author: MaxDesiatov

docs/ABI/Mangling.rst

@@ -567,14 +567,14 @@ Types
   C-TYPE is mangled according to the Itanium ABI, and prefixed with the length.
   Non-ASCII identifiers are preserved as-is; we do not use Punycode.
 
-  function-signature ::= params-type params-type async? concurrent? throws? // results and parameters
+  function-signature ::= params-type params-type async? sendable? throws? // results and parameters
 
   params-type ::= type 'z'? 'h'?              // tuple in case of multiple parameters or a single parameter with a single tuple type
                                              // with optional inout convention, shared convention. parameters don't have labels,
                                              // they are mangled separately as part of the entity.
   params-type ::= empty-list                  // shortcut for no parameters
 
-  concurrent ::= 'J'                         // @concurrent on function types
+  sendable ::= 'J'                         // @Sendable on function types
   async ::= 'Y'                              // 'async' annotation on function types
   throws ::= 'K'                             // 'throws' annotation on function types
 
@@ -636,7 +636,7 @@ mangled in to disambiguate.
   impl-function-type ::= type* 'I' FUNC-ATTRIBUTES '_'
   impl-function-type ::= type* generic-signature 'I' FUNC-ATTRIBUTES '_'
 
-  FUNC-ATTRIBUTES ::= PATTERN-SUBS? INVOCATION-SUBS? PSEUDO-GENERIC? CALLEE-ESCAPE? DIFFERENTIABILITY-KIND? CALLEE-CONVENTION FUNC-REPRESENTATION? COROUTINE-KIND? CONCURRENT? ASYNC? (PARAM-CONVENTION PARAM-DIFFERENTIABILITY?)* RESULT-CONVENTION* ('Y' PARAM-CONVENTION)* ('z' RESULT-CONVENTION RESULT-DIFFERENTIABILITY?)?
+  FUNC-ATTRIBUTES ::= PATTERN-SUBS? INVOCATION-SUBS? PSEUDO-GENERIC? CALLEE-ESCAPE? DIFFERENTIABILITY-KIND? CALLEE-CONVENTION FUNC-REPRESENTATION? COROUTINE-KIND? SENDABLE? ASYNC? (PARAM-CONVENTION PARAM-DIFFERENTIABILITY?)* RESULT-CONVENTION* ('Y' PARAM-CONVENTION)* ('z' RESULT-CONVENTION RESULT-DIFFERENTIABILITY?)?
 
   PATTERN-SUBS ::= 's'                       // has pattern substitutions
   INVOCATION-SUB ::= 'I'                     // has invocation substitutions
@@ -666,7 +666,7 @@ mangled in to disambiguate.
   COROUTINE-KIND ::= 'A'                     // yield-once coroutine
   COROUTINE-KIND ::= 'G'                     // yield-many coroutine
 
-  CONCURRENT ::= 'h'                         // @concurrent
+  SENDABLE ::= 'h'                         // @Sendable
   ASYNC ::= 'H'                              // @async
 
   PARAM-CONVENTION ::= 'i'                   // indirect in

include/swift/ABI/Metadata.h

@@ -1657,7 +1657,7 @@ struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
   }
   bool isAsync() const { return Flags.isAsync(); }
   bool isThrowing() const { return Flags.isThrowing(); }
-  bool isConcurrent() const { return Flags.isConcurrent(); }
+  bool isSendable() const { return Flags.isSendable(); }
   bool hasParameterFlags() const { return Flags.hasParameterFlags(); }
   bool isEscaping() const { return Flags.isEscaping(); }
 

include/swift/ABI/MetadataValues.h

@@ -317,6 +317,7 @@ class MethodDescriptorFlags {
     KindMask = 0x0F,                // 16 kinds should be enough for anybody
     IsInstanceMask = 0x10,
     IsDynamicMask = 0x20,
+    IsSignedAsDataMask = 0x40,
     ExtraDiscriminatorShift = 16,
     ExtraDiscriminatorMask = 0xFFFF0000,
   };
@@ -345,6 +346,15 @@ class MethodDescriptorFlags {
     return copy;
   }
 
+  MethodDescriptorFlags withIsSignedAsData(bool isSignedAsData) const {
+    auto copy = *this;
+    if (isSignedAsData)
+      copy.Value |= IsSignedAsDataMask;
+    else
+      copy.Value &= ~IsSignedAsDataMask;
+    return copy;
+  }
+
   MethodDescriptorFlags withExtraDiscriminator(uint16_t value) const {
     auto copy = *this;
     copy.Value = (copy.Value & ~ExtraDiscriminatorMask)
@@ -362,6 +372,8 @@ class MethodDescriptorFlags {
   /// Note that 'init' is not considered an instance member.
   bool isInstance() const { return Value & IsInstanceMask; }
 
+  bool isSignedAsData() const { return Value & IsSignedAsDataMask; }
+
   uint16_t getExtraDiscriminator() const {
     return (Value >> ExtraDiscriminatorShift);
   }
@@ -527,6 +539,7 @@ class ProtocolRequirementFlags {
   enum : int_type {
     KindMask = 0x0F,                // 16 kinds should be enough for anybody
     IsInstanceMask = 0x10,
+    IsSignedAsDataMask = 0x20,
     ExtraDiscriminatorShift = 16,
     ExtraDiscriminatorMask = 0xFFFF0000,
   };
@@ -546,6 +559,15 @@ class ProtocolRequirementFlags {
     return copy;
   }
 
+  ProtocolRequirementFlags withIsSignedAsData(bool isSignedAsData) const {
+    auto copy = *this;
+    if (isSignedAsData)
+      copy.Value |= IsSignedAsDataMask;
+    else
+      copy.Value &= ~IsSignedAsDataMask;
+    return copy;
+  }
+
   ProtocolRequirementFlags withExtraDiscriminator(uint16_t value) const {
     auto copy = *this;
     copy.Value = (copy.Value & ~ExtraDiscriminatorMask)
@@ -560,6 +582,8 @@ class ProtocolRequirementFlags {
   /// Note that 'init' is not considered an instance member.
   bool isInstance() const { return Value & IsInstanceMask; }
 
+  bool isSignedAsData() const { return Value & IsSignedAsDataMask; }
+
   bool isSignedWithAddress() const {
     return getKind() != Kind::BaseProtocol;
   }
@@ -787,7 +811,7 @@ class TargetFunctionTypeFlags {
     DifferentiabilityMask  = 0x98000000U,
     DifferentiabilityShift = 27U,
     AsyncMask              = 0x20000000U,
-    ConcurrentMask         = 0x40000000U,
+    SendableMask           = 0x40000000U,
   };
   int_type Data;
 
@@ -837,10 +861,10 @@ class TargetFunctionTypeFlags {
   }
 
   constexpr TargetFunctionTypeFlags<int_type>
-  withConcurrent(bool isConcurrent) const {
+  withConcurrent(bool isSendable) const {
     return TargetFunctionTypeFlags<int_type>(
-        (Data & ~ConcurrentMask) |
-        (isConcurrent ? ConcurrentMask : 0));
+        (Data & ~SendableMask) |
+        (isSendable ? SendableMask : 0));
   }
 
   unsigned getNumParameters() const { return Data & NumParametersMask; }
@@ -857,8 +881,8 @@ class TargetFunctionTypeFlags {
     return bool (Data & EscapingMask);
   }
 
-  bool isConcurrent() const {
-    return bool (Data & ConcurrentMask);
+  bool isSendable() const {
+    return bool (Data & SendableMask);
   }
 
   bool hasParameterFlags() const { return bool(Data & ParamFlagsMask); }

include/swift/ABI/Task.h

@@ -483,10 +483,6 @@ class alignas(MaximumAlignment) AsyncContext {
   TaskContinuationFunction * __ptrauth_swift_async_context_resume
     ResumeParent;
 
-  /// The executor that the parent needs to be resumed on.
-  /// FIXME: remove this
-  ExecutorRef ResumeParentExecutor;
-
   /// Flags describing this context.
   ///
   /// Note that this field is only 32 bits; any alignment padding
@@ -499,7 +495,6 @@ class alignas(MaximumAlignment) AsyncContext {
                TaskContinuationFunction *resumeParent,
                AsyncContext *parent)
     : Parent(parent), ResumeParent(resumeParent),
-      ResumeParentExecutor(ExecutorRef::generic()),
       Flags(flags) {}
 
   AsyncContext(const AsyncContext &) = delete;

include/swift/AST/AnyFunctionRef.h

@@ -188,13 +188,13 @@ class AnyFunctionRef {
     return false;
   }
 
-  /// Whether this function is @concurrent.
-  bool isConcurrent() const {
+  /// Whether this function is @Sendable.
+  bool isSendable() const {
     if (!hasType())
       return false;
 
     if (auto *fnType = getType()->getAs<AnyFunctionType>())
-      return fnType->isConcurrent();
+      return fnType->isSendable();
 
     return false;
   }

include/swift/AST/Attr.def

@@ -54,7 +54,7 @@ TYPE_ATTR(escaping)
 TYPE_ATTR(differentiable)
 TYPE_ATTR(noDerivative)
 TYPE_ATTR(async)
-TYPE_ATTR(concurrent)
+TYPE_ATTR(Sendable)
 
 // SIL-specific attributes
 TYPE_ATTR(block_storage)
@@ -601,7 +601,7 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(async, Async,
   APIBreakingToAdd | APIBreakingToRemove,
   106)
 
-SIMPLE_DECL_ATTR(concurrent, Concurrent,
+SIMPLE_DECL_ATTR(Sendable, Sendable,
   OnFunc | OnConstructor | OnAccessor |
   ABIBreakingToAdd | ABIBreakingToRemove |
   APIBreakingToAdd | APIBreakingToRemove,

include/swift/AST/Decl.h

@@ -5738,8 +5738,8 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
 
   /// Determine whether the given function is concurrent.
   ///
-  /// A function is concurrent if it has the @concurrent attribute.
-  bool isConcurrent() const;
+  /// A function is concurrent if it has the @Sendable attribute.
+  bool isSendable() const;
 
   /// Returns true if the function is a suitable 'async' context.
   ///

include/swift/AST/DeclContext.h

@@ -160,7 +160,7 @@ enum class ConformanceLookupKind : unsigned {
   /// All conformances except for inherited ones.
   NonInherited,
   /// All conformances except structurally-derived conformances, of which
-  /// ConcurrentValue is the only one.
+  /// Sendable is the only one.
   NonStructural,
 };
 

include/swift/AST/DiagnosticEngine.h

@@ -29,6 +29,7 @@
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace swift {
@@ -640,6 +641,8 @@ namespace swift {
     /// Track which diagnostics should be ignored.
     llvm::BitVector ignoredDiagnostics;
 
+    friend class DiagnosticStateRAII;
+
   public:
     DiagnosticState();
 
@@ -740,6 +743,7 @@ namespace swift {
     friend class InFlightDiagnostic;
     friend class DiagnosticTransaction;
     friend class CompoundDiagnosticTransaction;
+    friend class DiagnosticStateRAII;
 
   public:
     explicit DiagnosticEngine(SourceManager &SourceMgr)
@@ -1053,6 +1057,33 @@ namespace swift {
     }
   };
 
+  /// Remember details about the state of a diagnostic engine and restore them
+  /// when the object is destroyed.
+  ///
+  /// Diagnostic engines contain state about the most recent diagnostic emitted
+  /// which influences subsequent emissions; in particular, if you try to emit
+  /// a note and the previous diagnostic was ignored, the note will be ignored
+  /// too. This can be a problem in code structured like:
+  ///
+  ///     D->diagnose(diag::an_error);
+  ///     if (conditionWhichMightEmitDiagnostics())
+  ///        D->diagnose(diag::a_note); // might be affected by diagnostics from
+  ///                                   // conditionWhichMightEmitDiagnostics()!
+  ///
+  /// To prevent this, functions which are called for their return values but
+  /// may emit diagnostics as a side effect can use \c DiagnosticStateRAII to
+  /// ensure that their changes to diagnostic engine state don't leak out and
+  /// affect the caller's diagnostics.
+  class DiagnosticStateRAII {
+    llvm::SaveAndRestore<DiagnosticBehavior> previousBehavior;
+
+  public:
+    DiagnosticStateRAII(DiagnosticEngine &diags)
+      : previousBehavior(diags.state.previousBehavior) {}
+
+    ~DiagnosticStateRAII() {}
+  };
+
   class BufferIndirectlyCausingDiagnosticRAII {
   private:
     DiagnosticEngine &Diags;

include/swift/AST/DiagnosticsSema.def

@@ -3825,18 +3825,18 @@ NOTE(generic_parameters_always_escaping,none,
 
 ERROR(passing_noattrfunc_to_attrfunc,none,
       "passing %select{non-escaping|non-concurrent}0 parameter %1 to function "
-      "expecting %select{an @escaping|a @concurrent}0 closure",
+      "expecting %select{an @escaping|a @Sendable}0 closure",
       (unsigned, Identifier))
 ERROR(converting_noespace_param_to_generic_type,none,
       "converting non-escaping parameter %0 to generic parameter %1 may allow it to escape",
       (Identifier, Type))
 ERROR(assigning_noattrfunc_to_attrfunc,none,
       "assigning %select{non-escaping|non-concurrent}0 parameter %1 to "
-      "%select{an @escaping|a @concurrent}0 closure",
+      "%select{an @escaping|a @Sendable}0 closure",
       (unsigned, Identifier))
 ERROR(general_noattrfunc_to_attr,none,
       "using %select{non-escaping|non-concurrent}0 parameter %1 in a context "
-      "expecting %select{an @escaping|a @concurrent}0 closure",
+      "expecting %select{an @escaping|a @Sendable}0 closure",
       (unsigned, Identifier))
 ERROR(converting_noattrfunc_to_type,none,
       "converting %select{non-escaping|non-concurrent function}0 value to %1 "
@@ -4371,7 +4371,7 @@ ERROR(actor_isolated_keypath_component,none,
       "cannot form key path to actor-isolated %0 %1",
       (DescriptiveDeclKind, DeclName))
 ERROR(local_function_executed_concurrently,none,
-      "concurrently-executed %0 %1 must be marked as '@concurrent'",
+      "concurrently-executed %0 %1 must be marked as '@Sendable'",
       (DescriptiveDeclKind, DeclName))
 ERROR(concurrent_access_of_local_capture,none,
       "%select{mutation of|reference to}0 captured %1 %2 in "
@@ -4404,37 +4404,37 @@ ERROR(global_actor_isolated_requirement_witness_conflict,none,
       (DescriptiveDeclKind, DeclName, Type, Identifier, Type))
 
 WARNING(non_concurrent_param_type,none,
-        "cannot pass argument of non-concurrent-value type %0 across actors",
+        "cannot pass argument of non-sendable type %0 across actors",
         (Type))
 WARNING(non_concurrent_result_type,none,
-        "cannot call function returning non-concurrent-value type %0 across "
+        "cannot call function returning non-sendable type %0 across "
         "actors", (Type))
 WARNING(non_concurrent_property_type,none,
-        "cannot use %0 %1 with a non-concurrent-value type %2 "
+        "cannot use %0 %1 with a non-sendable type %2 "
         "%select{across actors|from concurrently-executed code}3",
         (DescriptiveDeclKind, DeclName, Type, bool))
 WARNING(non_concurrent_keypath_capture,none,
-        "cannot form key path that captures non-concurrent-value type %0",
+        "cannot form key path that captures non-sendable type %0",
         (Type))
 WARNING(non_concurrent_keypath_access,none,
-        "cannot form key path that accesses non-concurrent-value type %0",
+        "cannot form key path that accesses non-sendable type %0",
         (Type))
 ERROR(non_concurrent_type_member,none,
       "%select{stored property %1|associated value %1}0 of "
-      "'ConcurrentValue'-conforming %2 %3 has non-concurrent-value type %4",
+      "'Sendable'-conforming %2 %3 has non-sendable type %4",
       (bool, DeclName, DescriptiveDeclKind, DeclName, Type))
 ERROR(concurrent_value_class_mutable_property,none,
-      "stored property %0 of 'ConcurrentValue'-conforming %1 %2 is mutable",
+      "stored property %0 of 'Sendable'-conforming %1 %2 is mutable",
       (DeclName, DescriptiveDeclKind, DeclName))
 ERROR(concurrent_value_outside_source_file,none,
-      "conformance to 'ConcurrentValue' must occur in the same source file as "
-      "%0 %1; use 'UnsafeConcurrentValue' for retroactive conformance",
+      "conformance to 'Sendable' must occur in the same source file as "
+      "%0 %1; use 'UnsafeSendable' for retroactive conformance",
       (DescriptiveDeclKind, DeclName))
 ERROR(concurrent_value_nonfinal_class,none,
-      "non-final class %0 cannot conform to `ConcurrentValue`; "
-      "use `UnsafeConcurrentValue`", (DeclName))
+      "non-final class %0 cannot conform to `Sendable`; "
+      "use `UnsafeSendable`", (DeclName))
 ERROR(concurrent_value_inherit,none,
-      "`ConcurrentValue` class %1 cannot inherit from another class"
+      "`Sendable` class %1 cannot inherit from another class"
       "%select{| other than 'NSObject'}0",
       (bool, DeclName))