Merge pull request #59208 from gottesmm/sil-move-only-type-typesystem-changes

[move-only] Add initial type system changes to express move only ness in the type system

Author: gottesmm

include/swift/AST/Attr.def

@@ -85,6 +85,8 @@ TYPE_ATTR(yields)
 TYPE_ATTR(yield_once)
 TYPE_ATTR(yield_many)
 TYPE_ATTR(captures_generics)
+// Used at the SIL level to mark a type as moveOnly.
+TYPE_ATTR(moveOnly)
 
 // SIL metatype attributes.
 TYPE_ATTR(thin)

include/swift/AST/TypeDifferenceVisitor.h

@@ -333,6 +333,11 @@ class CanTypeDifferenceVisitor : public CanTypePairVisitor<Impl, bool> {
     return asImpl().visit(type1->getCaptureType(), type2->getCaptureType());
   }
 
+  bool visitSILMoveOnlyType(CanSILMoveOnlyType type1,
+                            CanSILMoveOnlyType type2) {
+    return asImpl().visit(type1->getInnerType(), type2->getInnerType());
+  }
+
   bool visitProtocolCompositionType(CanProtocolCompositionType type1,
                                     CanProtocolCompositionType type2) {
     return visitComponentArray(type1, type2,

include/swift/AST/TypeMatcher.h

@@ -352,6 +352,7 @@ class TypeMatcher {
     TRIVIAL_CASE(SILFunctionType)
     TRIVIAL_CASE(SILBlockStorageType)
     TRIVIAL_CASE(SILBoxType)
+    TRIVIAL_CASE(SILMoveOnlyType)
 
     bool visitProtocolCompositionType(CanProtocolCompositionType firstProtocolComposition,
                                       Type secondType,

include/swift/AST/TypeNodes.def

@@ -159,6 +159,7 @@ ABSTRACT_TYPE(AnyFunction, Type)
 ARTIFICIAL_TYPE(SILFunction, Type)
 ARTIFICIAL_TYPE(SILBlockStorage, Type)
 ARTIFICIAL_TYPE(SILBox, Type)
+ARTIFICIAL_TYPE(SILMoveOnly, Type)
 ARTIFICIAL_TYPE(SILToken, Type)
 TYPE(ProtocolComposition, Type)
 TYPE(ParameterizedProtocol, Type)

include/swift/AST/Types.h

@@ -4995,6 +4995,33 @@ class SILBoxType final : public TypeBase, public llvm::FoldingSetNode
 };
 DEFINE_EMPTY_CAN_TYPE_WRAPPER(SILBoxType, Type)
 
+class SILMoveOnlyType;
+class SILModule; // From SIL
+typedef CanTypeWrapper<SILMoveOnlyType> CanMoveOnlyType;
+
+/// A wrapper type that marks an inner type as being a move only value. Can not
+/// be written directly at the Swift level, instead it is triggered by adding
+/// the type attribute @_moveOnly to a different type. We transform these in
+/// TypeLowering into a moveOnly SILType on the inner type.
+class SILMoveOnlyType final : public TypeBase, public llvm::FoldingSetNode {
+  CanType innerType;
+
+  SILMoveOnlyType(CanType innerType)
+      : TypeBase(TypeKind::SILMoveOnly, &innerType->getASTContext(),
+                 innerType->getRecursiveProperties()),
+        innerType(innerType) {}
+
+public:
+  CanType getInnerType() const { return innerType; }
+
+  static CanMoveOnlyType get(CanType innerType);
+
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::SILMoveOnly;
+  }
+};
+DEFINE_EMPTY_CAN_TYPE_WRAPPER(SILMoveOnlyType, Type)
+
 class SILBlockStorageType;
 typedef CanTypeWrapper<SILBlockStorageType> CanSILBlockStorageType;
 

include/swift/SIL/AbstractionPattern.h

@@ -1337,6 +1337,14 @@ class AbstractionPattern {
     llvm_unreachable("bad kind");
   }
 
+  /// Given that the value being abstracted is a move only type, return the
+  /// abstraction pattern with the move only bit removed.
+  AbstractionPattern withoutMoveOnly() const;
+
+  /// Given that the value being abstracted is not a move only type, return the
+  /// abstraction pattern with the move only bit added.
+  AbstractionPattern withMoveOnly() const;
+
   /// Given that the value being abstracted is a tuple type, return
   /// the abstraction pattern for its object type.
   AbstractionPattern getTupleElementType(unsigned index) const;

include/swift/SIL/SILType.h

@@ -179,10 +179,18 @@ class SILType {
   ///    `@thick AnyObject.Type`.
   ///    More generally, you cannot recover a formal type from
   ///    a lowered type. See docs/SIL.rst for more details.
-  CanType getASTType() const {
-    return CanType(value.getPointer());
-  }
-  
+  /// 3. If the underlying type is move only, the returned CanType will not be
+  ///    pointer equal to the RawASTType since we return the unwrapped inner
+  ///    type. This is done under the assumption that in all cases where we are
+  ///    performing these AST queries on SILType, we are not interested in the
+  ///    move only-ness of the value (which we can query separately anyways).
+  CanType getASTType() const { return withoutMoveOnly().getRawASTType(); }
+
+  /// Returns the canonical AST type references by this SIL type without looking
+  /// through move only. Should only be used by internal utilities of SILType.
+  CanType getRawASTType() const { return CanType(value.getPointer()); }
+
+public:
   // FIXME -- Temporary until LLDB adopts getASTType()
   LLVM_ATTRIBUTE_DEPRECATED(CanType getSwiftRValueType() const,
                             "Please use getASTType()") {
@@ -411,9 +419,7 @@ class SILType {
   }
 
   /// True if the type involves any archetypes.
-  bool hasArchetype() const {
-    return getASTType()->hasArchetype();
-  }
+  bool hasArchetype() const { return getASTType()->hasArchetype(); }
 
   /// True if the type involves any opaque archetypes.
   bool hasOpaqueArchetype() const {
@@ -586,7 +592,42 @@ class SILType {
 
   /// Returns true if this is the AnyObject SILType;
   bool isAnyObject() const { return getASTType()->isAnyObject(); }
-  
+
+  /// Returns true if this SILType is a move only wrapper type.
+  ///
+  /// Canonical way to check if a SILType is move only. Using is/getAs/castTo
+  /// will look through moveonly-ness.
+  bool isMoveOnly() const { return getRawASTType()->is<SILMoveOnlyType>(); }
+
+  /// Return *this if already move only... otherwise, wrap the current type
+  /// within a move only type wrapper and return that. Idempotent!
+  SILType asMoveOnly() const {
+    if (isMoveOnly())
+      return *this;
+    auto newType = SILMoveOnlyType::get(getRawASTType());
+    return SILType::getPrimitiveType(newType, getCategory());
+  }
+
+  /// Return this SILType, removing moveonly-ness.
+  ///
+  /// Is idempotent.
+  SILType withoutMoveOnly() const {
+    if (!isMoveOnly())
+      return *this;
+    auto moveOnly = getRawASTType()->castTo<SILMoveOnlyType>();
+    return SILType::getPrimitiveType(moveOnly->getInnerType(), getCategory());
+  }
+
+  /// If \p otherType is move only, return this type that is move only as
+  /// well. Otherwise, returns self. Useful for propagating "move only"-ness
+  /// from a parent type to a subtype.
+  SILType copyMoveOnly(SILType otherType) const {
+    if (otherType.isMoveOnly()) {
+      return asMoveOnly();
+    }
+    return *this;
+  }
+
   /// Returns a SILType with any archetypes mapped out of context.
   SILType mapTypeOutOfContext() const;
 

include/swift/SIL/TypeLowering.h

@@ -169,11 +169,19 @@ enum IsInfiniteType_t : bool {
   IsInfiniteType = true,
 };
 
+/// Does this type contain a move only type that affects type lowering?
+enum IsMoveOnly_t : bool {
+  IsNotMoveOnly = false,
+  IsMoveOnly = true,
+};
+
 /// Extended type information used by SIL.
 class TypeLowering {
 public:
   class RecursiveProperties {
     // These are chosen so that bitwise-or merges the flags properly.
+    //
+    // clang-format off
     enum : unsigned {
       NonTrivialFlag             = 1 << 0,
       NonFixedABIFlag            = 1 << 1,
@@ -182,7 +190,9 @@ class TypeLowering {
       TypeExpansionSensitiveFlag = 1 << 4,
       InfiniteFlag               = 1 << 5,
       HasRawPointerFlag          = 1 << 6,
+      MoveOnlyFlag               = 1 << 7,
     };
+    // clang-format on
 
     uint8_t Flags;
   public:
@@ -195,13 +205,15 @@ class TypeLowering {
         IsAddressOnly_t isAddressOnly, IsResilient_t isResilient,
         IsTypeExpansionSensitive_t isTypeExpansionSensitive =
             IsNotTypeExpansionSensitive,
-        HasRawPointer_t hasRawPointer = DoesNotHaveRawPointer)
+        HasRawPointer_t hasRawPointer = DoesNotHaveRawPointer,
+        IsMoveOnly_t isMoveOnly = IsNotMoveOnly)
         : Flags((isTrivial ? 0U : NonTrivialFlag) |
                 (isFixedABI ? 0U : NonFixedABIFlag) |
                 (isAddressOnly ? AddressOnlyFlag : 0U) |
                 (isResilient ? ResilientFlag : 0U) |
                 (isTypeExpansionSensitive ? TypeExpansionSensitiveFlag : 0U) |
-                (hasRawPointer ? HasRawPointerFlag : 0U)) {}
+                (hasRawPointer ? HasRawPointerFlag : 0U) |
+                (isMoveOnly ? MoveOnlyFlag : 0U)) {}
 
     constexpr bool operator==(RecursiveProperties p) const {
       return Flags == p.Flags;
@@ -228,6 +240,35 @@ class TypeLowering {
       return {IsTrivial, IsFixedABI, IsNotAddressOnly, IsResilient};
     }
 
+    static constexpr RecursiveProperties forMoveOnlyReference() {
+      return {IsNotTrivial,
+              IsFixedABI,
+              IsNotAddressOnly,
+              IsNotResilient,
+              IsNotTypeExpansionSensitive,
+              DoesNotHaveRawPointer,
+              IsMoveOnly};
+    }
+
+    static constexpr RecursiveProperties forMoveOnlyOpaque() {
+      return {IsNotTrivial,
+              IsNotFixedABI,
+              IsAddressOnly,
+              IsNotResilient,
+              IsNotTypeExpansionSensitive,
+              DoesNotHaveRawPointer,
+              IsMoveOnly};
+    }
+
+    static constexpr RecursiveProperties forMoveOnlyResilient() {
+      return {IsTrivial,
+              IsFixedABI,
+              IsNotAddressOnly,
+              IsResilient,
+              IsNotTypeExpansionSensitive,
+              DoesNotHaveRawPointer,
+              IsMoveOnly};
+    }
 
     void addSubobject(RecursiveProperties other) {
       Flags |= other.Flags;
@@ -255,6 +296,9 @@ class TypeLowering {
     IsInfiniteType_t isInfinite() const {
       return IsInfiniteType_t((Flags & InfiniteFlag) != 0);
     }
+    IsMoveOnly_t isMoveOnly() const {
+      return IsMoveOnly_t((Flags & MoveOnlyFlag) != 0);
+    }
 
     void setNonTrivial() { Flags |= NonTrivialFlag; }
     void setNonFixedABI() { Flags |= NonFixedABIFlag; }
@@ -265,6 +309,7 @@ class TypeLowering {
               (isTypeExpansionSensitive ? TypeExpansionSensitiveFlag : 0);
     }
     void setInfinite() { Flags |= InfiniteFlag; }
+    void setMoveOnly() { Flags |= MoveOnlyFlag; }
   };
 
 private:

lib/AST/ASTContext.cpp

@@ -464,6 +464,7 @@ struct ASTContext::Implementation {
   llvm::FoldingSet<GenericFunctionType> GenericFunctionTypes;
   llvm::FoldingSet<SILFunctionType> SILFunctionTypes;
   llvm::DenseMap<CanType, SILBlockStorageType *> SILBlockStorageTypes;
+  llvm::DenseMap<CanType, SILMoveOnlyType *> SILMoveOnlyTypes;
   llvm::FoldingSet<SILBoxType> SILBoxTypes;
   llvm::DenseMap<BuiltinIntegerWidth, BuiltinIntegerType*> IntegerTypes;
   llvm::FoldingSet<BuiltinVectorType> BuiltinVectorTypes;
@@ -4067,6 +4068,19 @@ SILFunctionType::SILFunctionType(
 #endif
 }
 
+CanSILMoveOnlyType SILMoveOnlyType::get(CanType innerType) {
+  ASTContext &ctx = innerType->getASTContext();
+  auto found = ctx.getImpl().SILMoveOnlyTypes.find(innerType);
+  if (found != ctx.getImpl().SILMoveOnlyTypes.end())
+    return CanSILMoveOnlyType(found->second);
+
+  void *mem = ctx.Allocate(sizeof(SILMoveOnlyType), alignof(SILMoveOnlyType));
+
+  auto *storageTy = new (mem) SILMoveOnlyType(innerType);
+  ctx.getImpl().SILMoveOnlyTypes.insert({innerType, storageTy});
+  return CanSILMoveOnlyType(storageTy);
+}
+
 CanSILBlockStorageType SILBlockStorageType::get(CanType captureType) {
   ASTContext &ctx = captureType->getASTContext();
   auto found = ctx.getImpl().SILBlockStorageTypes.find(captureType);

lib/AST/ASTDumper.cpp

@@ -3935,6 +3935,12 @@ namespace {
       PrintWithColorRAII(OS, ParenthesisColor) << ')';
     }
 
+    void visitSILMoveOnlyType(SILMoveOnlyType *T, StringRef label) {
+      printCommon(label, "sil_move_only_type");
+      printRec(T->getInnerType());
+      PrintWithColorRAII(OS, ParenthesisColor) << ')';
+    }
+
     void visitSILBoxType(SILBoxType *T, StringRef label) {
       printCommon(label, "sil_box_type");
       // FIXME: Print the structure of the type.

lib/AST/ASTMangler.cpp

@@ -1448,7 +1448,9 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
 
       return;
     }
-
+    case TypeKind::SILMoveOnly:
+      // If we hit this, we just mangle the underlying name and move on.
+      llvm_unreachable("should never be mangled?");
     case TypeKind::SILBlockStorage:
       llvm_unreachable("should never be mangled");
   }

lib/AST/ASTPrinter.cpp

@@ -6193,6 +6193,11 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     }
   }
 
+  void visitSILMoveOnlyType(SILMoveOnlyType *T) {
+    Printer << "@moveOnly ";
+    printWithParensIfNotSimple(T->getInnerType());
+  }
+
   void visitArraySliceType(ArraySliceType *T) {
     Printer << "[";
     visit(T->getBaseType());

lib/AST/ExistentialGeneralization.cpp

@@ -175,6 +175,7 @@ class Generalizer : public CanTypeVisitor<Generalizer, Type> {
   INVALID_TO_GENERALIZE(SILBox)
   INVALID_TO_GENERALIZE(SILFunction)
   INVALID_TO_GENERALIZE(SILToken)
+  INVALID_TO_GENERALIZE(SILMoveOnly)
 #undef INVALID_TO_GENERALIZE
 
   /// Generalize the generic arguments of the given generic type.s