[SIL] Add @Concurrent function types to SIL

DougGregor · DougGregor · commit 99f8d7a5e8cc · 2021-01-29T11:16:17.000-08:00
Add @Concurrent to SIL function types, mirroring what's available on AST function types. @Concurrent function types will have by-value capture semantics.
diff --git a/docs/ABI/Mangling.rst b/docs/ABI/Mangling.rst
@@ -625,7 +625,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? 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? CONCURRENT? 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
@@ -654,6 +654,7 @@ mangled in to disambiguate.
   COROUTINE-KIND ::= 'A'                     // yield-once coroutine
   COROUTINE-KIND ::= 'G'                     // yield-many coroutine
 
+  CONCURRENT ::= 'h'                         // @concurrent
   ASYNC ::= 'H'                              // @async
 
   PARAM-CONVENTION ::= 'i'                   // indirect in
diff --git a/include/swift/AST/ExtInfo.h b/include/swift/AST/ExtInfo.h
@@ -615,17 +615,18 @@ class SILExtInfoBuilder {
   // If bits are added or removed, then TypeBase::SILFunctionTypeBits
   // and NumMaskBits must be updated, and they must match.
 
-  //   |representation|pseudogeneric| noescape | async | differentiability|
-  //   |    0 .. 3    |      4      |     5    |   6   |      7 .. 8     |
+  //   |representation|pseudogeneric| noescape | concurrent | async | differentiability|
+  //   |    0 .. 3    |      4      |     5    |     6      |   7   |      8 .. 9     |
   //
   enum : unsigned {
     RepresentationMask = 0xF << 0,
     PseudogenericMask = 1 << 4,
     NoEscapeMask = 1 << 5,
-    AsyncMask = 1 << 6,
-    DifferentiabilityMaskOffset = 7,
+    ConcurrentMask = 1 << 6,
+    AsyncMask = 1 << 7,
+    DifferentiabilityMaskOffset = 8,
     DifferentiabilityMask = 0x3 << DifferentiabilityMaskOffset,
-    NumMaskBits = 9
+    NumMaskBits = 10
   };
 
   unsigned bits; // Naturally sized for speed.
@@ -639,10 +640,13 @@ class SILExtInfoBuilder {
       : bits(bits), clangTypeInfo(clangTypeInfo.getCanonical()) {}
 
   static constexpr unsigned makeBits(Representation rep, bool isPseudogeneric,
-                                     bool isNoEscape, bool isAsync,
+                                     bool isNoEscape, bool isConcurrent,
+                                     bool isAsync,
                                      DifferentiabilityKind diffKind) {
     return ((unsigned)rep) | (isPseudogeneric ? PseudogenericMask : 0) |
-           (isNoEscape ? NoEscapeMask : 0) | (isAsync ? AsyncMask : 0) |
+           (isNoEscape ? NoEscapeMask : 0) |
+           (isConcurrent ? ConcurrentMask : 0) |
+           (isAsync ? AsyncMask : 0) |
            (((unsigned)diffKind << DifferentiabilityMaskOffset) &
             DifferentiabilityMask);
   }
@@ -652,21 +656,22 @@ class SILExtInfoBuilder {
   /// non-pseudogeneric, non-differentiable.
   SILExtInfoBuilder()
       : SILExtInfoBuilder(makeBits(SILFunctionTypeRepresentation::Thick, false,
-                                   false, false,
+                                   false, false, false,
                                    DifferentiabilityKind::NonDifferentiable),
                           ClangTypeInfo(nullptr)) {}
 
   SILExtInfoBuilder(Representation rep, bool isPseudogeneric, bool isNoEscape,
-                    bool isAsync, DifferentiabilityKind diffKind,
-                    const clang::Type *type)
-      : SILExtInfoBuilder(makeBits(rep, isPseudogeneric, isNoEscape, isAsync,
-                                   diffKind),
+                    bool isConcurrent, bool isAsync,
+                    DifferentiabilityKind diffKind, const clang::Type *type)
+      : SILExtInfoBuilder(makeBits(rep, isPseudogeneric, isNoEscape,
+                                   isConcurrent, isAsync, diffKind),
                           ClangTypeInfo(type)) {}
 
   // Constructor for polymorphic type.
   SILExtInfoBuilder(ASTExtInfoBuilder info, bool isPseudogeneric)
       : SILExtInfoBuilder(makeBits(info.getSILRepresentation(), isPseudogeneric,
-                                   info.isNoEscape(), info.isAsync(),
+                                   info.isNoEscape(), info.isConcurrent(),
+                                   info.isAsync(),
                                    info.getDifferentiabilityKind()),
                           info.getClangTypeInfo()) {}
 
@@ -691,6 +696,8 @@ class SILExtInfoBuilder {
   // Is this function guaranteed to be no-escape by the type system?
   constexpr bool isNoEscape() const { return bits & NoEscapeMask; }
 
+  constexpr bool isConcurrent() const { return bits & ConcurrentMask; }
+
   constexpr bool isAsync() const { return bits & AsyncMask; }
 
   constexpr DifferentiabilityKind getDifferentiabilityKind() const {
@@ -760,6 +767,12 @@ class SILExtInfoBuilder {
                              clangTypeInfo);
   }
   LLVM_NODISCARD
+  SILExtInfoBuilder withConcurrent(bool isConcurrent = true) const {
+    return SILExtInfoBuilder(isConcurrent ? (bits | ConcurrentMask)
+                                          : (bits & ~ConcurrentMask),
+                             clangTypeInfo);
+  }
+  LLVM_NODISCARD
   SILExtInfoBuilder withAsync(bool isAsync = true) const {
     return SILExtInfoBuilder(isAsync ? (bits | AsyncMask) : (bits & ~AsyncMask),
                              clangTypeInfo);
@@ -822,7 +835,7 @@ class SILExtInfo {
   /// A default ExtInfo but with a Thin convention.
   static SILExtInfo getThin() {
     return SILExtInfoBuilder(SILExtInfoBuilder::Representation::Thin, false,
-                             false, false,
+                             false, false, false,
                              DifferentiabilityKind::NonDifferentiable, nullptr)
         .build();
   }
@@ -846,6 +859,8 @@ class SILExtInfo {
 
   constexpr bool isNoEscape() const { return builder.isNoEscape(); }
 
+  constexpr bool isConcurrent() const { return builder.isConcurrent(); }
+
   constexpr bool isAsync() const { return builder.isAsync(); }
 
   constexpr DifferentiabilityKind getDifferentiabilityKind() const {
@@ -874,6 +889,9 @@ class SILExtInfo {
     return builder.withNoEscape(noEscape).build();
   }
   
+  SILExtInfo withConcurrent(bool isConcurrent = true) const {
+    return builder.withConcurrent(isConcurrent).build();
+  }
 
   SILExtInfo withAsync(bool isAsync = true) const {
     return builder.withAsync(isAsync).build();
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -316,7 +316,7 @@ class alignas(1 << TypeAlignInBits) TypeBase {
 
 protected:
   enum { NumAFTExtInfoBits = 10 };
-  enum { NumSILExtInfoBits = 9 };
+  enum { NumSILExtInfoBits = 10 };
   union { uint64_t OpaqueBits;
 
   SWIFT_INLINE_BITFIELD_BASE(TypeBase, bitmax(NumTypeKindBits,8) +
@@ -4120,6 +4120,7 @@ class SILFunctionType final
     return SILCoroutineKind(Bits.SILFunctionType.CoroutineKind);
   }
 
+  bool isConcurrent() const { return getExtInfo().isConcurrent(); }
   bool isAsync() const { return getExtInfo().isAsync(); }
 
   /// Return the array of all the yields.
diff --git a/include/swift/Demangling/TypeDecoder.h b/include/swift/Demangling/TypeDecoder.h
@@ -240,52 +240,61 @@ class ImplFunctionTypeFlags {
   unsigned Rep : 3;
   unsigned Pseudogeneric : 1;
   unsigned Escaping : 1;
+  unsigned Concurrent : 1;
   unsigned Async : 1;
   unsigned DifferentiabilityKind : 2;
 
 public:
   ImplFunctionTypeFlags()
-      : Rep(0), Pseudogeneric(0), Escaping(0), Async(0),
+      : Rep(0), Pseudogeneric(0), Escaping(0), Concurrent(0), Async(0),
         DifferentiabilityKind(0) {}
 
   ImplFunctionTypeFlags(ImplFunctionRepresentation rep, bool pseudogeneric,
-                        bool noescape, bool async,
+                        bool noescape, bool concurrent, bool async,
                         ImplFunctionDifferentiabilityKind diffKind)
       : Rep(unsigned(rep)), Pseudogeneric(pseudogeneric), Escaping(noescape),
-        Async(async), DifferentiabilityKind(unsigned(diffKind)) {}
+        Concurrent(concurrent), Async(async),
+        DifferentiabilityKind(unsigned(diffKind)) {}
 
   ImplFunctionTypeFlags
   withRepresentation(ImplFunctionRepresentation rep) const {
     return ImplFunctionTypeFlags(
-        rep, Pseudogeneric, Escaping, Async,
+        rep, Pseudogeneric, Escaping, Concurrent, Async,
         ImplFunctionDifferentiabilityKind(DifferentiabilityKind));
   }
 
   ImplFunctionTypeFlags
-  withAsync() const {
+  withConcurrent() const {
     return ImplFunctionTypeFlags(
         ImplFunctionRepresentation(Rep), Pseudogeneric, Escaping, true,
-        ImplFunctionDifferentiabilityKind(DifferentiabilityKind));
+        Async, ImplFunctionDifferentiabilityKind(DifferentiabilityKind));
+  }
+
+  ImplFunctionTypeFlags
+  withAsync() const {
+    return ImplFunctionTypeFlags(
+        ImplFunctionRepresentation(Rep), Pseudogeneric, Escaping, Concurrent,
+        true, ImplFunctionDifferentiabilityKind(DifferentiabilityKind));
   }
 
   ImplFunctionTypeFlags
   withEscaping() const {
     return ImplFunctionTypeFlags(
-        ImplFunctionRepresentation(Rep), Pseudogeneric, true, Async,
+        ImplFunctionRepresentation(Rep), Pseudogeneric, true, Concurrent, Async,
         ImplFunctionDifferentiabilityKind(DifferentiabilityKind));
   }
   
   ImplFunctionTypeFlags
   withPseudogeneric() const {
     return ImplFunctionTypeFlags(
-        ImplFunctionRepresentation(Rep), true, Escaping, Async,
+        ImplFunctionRepresentation(Rep), true, Escaping, Concurrent, Async,
         ImplFunctionDifferentiabilityKind(DifferentiabilityKind));
   }
 
   ImplFunctionTypeFlags
   withDifferentiabilityKind(ImplFunctionDifferentiabilityKind diffKind) const {
     return ImplFunctionTypeFlags(ImplFunctionRepresentation(Rep), Pseudogeneric,
-                                 Escaping, Async, diffKind);
+                                 Escaping, Concurrent, Async, diffKind);
   }
 
   ImplFunctionRepresentation getRepresentation() const {
@@ -296,6 +305,8 @@ class ImplFunctionTypeFlags {
 
   bool isEscaping() const { return Escaping; }
 
+  bool isConcurrent() const { return Concurrent; }
+
   bool isPseudogeneric() const { return Pseudogeneric; }
 
   ImplFunctionDifferentiabilityKind getDifferentiabilityKind() const {
@@ -731,7 +742,9 @@ class TypeDecoder {
         } else if (child->getKind() == NodeKind::ImplFunctionAttribute) {
           if (!child->hasText())
             return MAKE_NODE_TYPE_ERROR0(child, "expected text");
-          if (child->getText() == "@async") {
+          if (child->getText() == "@concurrent") {
+            flags = flags.withConcurrent();
+          } else if (child->getText() == "@async") {
             flags = flags.withAsync();
           }
         } else if (child->getKind() == NodeKind::ImplDifferentiable) {
diff --git a/include/swift/Reflection/TypeRefBuilder.h b/include/swift/Reflection/TypeRefBuilder.h
@@ -443,6 +443,7 @@ class TypeRefBuilder {
       break;
     }
 
+    funcFlags = funcFlags.withConcurrent(flags.isConcurrent());
     funcFlags = funcFlags.withAsync(flags.isAsync());
 
     auto result = createTupleType({}, "");
diff --git a/lib/AST/ASTDemangler.cpp b/lib/AST/ASTDemangler.cpp
@@ -559,7 +559,7 @@ Type ASTBuilder::createImplFunctionType(
   }
   auto einfo = SILFunctionType::ExtInfoBuilder(
                    representation, flags.isPseudogeneric(), !flags.isEscaping(),
-                   flags.isAsync(), diffKind, clangFnType)
+                   flags.isConcurrent(), flags.isAsync(), diffKind, clangFnType)
                    .build();
 
   return SILFunctionType::get(genericSig, einfo, funcCoroutineKind,
diff --git a/lib/AST/ASTMangler.cpp b/lib/AST/ASTMangler.cpp
@@ -1727,6 +1727,11 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn) {
     break;
   }
 
+  // Concurrent functions.
+  if (fn->isConcurrent()) {
+    OpArgs.push_back('h');
+  }
+
   // Asynchronous functions.
   if (fn->isAsync()) {
     OpArgs.push_back('H');
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -4293,6 +4293,9 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     if (info.isNoEscape()) {
       Printer.printSimpleAttr("@noescape") << " ";
     }
+    if (info.isConcurrent()) {
+      Printer.printSimpleAttr("@concurrent") << " ";
+    }
     if (info.isAsync()) {
       Printer.printSimpleAttr("@async") << " ";
     }
diff --git a/lib/Demangling/Demangler.cpp b/lib/Demangling/Demangler.cpp
@@ -1877,6 +1877,11 @@ NodePointer Demangler::demangleImplFunctionType() {
   if (CoroAttr)
     type->addChild(createNode(Node::Kind::ImplFunctionAttribute, CoroAttr), *this);
 
+  if (nextIf('h')) {
+    type->addChild(createNode(Node::Kind::ImplFunctionAttribute, "@concurrent"),
+                   *this);
+  }
+
   if (nextIf('H')) {
     type->addChild(createNode(Node::Kind::ImplFunctionAttribute, "@async"),
                    *this);
diff --git a/lib/Demangling/OldDemangler.cpp b/lib/Demangling/OldDemangler.cpp
@@ -2149,6 +2149,9 @@ class OldDemangler {
         return nullptr;
     }
 
+    if (Mangled.nextIf('h'))
+      addImplFunctionAttribute(type, "@concurrent");
+
     if (Mangled.nextIf('H'))
       addImplFunctionAttribute(type, "@async");
 
diff --git a/lib/Demangling/OldRemangler.cpp b/lib/Demangling/OldRemangler.cpp
@@ -1271,6 +1271,8 @@ void Remangler::mangleImplFunctionAttribute(Node *node) {
     Buffer << "A";
   } else if (text == "@yield_many") {
     Buffer << "G";
+  } else if (text == "@concurrent") {
+    Buffer << "h";
   } else if (text == "@async") {
     Buffer << "H";
   } else {
diff --git a/lib/Demangling/Remangler.cpp b/lib/Demangling/Remangler.cpp
@@ -1600,6 +1600,7 @@ void Remangler::mangleImplFunctionType(Node *node) {
         char FuncAttr = llvm::StringSwitch<char>(Child->getText())
                         .Case("@yield_once", 'A')
                         .Case("@yield_many", 'G')
+                        .Case("@concurrent", 'h')
                         .Case("@async", 'H')
                         .Default(0);
         assert(FuncAttr && "invalid impl function attribute");
diff --git a/lib/SIL/IR/SILFunctionType.cpp b/lib/SIL/IR/SILFunctionType.cpp
@@ -2106,7 +2106,10 @@ static CanSILFunctionType getSILFunctionType(
   assert(
       (!foreignInfo.Async || substFnInterfaceType->getExtInfo().isAsync())
       && "foreignAsync was set but function type is not async?");
-  
+
+  // Map '@concurrent' to the appropriate `@concurrent` modifier.
+  bool isConcurrent = substFnInterfaceType->getExtInfo().isConcurrent();
+
   // Map 'async' to the appropriate `@async` modifier.
   bool isAsync = false;
   if (substFnInterfaceType->getExtInfo().isAsync() && !foreignInfo.Async) {
@@ -2221,6 +2224,7 @@ static CanSILFunctionType getSILFunctionType(
   }
   auto silExtInfo = extInfoBuilder.withClangFunctionType(clangType)
                         .withIsPseudogeneric(pseudogeneric)
+                        .withConcurrent(isConcurrent)
                         .withAsync(isAsync)
                         .build();
 
diff --git a/lib/SIL/IR/TypeLowering.cpp b/lib/SIL/IR/TypeLowering.cpp
@@ -2529,6 +2529,7 @@ getFunctionInterfaceTypeWithCaptures(TypeConverter &TC,
   auto innerExtInfo =
       AnyFunctionType::ExtInfoBuilder(FunctionType::Representation::Thin,
                                       funcType->isThrowing())
+          .withConcurrent(funcType->isConcurrent())
           .withAsync(funcType->isAsync())
           .build();
 
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -2249,7 +2249,7 @@ TypeResolver::resolveAttributedType(TypeAttributes &attrs, TypeRepr *repr,
 
       auto extInfoBuilder = SILFunctionType::ExtInfoBuilder(
           rep, attrs.has(TAK_pseudogeneric), attrs.has(TAK_noescape),
-          attrs.has(TAK_async), diffKind,
+          attrs.has(TAK_concurrent), attrs.has(TAK_async), diffKind,
           parsedClangFunctionType);
 
       ty =
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
@@ -5408,6 +5408,7 @@ class TypeDeserializer {
     uint8_t rawRepresentation;
     uint8_t rawDiffKind;
     bool pseudogeneric = false;
+    bool concurrent;
     bool noescape;
     bool hasErrorResult;
     unsigned numParams;
@@ -5420,6 +5421,7 @@ class TypeDeserializer {
     ClangTypeID clangFunctionTypeID;
 
     decls_block::SILFunctionTypeLayout::readRecord(scratch,
+                                             concurrent,
                                              async,
                                              rawCoroutineKind,
                                              rawCalleeConvention,
@@ -5457,7 +5459,7 @@ class TypeDeserializer {
 
     auto extInfo =
         SILFunctionType::ExtInfoBuilder(*representation, pseudogeneric,
-                                        noescape, async, *diffKind, 
+                                        noescape, concurrent, async, *diffKind, 
                                         clangFunctionType)
             .build();
 
diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
diff --git a/test/SILGen/async_let.swift b/test/SILGen/async_let.swift
diff --git a/test/SILGen/concurrent_functions.swift b/test/SILGen/concurrent_functions.swift

Original file line number	Diff line number	Diff line change
`@@ -443,6 +443,7 @@ class TypeRefBuilder {`
`443`	`443`	`break;`
`444`	`444`	`}`
`445`	`445`
	`446`	`+ funcFlags = funcFlags.withConcurrent(flags.isConcurrent());`
`446`	`447`	`funcFlags = funcFlags.withAsync(flags.isAsync());`
`447`	`448`
`448`	`449`	`auto result = createTupleType({}, "");`
Original file line number	Diff line number	Diff line change
`@@ -559,7 +559,7 @@ Type ASTBuilder::createImplFunctionType(`
`559`	`559`	`}`
`560`	`560`	`auto einfo = SILFunctionType::ExtInfoBuilder(`
`561`	`561`	`representation, flags.isPseudogeneric(), !flags.isEscaping(),`
`562`		`- flags.isAsync(), diffKind, clangFnType)`
	`562`	`+ flags.isConcurrent(), flags.isAsync(), diffKind, clangFnType)`
`563`	`563`	`.build();`
`564`	`564`
`565`	`565`	`return SILFunctionType::get(genericSig, einfo, funcCoroutineKind,`
Original file line number	Diff line number	Diff line change
`@@ -4293,6 +4293,9 @@ class TypePrinter : public TypeVisitor<TypePrinter> {`
`4293`	`4293`	`if (info.isNoEscape()) {`
`4294`	`4294`	`Printer.printSimpleAttr("@noescape") << " ";`
`4295`	`4295`	`}`
	`4296`	`+ if (info.isConcurrent()) {`
	`4297`	`+ Printer.printSimpleAttr("@concurrent") << " ";`
	`4298`	`+ }`
`4296`	`4299`	`if (info.isAsync()) {`
`4297`	`4300`	`Printer.printSimpleAttr("@async") << " ";`
`4298`	`4301`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2149,6 +2149,9 @@ class OldDemangler {`
`2149`	`2149`	`return nullptr;`
`2150`	`2150`	`}`
`2151`	`2151`
	`2152`	`+ if (Mangled.nextIf('h'))`
	`2153`	`+ addImplFunctionAttribute(type, "@concurrent");`
	`2154`	`+`
`2152`	`2155`	`if (Mangled.nextIf('H'))`
`2153`	`2156`	`addImplFunctionAttribute(type, "@async");`
`2154`	`2157`