Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

docs/ABI/Mangling.rst

@@ -556,13 +556,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? throws? // results and parameters
+  function-signature ::= params-type params-type async? concurrent? 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
   async ::= 'Y'                              // 'async' annotation on function types
   throws ::= 'K'                             // 'throws' annotation on function types
 

include/swift/ABI/Metadata.h

@@ -1637,6 +1637,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 hasParameterFlags() const { return Flags.hasParameterFlags(); }
   bool isEscaping() const { return Flags.isEscaping(); }
 

include/swift/ABI/MetadataValues.h

@@ -779,6 +779,7 @@ class TargetFunctionTypeFlags {
     DifferentiableMask = 0x08000000U,
     LinearMask        = 0x10000000U,
     AsyncMask         = 0x20000000U,
+    ConcurrentMask    = 0x40000000U,
   };
   int_type Data;
 
@@ -831,6 +832,13 @@ class TargetFunctionTypeFlags {
                                              (isEscaping ? EscapingMask : 0));
   }
 
+  constexpr TargetFunctionTypeFlags<int_type>
+  withConcurrent(bool isConcurrent) const {
+    return TargetFunctionTypeFlags<int_type>(
+        (Data & ~ConcurrentMask) |
+        (isConcurrent ? ConcurrentMask : 0));
+  }
+
   unsigned getNumParameters() const { return Data & NumParametersMask; }
 
   FunctionMetadataConvention getConvention() const {
@@ -845,6 +853,10 @@ class TargetFunctionTypeFlags {
     return bool (Data & EscapingMask);
   }
 
+  bool isConcurrent() const {
+    return bool (Data & ConcurrentMask);
+  }
+
   bool hasParameterFlags() const { return bool(Data & ParamFlagsMask); }
 
   bool isDifferentiable() const {

include/swift/AST/Attr.def

@@ -54,6 +54,7 @@ TYPE_ATTR(escaping)
 TYPE_ATTR(differentiable)
 TYPE_ATTR(noDerivative)
 TYPE_ATTR(async)
+TYPE_ATTR(concurrent)
 
 // SIL-specific attributes
 TYPE_ATTR(block_storage)
@@ -599,6 +600,12 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(async, Async,
   APIBreakingToAdd | APIBreakingToRemove,
   106)
 
+SIMPLE_DECL_ATTR(concurrent, Concurrent,
+  OnFunc | OnConstructor | OnAccessor | ConcurrencyOnly |
+  ABIStableToAdd | ABIStableToRemove |
+  APIBreakingToAdd | APIBreakingToRemove,
+  107)
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/Decl.h

@@ -5773,6 +5773,11 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// type of the function will be `async` as well.
   bool hasAsync() const { return Bits.AbstractFunctionDecl.Async; }
 
+  /// Determine whether the given function is concurrent.
+  ///
+  /// A function is concurrent if it has the @concurrent attribute.
+  bool isConcurrent() const;
+
   /// Returns true if the function is a suitable 'async' context.
   ///
   /// Functions that are an 'async' context can make calls to 'async' functions.

include/swift/AST/DiagnosticsSema.def

@@ -3727,26 +3727,30 @@ NOTE(silence_debug_description_in_interpolation_segment_call,none,
      "use 'String(describing:)' to silence this warning", ())
 
 NOTE(noescape_parameter,none,
-    "parameter %0 is implicitly non-escaping",
-     (Identifier))
+    "parameter %1 is implicitly %select{non-escaping|non-concurrent}0",
+     (unsigned, Identifier))
 NOTE(generic_parameters_always_escaping,none,
      "generic parameters are always considered '@escaping'", ())
 
-ERROR(passing_noescape_to_escaping,none,
-      "passing non-escaping parameter %0 to function expecting an @escaping closure",
-      (Identifier))
+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",
+      (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_noescape_to_escaping,none,
-      "assigning non-escaping parameter %0 to an @escaping closure",
-      (Identifier))
-ERROR(general_noescape_to_escaping,none,
-      "using non-escaping parameter %0 in a context expecting an @escaping closure",
-      (Identifier))
-ERROR(converting_noescape_to_type,none,
-      "converting non-escaping value to %0 may allow it to escape",
-      (Type))
+ERROR(assigning_noattrfunc_to_attrfunc,none,
+      "assigning %select{non-escaping|non-concurrent}0 parameter %1 to "
+      "%select{an @escaping|a @concurrent}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",
+      (unsigned, Identifier))
+ERROR(converting_noattrfunc_to_type,none,
+      "converting %select{non-escaping|non-concurrent function}0 value to %1 "
+      "may %select{allow it to escape|introduce data races}0",
+      (unsigned, Type))
 
 ERROR(capture_across_type_decl,none,
       "%0 declaration cannot close over value %1 defined in outer scope",
@@ -4256,10 +4260,23 @@ WARNING(concurrent_access_local,none,
         "local %0 %1 is unsafe to reference in code that may execute "
         "concurrently",
         (DescriptiveDeclKind, DeclName))
-ERROR(actor_isolated_concurrent_access,none,
-        "actor-isolated %0 %1 is unsafe to reference in code "
-        "that may execute concurrently",
+ERROR(actor_isolated_from_concurrent_closure,none,
+        "actor-isolated %0 %1 cannot be referenced from a concurrent closure",
+        (DescriptiveDeclKind, DeclName))
+ERROR(actor_isolated_from_concurrent_function,none,
+        "actor-isolated %0 %1 cannot be referenced from a concurrent function",
+        (DescriptiveDeclKind, DeclName))
+ERROR(actor_isolated_from_async_let,none,
+        "actor-isolated %0 %1 cannot be referenced from 'async let' initializer",
         (DescriptiveDeclKind, DeclName))
+ERROR(actor_isolated_from_escaping_closure,none,
+        "actor-isolated %0 %1 cannot be referenced from an '@escaping' closure",
+        (DescriptiveDeclKind, DeclName))
+ERROR(local_function_executed_concurrently,none,
+      "concurrently-executed %0 %1 must be marked as '@concurrent'",
+      (DescriptiveDeclKind, DeclName))
+NOTE(concurrent_access_here,none,
+     "access in concurrently-executed code here", ())
 NOTE(actor_isolated_sync_func,none,
      "calls to %0 %1 from outside of its actor context are "
      "implicitly asynchronous",

include/swift/AST/ExtInfo.h

@@ -289,20 +289,21 @@ class ASTExtInfoBuilder {
   friend AnyFunctionType;
   friend ASTExtInfo;
 
-  // If bits are added or removed, then TypeBase::AnyFunctionTypeBits
+  // If bits are added or removed, then TypeBase::NumAFTExtInfoBits
   // and NumMaskBits must be updated, and they must match.
   //
-  //   |representation|noEscape|async|throws|differentiability|
-  //   |    0 .. 3    |    4   |  5  |   6  |      7 .. 8     |
+  //   |representation|noEscape|concurrent|async|throws|differentiability|
+  //   |    0 .. 3    |    4   |    5     |  6  |   7  |      8 .. 9     |
   //
   enum : unsigned {
     RepresentationMask = 0xF << 0,
     NoEscapeMask = 1 << 4,
-    AsyncMask = 1 << 5,
-    ThrowsMask = 1 << 6,
-    DifferentiabilityMaskOffset = 7,
+    ConcurrentMask = 1 << 5,
+    AsyncMask = 1 << 6,
+    ThrowsMask = 1 << 7,
+    DifferentiabilityMaskOffset = 8,
     DifferentiabilityMask = 0x3 << DifferentiabilityMaskOffset,
-    NumMaskBits = 9
+    NumMaskBits = 10
   };
 
   unsigned bits; // Naturally sized for speed.
@@ -350,6 +351,8 @@ class ASTExtInfoBuilder {
 
   constexpr bool isNoEscape() const { return bits & NoEscapeMask; }
 
+  constexpr bool isConcurrent() const { return bits & ConcurrentMask; }
+
   constexpr bool isAsync() const { return bits & AsyncMask; }
 
   constexpr bool isThrowing() const { return bits & ThrowsMask; }
@@ -407,6 +410,12 @@ class ASTExtInfoBuilder {
                              clangTypeInfo);
   }
   LLVM_NODISCARD
+  ASTExtInfoBuilder withConcurrent(bool concurrent = true) const {
+    return ASTExtInfoBuilder(concurrent ? (bits | ConcurrentMask)
+                                        : (bits & ~ConcurrentMask),
+                             clangTypeInfo);
+  }
+  LLVM_NODISCARD
   ASTExtInfoBuilder withAsync(bool async = true) const {
     return ASTExtInfoBuilder(async ? (bits | AsyncMask)
                                    : (bits & ~AsyncMask),
@@ -497,6 +506,8 @@ class ASTExtInfo {
 
   constexpr bool isNoEscape() const { return builder.isNoEscape(); }
 
+  constexpr bool isConcurrent() const { return builder.isConcurrent(); }
+
   constexpr bool isAsync() const { return builder.isAsync(); }
 
   constexpr bool isThrowing() const { return builder.isThrowing(); }
@@ -529,6 +540,14 @@ class ASTExtInfo {
     return builder.withNoEscape(noEscape).build();
   }
 
+  /// Helper method for changing only the concurrent field.
+  ///
+  /// Prefer using \c ASTExtInfoBuilder::withConcurrent for chaining.
+  LLVM_NODISCARD
+  ASTExtInfo withConcurrent(bool concurrent = true) const {
+    return builder.withConcurrent(concurrent).build();
+  }
+
   /// Helper method for changing only the throws field.
   ///
   /// Prefer using \c ASTExtInfoBuilder::withThrows for chaining.

include/swift/AST/TypeMatcher.h

@@ -208,6 +208,9 @@ class TypeMatcher {
         if (firstFunc->isNoEscape() != secondFunc->isNoEscape())
           return mismatch(firstFunc.getPointer(), secondFunc, sugaredFirstType);
 
+        if (firstFunc->isConcurrent() != secondFunc->isConcurrent())
+          return mismatch(firstFunc.getPointer(), secondFunc, sugaredFirstType);
+
         auto sugaredFirstFunc = sugaredFirstType->castTo<AnyFunctionType>();
         if (firstFunc->getParams().size() != secondFunc->getParams().size())
           return mismatch(firstFunc.getPointer(), secondFunc, sugaredFirstFunc);

include/swift/AST/Types.h

@@ -315,7 +315,7 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   }
 
 protected:
-  enum { NumAFTExtInfoBits = 9 };
+  enum { NumAFTExtInfoBits = 10 };
   enum { NumSILExtInfoBits = 9 };
   union { uint64_t OpaqueBits;
 
@@ -3145,6 +3145,10 @@ class AnyFunctionType : public TypeBase {
     return getExtInfo().isNoEscape();
   }
 
+  bool isConcurrent() const {
+    return getExtInfo().isConcurrent();
+  }
+
   bool isAsync() const { return getExtInfo().isAsync(); }
 
   bool isThrowing() const { return getExtInfo().isThrowing(); }

include/swift/Demangling/DemangleNodes.def

@@ -85,6 +85,7 @@ NODE(EnumCase)
 NODE(ErrorType)
 NODE(EscapingAutoClosureType)
 NODE(NoEscapeFunctionType)
+NODE(ConcurrentFunctionType)
 NODE(ExistentialMetatype)
 CONTEXT_NODE(ExplicitClosure)
 CONTEXT_NODE(Extension)

include/swift/Demangling/TypeDecoder.h

@@ -645,14 +645,22 @@ class TypeDecoder {
         ++firstChildIdx;
       }
 
+      bool isConcurrent = false;
+      if (Node->getChild(firstChildIdx)->getKind()
+            == NodeKind::ConcurrentFunctionType) {
+        isConcurrent = true;
+        ++firstChildIdx;
+      }
+
       bool isAsync = false;
       if (Node->getChild(firstChildIdx)->getKind()
             == NodeKind::AsyncAnnotation) {
         isAsync = true;
         ++firstChildIdx;
       }
 
-      flags = flags.withAsync(isAsync).withThrows(isThrow);
+      flags = flags.withConcurrent(isConcurrent)
+          .withAsync(isAsync).withThrows(isThrow);
 
       if (Node->getNumChildren() < firstChildIdx + 2)
         return MAKE_NODE_TYPE_ERROR(Node,

include/swift/Sema/CSFix.h

@@ -615,6 +615,26 @@ class ForceOptional final : public ContextualMismatch {
                                ConstraintLocator *locator);
 };
 
+/// This is a contextual mismatch between @concurrent and non-@concurrent
+/// function types, repair it by adding @concurrent attribute.
+class AddConcurrentAttribute final : public ContextualMismatch {
+  AddConcurrentAttribute(ConstraintSystem &cs, FunctionType *fromType,
+                     FunctionType *toType, ConstraintLocator *locator)
+      : ContextualMismatch(cs, fromType, toType, locator) {
+    assert(fromType->isConcurrent() != toType->isConcurrent());
+  }
+
+public:
+  std::string getName() const override { return "add '@concurrent' attribute"; }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  static AddConcurrentAttribute *create(ConstraintSystem &cs,
+                                    FunctionType *fromType,
+                                    FunctionType *toType,
+                                    ConstraintLocator *locator);
+};
+
 /// This is a contextual mismatch between throwing and non-throwing
 /// function types, repair it by dropping `throws` attribute.
 class DropThrowsAttribute final : public ContextualMismatch {

include/swift/Sema/ConstraintLocator.h

@@ -741,7 +741,7 @@ class LocatorPathElt::PatternMatch final : public StoredPointerElement<Pattern>
 
 class LocatorPathElt::ArgumentAttribute final : public StoredIntegerElement<1> {
 public:
-  enum Attribute : uint8_t { InOut, Escaping };
+  enum Attribute : uint8_t { InOut, Escaping, Concurrent };
 
 private:
   ArgumentAttribute(Attribute attr)
@@ -758,6 +758,10 @@ class LocatorPathElt::ArgumentAttribute final : public StoredIntegerElement<1> {
     return ArgumentAttribute(Attribute::Escaping);
   }
 
+  static ArgumentAttribute forConcurrent() {
+    return ArgumentAttribute(Attribute::Concurrent);
+  }
+
   static bool classof(const LocatorPathElt *elt) {
     return elt->getKind() == ConstraintLocator::ArgumentAttribute;
   }

lib/AST/ASTDumper.cpp

@@ -2531,6 +2531,8 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
       if (auto fType = Ty->getAs<AnyFunctionType>()) {
         if (!fType->getExtInfo().isNoEscape())
           PrintWithColorRAII(OS, ClosureModifierColor) << " escaping";
+        if (fType->getExtInfo().isConcurrent())
+          PrintWithColorRAII(OS, ClosureModifierColor) << " concurrent";
       }
     }
 
@@ -3810,6 +3812,7 @@ namespace {
                    getSILFunctionTypeRepresentationString(representation));
 
       printFlag(!T->isNoEscape(), "escaping");
+      printFlag(T->isConcurrent(), "concurrent");
       printFlag(T->isAsync(), "async");
       printFlag(T->isThrowing(), "throws");
 

lib/AST/ASTMangler.cpp

@@ -2377,6 +2377,8 @@ void ASTMangler::appendFunctionSignature(AnyFunctionType *fn,
   appendFunctionInputType(fn->getParams(), forDecl);
   if (fn->isAsync() || functionMangling == AsyncHandlerBodyMangling)
     appendOperator("Y");
+  if (fn->isConcurrent())
+    appendOperator("J");
   if (fn->isThrowing())
     appendOperator("K");
 }

lib/AST/ASTPrinter.cpp

@@ -4160,6 +4160,11 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       }
     }
 
+    if (!Options.excludeAttrKind(TAK_concurrent) &&
+        info.isConcurrent()) {
+      Printer << "@concurrent ";
+    }
+
     SmallString<64> buf;
     switch (Options.PrintFunctionRepresentationAttrs) {
     case PrintOptions::FunctionRepresentationMode::None: