Merge pull request swiftlang#71152 from rjmccall/centralize-function-type-isolation

Create a uniform representation for function type isolation

Author: rjmccall

include/swift/AST/ASTDemangler.h

@@ -143,7 +143,7 @@ class ASTBuilder {
 
   Type createFunctionType(
       ArrayRef<Demangle::FunctionParam<Type>> params,
-      Type output, FunctionTypeFlags flags,
+      Type output, FunctionTypeFlags flags, ExtendedFunctionTypeFlags extFlags,
       FunctionMetadataDifferentiabilityKind diffKind, Type globalActor,
       Type thrownError);
 

include/swift/AST/ExtInfo.h

@@ -47,6 +47,78 @@ enum class SILFunctionTypeRepresentation : uint8_t;
 
 namespace swift {
 
+/// The formal isolation of a function type.
+class FunctionTypeIsolation {
+public:
+  enum class Kind : uint8_t {
+    /// The function is not isolated.
+    NonIsolated,
+
+    /// The function is isolated to a global actor.
+    GlobalActor,
+
+    /// The function has an isolated parameter; which one is indicated in
+    /// the parameter list.
+    Parameter,
+
+    /// The function is dynamically isolated.
+    Dynamic,
+  };
+
+  static constexpr size_t NumBits = 3; // future-proof this slightly
+  static constexpr size_t Mask = (1 << NumBits) - 1;
+
+private:
+  llvm::PointerIntPair<Type, NumBits, Kind> value;
+
+  FunctionTypeIsolation(Kind kind, Type type = Type()) : value(type, kind) {}
+
+public:
+  static FunctionTypeIsolation forNonIsolated() {
+    return { Kind::NonIsolated };
+  }
+  static FunctionTypeIsolation forGlobalActor(Type type) {
+    assert(type && "creating global actor isolation without an actor type");
+    return { Kind::GlobalActor, type };
+  }
+  static FunctionTypeIsolation forParameter() {
+    return { Kind::Parameter };
+  }
+  static FunctionTypeIsolation forDynamic() {
+    return { Kind::Dynamic };
+  }
+
+  Kind getKind() const { return value.getInt(); }
+  bool isNonIsolated() const {
+    return getKind() == Kind::NonIsolated;
+  }
+  bool isGlobalActor() const {
+    return getKind() == Kind::GlobalActor;
+  }
+  Type getGlobalActorType() const {
+    assert(getKind() == Kind::GlobalActor);
+    return value.getPointer();
+  }
+  bool isParameter() const {
+    return getKind() == Kind::Parameter;
+  }
+  bool isDynamic() const {
+    return getKind() == Kind::Dynamic;
+  }
+
+  // The opaque accessors below are just for the benefit of ExtInfoBuilder,
+  // which finds it convenient to break down the type separately.  Normal
+  // clients should use the accessors above.
+
+  Type getOpaqueType() const {
+    return value.getPointer();
+  }
+
+  static FunctionTypeIsolation fromOpaqueValues(Kind kind, Type type) {
+    return FunctionTypeIsolation(kind, type);
+  }
+};
+
 // MARK: - ClangTypeInfo
 /// Wrapper class for storing a clang::Type in an (AST|SIL)ExtInfo.
 class ClangTypeInfo {
@@ -373,20 +445,24 @@ class ASTExtInfoBuilder {
   // If bits are added or removed, then TypeBase::NumAFTExtInfoBits
   // and NumMaskBits must be updated, and they must match.
   //
-  //   |representation|noEscape|concurrent|async|throws|differentiability|
-  //   |    0 .. 3    |    4   |    5     |  6  |   7  |     8 .. 10    |
+  //   |representation|noEscape|concurrent|async|throws|isolation|differentiability|
+  //   |    0 .. 3    |    4   |    5     |  6  |   7  | 8 .. 10 |     11 .. 13    |
   //
   enum : unsigned {
     RepresentationMask = 0xF << 0,
     NoEscapeMask = 1 << 4,
     SendableMask = 1 << 5,
     AsyncMask = 1 << 6,
     ThrowsMask = 1 << 7,
-    DifferentiabilityMaskOffset = 8,
+    IsolationMaskOffset = 8,
+    IsolationMask = 0x7 << IsolationMaskOffset,
+    DifferentiabilityMaskOffset = 11,
     DifferentiabilityMask = 0x7 << DifferentiabilityMaskOffset,
-    NumMaskBits = 11
+    NumMaskBits = 14
   };
 
+  static_assert(FunctionTypeIsolation::Mask == 0x7, "update mask manually");
+
   unsigned bits; // Naturally sized for speed.
 
   ClangTypeInfo clangTypeInfo;
@@ -403,33 +479,39 @@ class ASTExtInfoBuilder {
                     LifetimeDependenceInfo lifetimeDependenceInfo)
       : bits(bits), clangTypeInfo(clangTypeInfo), globalActor(globalActor),
         thrownError(thrownError),
-        lifetimeDependenceInfo(lifetimeDependenceInfo) {}
+        lifetimeDependenceInfo(lifetimeDependenceInfo) {
+    assert(isThrowing() || !thrownError);
+    assert(hasGlobalActorFromBits(bits) == !globalActor.isNull());
+  }
 
 public:
   /// An ExtInfoBuilder for a typical Swift function: @convention(swift),
   /// @escaping, non-throwing, non-differentiable.
   ASTExtInfoBuilder()
       : ASTExtInfoBuilder(Representation::Swift, false, false, Type(),
                           DifferentiabilityKind::NonDifferentiable, nullptr,
-                          Type(), LifetimeDependenceInfo()) {}
+                          FunctionTypeIsolation::forNonIsolated(),
+                          LifetimeDependenceInfo()) {}
 
   // Constructor for polymorphic type.
   ASTExtInfoBuilder(Representation rep, bool throws, Type thrownError)
       : ASTExtInfoBuilder(rep, false, throws, thrownError,
                           DifferentiabilityKind::NonDifferentiable, nullptr,
-                          Type(), LifetimeDependenceInfo()) {}
+                          FunctionTypeIsolation::forNonIsolated(),
+                          LifetimeDependenceInfo()) {}
 
   // Constructor with no defaults.
   ASTExtInfoBuilder(Representation rep, bool isNoEscape, bool throws,
                     Type thrownError, DifferentiabilityKind diffKind,
-                    const clang::Type *type, Type globalActor,
+                    const clang::Type *type, FunctionTypeIsolation isolation,
                     LifetimeDependenceInfo lifetimeDependenceInfo)
       : ASTExtInfoBuilder(
             ((unsigned)rep) | (isNoEscape ? NoEscapeMask : 0) |
                 (throws ? ThrowsMask : 0) |
                 (((unsigned)diffKind << DifferentiabilityMaskOffset) &
-                 DifferentiabilityMask),
-            ClangTypeInfo(type), globalActor, thrownError,
+                 DifferentiabilityMask) |
+                (unsigned(isolation.getKind()) << IsolationMaskOffset),
+            ClangTypeInfo(type), isolation.getOpaqueType(), thrownError,
             lifetimeDependenceInfo) {}
 
   void checkInvariants() const;
@@ -474,6 +556,26 @@ class ASTExtInfoBuilder {
     return lifetimeDependenceInfo;
   }
 
+  FunctionTypeIsolation::Kind getIsolationKind() const {
+    return getIsolationKindFromBits(bits);
+  }
+  static FunctionTypeIsolation::Kind getIsolationKindFromBits(unsigned bits) {
+    return FunctionTypeIsolation::Kind(
+             (bits & IsolationMask) >> IsolationMaskOffset);
+  }
+  bool isDynamicallyIsolated() const {
+    return getIsolationKind() == FunctionTypeIsolation::Kind::Dynamic;
+  }
+  static bool hasGlobalActorFromBits(unsigned bits) {
+    return getIsolationKindFromBits(bits)
+             == FunctionTypeIsolation::Kind::GlobalActor;
+  }
+
+  FunctionTypeIsolation getIsolation() const {
+    return FunctionTypeIsolation::fromOpaqueValues(getIsolationKind(),
+                                                   globalActor);
+  }
+
   constexpr bool hasSelfParam() const {
     switch (getSILRepresentation()) {
     case SILFunctionTypeRepresentation::Thick:
@@ -529,6 +631,7 @@ class ASTExtInfoBuilder {
   }
   [[nodiscard]]
   ASTExtInfoBuilder withThrows(bool throws, Type thrownError) const {
+    assert(throws || !thrownError);
     return ASTExtInfoBuilder(
         throws ? (bits | ThrowsMask) : (bits & ~ThrowsMask), clangTypeInfo,
         globalActor, thrownError, lifetimeDependenceInfo);
@@ -566,15 +669,19 @@ class ASTExtInfoBuilder {
   }
 
   [[nodiscard]]
-  ASTExtInfoBuilder withGlobalActor(Type globalActor) const {
+  ASTExtInfoBuilder withLifetimeDependenceInfo(
+      LifetimeDependenceInfo lifetimeDependenceInfo) const {
     return ASTExtInfoBuilder(bits, clangTypeInfo, globalActor, thrownError,
                              lifetimeDependenceInfo);
   }
 
-  [[nodiscard]] ASTExtInfoBuilder withLifetimeDependenceInfo(
-      LifetimeDependenceInfo lifetimeDependenceInfo) const {
-    return ASTExtInfoBuilder(bits, clangTypeInfo, globalActor, thrownError,
-                             lifetimeDependenceInfo);
+  [[nodiscard]]
+  ASTExtInfoBuilder withIsolation(FunctionTypeIsolation isolation) const {
+    return ASTExtInfoBuilder(
+             (bits & ~IsolationMask)
+                | (unsigned(isolation.getKind()) << IsolationMaskOffset),
+             clangTypeInfo, isolation.getOpaqueType(), thrownError,
+             lifetimeDependenceInfo);
   }
 
   bool isEqualTo(ASTExtInfoBuilder other, bool useClangTypes) const {
@@ -664,6 +771,8 @@ class ASTExtInfo {
     return builder.getLifetimeDependenceInfo();
   }
 
+  FunctionTypeIsolation getIsolation() const { return builder.getIsolation(); }
+
   /// Helper method for changing the representation.
   ///
   /// Prefer using \c ASTExtInfoBuilder::withRepresentation for chaining.
@@ -712,9 +821,22 @@ class ASTExtInfo {
     return builder.withAsync(async).build();
   }
 
+  [[nodiscard]]
+  ASTExtInfo withIsolation(FunctionTypeIsolation isolation) const {
+    return builder.withIsolation(isolation).build();
+  }
+
+  [[nodiscard]]
+  ASTExtInfo withoutIsolation() const {
+    return builder.withIsolation(FunctionTypeIsolation::forNonIsolated())
+      .build();
+  }
+
   [[nodiscard]]
   ASTExtInfo withGlobalActor(Type globalActor) const {
-    return builder.withGlobalActor(globalActor).build();
+    return builder.withIsolation(
+             FunctionTypeIsolation::forGlobalActor(globalActor))
+      .build();
   }
 
   [[nodiscard]] ASTExtInfo withLifetimeDependenceInfo(

include/swift/AST/Types.h

@@ -384,7 +384,7 @@ class alignas(1 << TypeAlignInBits) TypeBase
   }
 
 protected:
-  enum { NumAFTExtInfoBits = 11 };
+  enum { NumAFTExtInfoBits = 14 };
   enum { NumSILExtInfoBits = 13 };
 
   // clang-format off
@@ -412,13 +412,12 @@ class alignas(1 << TypeAlignInBits) TypeBase
 
   SWIFT_INLINE_BITFIELD_EMPTY(ParenType, SugarType);
 
-  SWIFT_INLINE_BITFIELD_FULL(AnyFunctionType, TypeBase, NumAFTExtInfoBits+1+1+1+1+1+16,
+  SWIFT_INLINE_BITFIELD_FULL(AnyFunctionType, TypeBase, NumAFTExtInfoBits+1+1+1+1+16,
     /// Extra information which affects how the function is called, like
     /// regparm and the calling convention.
     ExtInfoBits : NumAFTExtInfoBits,
     HasExtInfo : 1,
     HasClangTypeInfo : 1,
-    HasGlobalActor : 1,
     HasThrownError : 1,
     HasLifetimeDependenceInfo : 1,
     : NumPadBits,
@@ -3365,10 +3364,9 @@ class AnyFunctionType : public TypeBase {
       Bits.AnyFunctionType.ExtInfoBits = Info.value().getBits();
       Bits.AnyFunctionType.HasClangTypeInfo =
           !Info.value().getClangTypeInfo().empty();
-      Bits.AnyFunctionType.HasGlobalActor =
-          !Info.value().getGlobalActor().isNull();
       Bits.AnyFunctionType.HasThrownError =
           !Info.value().getThrownError().isNull();
+      assert(!Bits.AnyFunctionType.HasThrownError || Info->isThrowing());
       Bits.AnyFunctionType.HasLifetimeDependenceInfo =
           !Info.value().getLifetimeDependenceInfo().empty();
       // The use of both assert() and static_assert() is intentional.
@@ -3381,7 +3379,6 @@ class AnyFunctionType : public TypeBase {
       Bits.AnyFunctionType.HasExtInfo = false;
       Bits.AnyFunctionType.HasClangTypeInfo = false;
       Bits.AnyFunctionType.ExtInfoBits = 0;
-      Bits.AnyFunctionType.HasGlobalActor = false;
       Bits.AnyFunctionType.HasThrownError = false;
       Bits.AnyFunctionType.HasLifetimeDependenceInfo = false;
     }
@@ -3423,7 +3420,7 @@ class AnyFunctionType : public TypeBase {
   }
 
   bool hasGlobalActor() const {
-    return Bits.AnyFunctionType.HasGlobalActor;
+    return ExtInfoBuilder::hasGlobalActorFromBits(Bits.AnyFunctionType.ExtInfoBits);
   }
 
   bool hasThrownError() const {
@@ -3442,6 +3439,15 @@ class AnyFunctionType : public TypeBase {
 
   LifetimeDependenceInfo getLifetimeDependenceInfo() const;
 
+  FunctionTypeIsolation getIsolation() const {
+    if (hasExtInfo())
+      return getExtInfo().getIsolation();
+    return FunctionTypeIsolation::forNonIsolated();
+  }
+  bool isDynamicallyIsolated() const {
+    return getIsolation().isDynamic();
+  }
+
   /// Retrieve the "effective" thrown interface type, or llvm::None if
   /// this function cannot throw.
   ///
@@ -3693,6 +3699,15 @@ END_CAN_TYPE_WRAPPER(AnyFunctionType, Type)
 inline AnyFunctionType::CanYield AnyFunctionType::Yield::getCanonical() const {
   return CanYield(getType()->getCanonicalType(), getFlags());
 }
+
+/// A convenience function to find out if any of the given parameters is
+/// isolated.
+///
+/// You generally shouldn't need to call this when you're starting from a
+/// function type; you can just check if the isolation on the type is
+/// parameter isolation.
+bool hasIsolatedParameter(ArrayRef<AnyFunctionType::Param> params);
+
 /// FunctionType - A monomorphic function type, specified with an arrow.
 ///
 /// For example:

include/swift/Demangling/TypeDecoder.h

@@ -812,6 +812,7 @@ class TypeDecoder {
                                     Node->getNumChildren());
 
       FunctionTypeFlags flags;
+      ExtendedFunctionTypeFlags extFlags;
       if (Node->getKind() == NodeKind::ObjCBlock ||
           Node->getKind() == NodeKind::EscapingObjCBlock) {
         flags = flags.withConvention(FunctionMetadataConvention::Block);
@@ -847,6 +848,8 @@ class TypeDecoder {
         ++firstChildIdx;
       }
 
+      // FIXME: other kinds of isolation
+
       FunctionMetadataDifferentiabilityKind diffKind;
       if (Node->getChild(firstChildIdx)->getKind() ==
             NodeKind::DifferentiableFunctionType) {
@@ -895,6 +898,8 @@ class TypeDecoder {
 
         thrownErrorType = thrownErrorResult.getType();
         ++firstChildIdx;
+
+        extFlags = extFlags.withTypedThrows(true);
       }
 
       bool isSendable = false;
@@ -941,8 +946,11 @@ class TypeDecoder {
       if (result.isError())
         return result;
 
+      if (extFlags != ExtendedFunctionTypeFlags())
+        flags = flags.withExtendedFlags(true);
+
       return Builder.createFunctionType(
-          parameters, result.getType(), flags, diffKind, globalActorType,
+          parameters, result.getType(), flags, extFlags, diffKind, globalActorType,
           thrownErrorType);
     }
     case NodeKind::ImplFunctionType: {