Merge pull request swiftlang#37944 from DougGregor/isolated-parameters-abi

[SE-0313] isolated parameters ABI

Author: DougGregor

docs/ABI/Mangling.rst

@@ -611,7 +611,7 @@ Types
   type-list ::= empty-list
 
                                                   // FIXME: Consider replacing 'h' with a two-char code
-  list-type ::= type identifier? 'Yk'? 'z'? 'h'? 'n'? 'd'?  // type with optional label, '@noDerivative', inout convention, shared convention, owned convention, and variadic specifier
+  list-type ::= type identifier? 'Yk'? 'z'? 'h'? 'n'? 'Yi'? 'd'?  // type with optional label, '@noDerivative', inout convention, shared convention, owned convention, actor 'isolated', and variadic specifier
 
   METATYPE-REPR ::= 't'                      // Thin metatype representation
   METATYPE-REPR ::= 'T'                      // Thick metatype representation

include/swift/ABI/MetadataValues.h

@@ -950,7 +950,8 @@ class TargetParameterTypeFlags {
     ValueOwnershipMask    = 0x7F,
     VariadicMask          = 0x80,
     AutoClosureMask       = 0x100,
-    NoDerivativeMask      = 0x200
+    NoDerivativeMask      = 0x200,
+    IsolatedMask          = 0x400,
   };
   int_type Data;
 
@@ -983,10 +984,17 @@ class TargetParameterTypeFlags {
         (Data & ~NoDerivativeMask) | (isNoDerivative ? NoDerivativeMask : 0));
   }
 
+  constexpr TargetParameterTypeFlags<int_type>
+  withIsolated(bool isIsolated) const {
+    return TargetParameterTypeFlags<int_type>(
+        (Data & ~IsolatedMask) | (isIsolated ? IsolatedMask : 0));
+  }
+
   bool isNone() const { return Data == 0; }
   bool isVariadic() const { return Data & VariadicMask; }
   bool isAutoClosure() const { return Data & AutoClosureMask; }
   bool isNoDerivative() const { return Data & NoDerivativeMask; }
+  bool isIsolated() const { return Data & IsolatedMask; }
 
   ValueOwnership getValueOwnership() const {
     return (ValueOwnership)(Data & ValueOwnershipMask);

include/swift/AST/Attr.def

@@ -662,6 +662,12 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(spawn, Spawn,
   APIBreakingToAdd | APIBreakingToRemove,
   117)
 
+CONTEXTUAL_SIMPLE_DECL_ATTR(isolated, Isolated,
+  DeclModifier | OnParam |
+  ABIBreakingToAdd | ABIBreakingToRemove |
+  APIBreakingToAdd | APIBreakingToRemove,
+  118)
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/Decl.h

@@ -5233,7 +5233,7 @@ class ParamDecl : public VarDecl {
 
   TypeRepr *TyRepr = nullptr;
 
-  struct StoredDefaultArgument {
+  struct alignas(1 << DeclAlignInBits) StoredDefaultArgument {
     PointerUnion<Expr *, VarDecl *> DefaultArg;
 
     /// Stores the context for the default argument as well as a bit to
@@ -5254,10 +5254,13 @@ class ParamDecl : public VarDecl {
 
     /// Whether or not this parameter is `@autoclosure`.
     IsAutoClosure = 1 << 1,
+
+    /// Whether or not this parameter is 'isolated'.
+    IsIsolated = 1 << 2,
   };
 
   /// The default value, if any, along with flags.
-  llvm::PointerIntPair<StoredDefaultArgument *, 2, OptionSet<Flags>>
+  llvm::PointerIntPair<StoredDefaultArgument *, 3, OptionSet<Flags>>
       DefaultValueAndFlags;
 
   friend class ParamSpecifierRequest;
@@ -5408,6 +5411,17 @@ class ParamDecl : public VarDecl {
                                       : flags - Flags::IsAutoClosure);
   }
 
+  /// Whether or not this parameter is marked with 'isolated'.
+  bool isIsolated() const {
+    return DefaultValueAndFlags.getInt().contains(Flags::IsIsolated);
+  }
+
+  void setIsolated(bool value = true) {
+    auto flags = DefaultValueAndFlags.getInt();
+    DefaultValueAndFlags.setInt(value ? flags | Flags::IsIsolated
+                                      : flags - Flags::IsIsolated);
+  }
+
   /// Does this parameter reject temporary pointer conversions?
   bool isNonEphemeral() const;
 

include/swift/AST/DiagnosticsSema.def

@@ -4373,24 +4373,20 @@ ERROR(override_implicit_unowned_executor,none,
       "explicitly defined", ())
 
 ERROR(actor_isolated_non_self_reference,none,
-        "actor-isolated %0 %1 can only be %select{referenced|mutated|used 'inout'}3 "
-        "%select{from inside the actor|on 'self'}2",
-        (DescriptiveDeclKind, DeclName, bool, unsigned))
-ERROR(actor_isolated_self_independent_context,none,
-        "actor-isolated %0 %1 can not be %select{referenced|mutated|used 'inout'}2 from a "
-        "non-isolated context",
-        (DescriptiveDeclKind, DeclName, unsigned))
+        "actor-isolated %0 %1 can not be "
+        "%select{referenced|mutated|used 'inout'}2 "
+        "%select{on a non-isolated actor instance|"
+        "from a Sendable function|from a Sendable closure|"
+        "from an 'async let' initializer|from global actor %4|"
+        "from the main actor|from a non-isolated context}3",
+        (DescriptiveDeclKind, DeclName, unsigned, unsigned, Type))
 ERROR(actor_isolated_inout_state,none,
       "actor-isolated %0 %1 cannot be passed 'inout' to"
       "%select{| implicitly}2 'async' function call",
       (DescriptiveDeclKind, DeclName, bool))
 ERROR(actor_isolated_mutating_func,none,
       "cannot call mutating async function %0 on actor-isolated %1 %2",
       (DeclName, DescriptiveDeclKind, DeclName))
-ERROR(actor_isolated_global_actor_context,none,
-      "actor-isolated %0 %1 can not be %select{referenced|mutated|used 'inout'}3 "
-      "from%select{| synchronous}4 context of global actor %2",
-      (DescriptiveDeclKind, DeclName, Type, unsigned, bool))
 ERROR(global_actor_from_instance_actor_context,none,
       "%0 %1 isolated to global actor %2 can not be %select{referenced|mutated|used 'inout'}4"
       " from actor %3 %select{|in a synchronous context}5",
@@ -4415,15 +4411,6 @@ ERROR(actor_isolated_partial_apply,none,
 ERROR(concurrent_access_local,none,
         "use of local %0 %1 in concurrently-executing code",
         (DescriptiveDeclKind, DeclName))
-ERROR(actor_isolated_from_concurrent_closure,none,
-        "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from a concurrent closure",
-        (DescriptiveDeclKind, DeclName, unsigned))
-ERROR(actor_isolated_from_concurrent_function,none,
-        "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from a concurrent function",
-        (DescriptiveDeclKind, DeclName, unsigned))
-ERROR(actor_isolated_from_async_let,none,
-        "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from 'async let' initializer",
-        (DescriptiveDeclKind, DeclName, unsigned))
 ERROR(actor_isolated_keypath_component,none,
       "cannot form key path to actor-isolated %0 %1",
       (DescriptiveDeclKind, DeclName))
@@ -4468,6 +4455,9 @@ ERROR(actor_cannot_conform_to_global_actor_protocol,none,
 NOTE(protocol_isolated_to_global_actor_here,none,
      "%0 is isolated to global actor %1 here", (Type, Type))
 
+ERROR(isolated_parameter_not_actor,none,
+      "'isolated' parameter has non-actor type %0", (Type))
+      
 WARNING(non_concurrent_param_type,none,
         "cannot pass argument of non-sendable type %0 across actors",
         (Type))

include/swift/AST/TypeCheckRequests.h

@@ -1023,6 +1023,20 @@ class ActorIsolationRequest :
   bool isCached() const { return true; }
 };
 
+/// Determine whether the given function should have an isolated 'self'.
+class HasIsolatedSelfRequest :
+    public SimpleRequest<HasIsolatedSelfRequest,
+                         bool(ValueDecl *),
+                         RequestFlags::Uncached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  bool evaluate(Evaluator &evaluator, ValueDecl *func) const;
+};
+
 /// Request whether the storage has a mutating getter.
 class IsGetterMutatingRequest :
     public SimpleRequest<IsGetterMutatingRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -112,6 +112,9 @@ SWIFT_REQUEST(TypeChecker, GlobalActorAttributeRequest,
 SWIFT_REQUEST(TypeChecker, ActorIsolationRequest,
               ActorIsolationState(ValueDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, HasIsolatedSelfRequest,
+              bool(ValueDecl *),
+              Uncached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, FunctionOperatorRequest, OperatorDecl *(FuncDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(NameLookup, GenericSignatureRequest,

include/swift/AST/TypeRepr.h

@@ -939,7 +939,8 @@ class SpecifierTypeRepr : public TypeRepr {
   static bool classof(const TypeRepr *T) {
     return T->getKind() == TypeReprKind::InOut ||
            T->getKind() == TypeReprKind::Shared ||
-           T->getKind() == TypeReprKind::Owned;
+           T->getKind() == TypeReprKind::Owned ||
+           T->getKind() == TypeReprKind::Isolated;
   }
   static bool classof(const SpecifierTypeRepr *T) { return true; }
 
@@ -995,6 +996,21 @@ class OwnedTypeRepr : public SpecifierTypeRepr {
   static bool classof(const OwnedTypeRepr *T) { return true; }
 };
 
+/// An 'isolated' type.
+/// \code
+///   x : isolated Actor
+/// \endcode
+class IsolatedTypeRepr : public SpecifierTypeRepr {
+public:
+  IsolatedTypeRepr(TypeRepr *Base, SourceLoc InOutLoc)
+    : SpecifierTypeRepr(TypeReprKind::Isolated, Base, InOutLoc) {}
+
+  static bool classof(const TypeRepr *T) {
+    return T->getKind() == TypeReprKind::Isolated;
+  }
+  static bool classof(const IsolatedTypeRepr *T) { return true; }
+};
+
 /// A TypeRepr for a known, fixed type.
 ///
 /// Fixed type representations should be used sparingly, in places
@@ -1226,6 +1242,7 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::SILBox:
   case TypeReprKind::Shared:
   case TypeReprKind::Owned:
+  case TypeReprKind::Isolated:
   case TypeReprKind::Placeholder:
     return true;
   }

include/swift/AST/TypeReprNodes.def

@@ -59,6 +59,7 @@ ABSTRACT_TYPEREPR(Specifier, TypeRepr)
   TYPEREPR(InOut, SpecifierTypeRepr)
   TYPEREPR(Shared, SpecifierTypeRepr)
   TYPEREPR(Owned, SpecifierTypeRepr)
+  TYPEREPR(Isolated, SpecifierTypeRepr)
 TYPEREPR(Fixed, TypeRepr)
 TYPEREPR(SILBox, TypeRepr)
 LAST_TYPEREPR(SILBox)

include/swift/AST/Types.h

@@ -1933,10 +1933,11 @@ class ParameterTypeFlags {
     OwnershipShift = 3,
     Ownership    = 7 << OwnershipShift,
     NoDerivative = 1 << 6,
-    NumBits = 7
+    Isolated     = 1 << 7,
+    NumBits = 8
   };
   OptionSet<ParameterFlags> value;
-  static_assert(NumBits < 8*sizeof(OptionSet<ParameterFlags>), "overflowed");
+  static_assert(NumBits <= 8*sizeof(OptionSet<ParameterFlags>), "overflowed");
 
   ParameterTypeFlags(OptionSet<ParameterFlags, uint8_t> val) : value(val) {}
 
@@ -1947,17 +1948,18 @@ class ParameterTypeFlags {
   }
 
   ParameterTypeFlags(bool variadic, bool autoclosure, bool nonEphemeral,
-                     ValueOwnership ownership, bool noDerivative)
+                     ValueOwnership ownership, bool isolated, bool noDerivative)
       : value((variadic ? Variadic : 0) | (autoclosure ? AutoClosure : 0) |
               (nonEphemeral ? NonEphemeral : 0) |
               uint8_t(ownership) << OwnershipShift |
+              (isolated ? Isolated : 0) |
               (noDerivative ? NoDerivative : 0)) {}
 
   /// Create one from what's present in the parameter type
   inline static ParameterTypeFlags
   fromParameterType(Type paramTy, bool isVariadic, bool isAutoClosure,
                     bool isNonEphemeral, ValueOwnership ownership,
-                    bool isNoDerivative);
+                    bool isolated, bool isNoDerivative);
 
   bool isNone() const { return !value; }
   bool isVariadic() const { return value.contains(Variadic); }
@@ -1966,6 +1968,7 @@ class ParameterTypeFlags {
   bool isInOut() const { return getValueOwnership() == ValueOwnership::InOut; }
   bool isShared() const { return getValueOwnership() == ValueOwnership::Shared;}
   bool isOwned() const { return getValueOwnership() == ValueOwnership::Owned; }
+  bool isIsolated() const { return value.contains(Isolated); }
   bool isNoDerivative() const { return value.contains(NoDerivative); }
 
   ValueOwnership getValueOwnership() const {
@@ -2009,6 +2012,12 @@ class ParameterTypeFlags {
                                   : value - ParameterTypeFlags::NonEphemeral);
   }
 
+  ParameterTypeFlags withIsolated(bool isolated) const {
+    return ParameterTypeFlags(isolated
+                                  ? value | ParameterTypeFlags::Isolated
+                                  : value - ParameterTypeFlags::Isolated);
+  }
+
   ParameterTypeFlags withNoDerivative(bool noDerivative) const {
     return ParameterTypeFlags(noDerivative
                                   ? value | ParameterTypeFlags::NoDerivative
@@ -2082,7 +2091,7 @@ class YieldTypeFlags {
     return ParameterTypeFlags(/*variadic*/ false,
                               /*autoclosure*/ false,
                               /*nonEphemeral*/ false, getValueOwnership(),
-                              /*noDerivative*/ false);
+                              /*isolated*/ false, /*noDerivative*/ false);
   }
 
   bool operator ==(const YieldTypeFlags &other) const {
@@ -2861,6 +2870,9 @@ class AnyFunctionType : public TypeBase {
     /// Whether the parameter is marked '@_nonEphemeral'
     bool isNonEphemeral() const { return Flags.isNonEphemeral(); }
 
+    /// Whether the parameter is 'isolated'.
+    bool isIsolated() const { return Flags.isIsolated(); }
+
     /// Whether the parameter is marked '@noDerivative'.
     bool isNoDerivative() const { return Flags.isNoDerivative(); }
 
@@ -6231,7 +6243,7 @@ inline TupleTypeElt TupleTypeElt::getWithType(Type T) const {
 /// Create one from what's present in the parameter decl and type
 inline ParameterTypeFlags ParameterTypeFlags::fromParameterType(
     Type paramTy, bool isVariadic, bool isAutoClosure, bool isNonEphemeral,
-    ValueOwnership ownership, bool isNoDerivative) {
+    ValueOwnership ownership, bool isolated, bool isNoDerivative) {
   // FIXME(Remove InOut): The last caller that needs this is argument
   // decomposition.  Start by enabling the assertion there and fixing up those
   // callers, then remove this, then remove
@@ -6241,7 +6253,8 @@ inline ParameterTypeFlags ParameterTypeFlags::fromParameterType(
            ownership == ValueOwnership::InOut);
     ownership = ValueOwnership::InOut;
   }
-  return {isVariadic, isAutoClosure, isNonEphemeral, ownership, isNoDerivative};
+  return {isVariadic, isAutoClosure, isNonEphemeral, ownership, isolated,
+          isNoDerivative};
 }
 
 inline const Type *BoundGenericType::getTrailingObjectsPointer() const {