[Concurrent] Introduce concurrent function types.

Introduce `@concurrent` attribute on function types, including:
* Parsing as a type attribute
* (De-/re-/)mangling for concurrent function types
* Implicit conversion from @Concurrent to non-@Concurrent
- (De-)serialization for concurrent function types
- AST printing and dumping support

Author: DougGregor

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)

include/swift/AST/DiagnosticsSema.def

@@ -3724,26 +3724,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",

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,