Merge pull request #59468 from gottesmm/pr-ca8c452eb2068fedf55ec81469906d60c22ab058

[move-only-wrapper] A few small mechanical fixes before the main no-implicit-copy rebase PR

Author: gottesmm

include/swift/SIL/AbstractionPattern.h

@@ -1257,11 +1257,11 @@ class AbstractionPattern {
 
   /// Given that the value being abstracted is a move only type, return the
   /// abstraction pattern with the move only bit removed.
-  AbstractionPattern withoutMoveOnly() const;
+  AbstractionPattern removingMoveOnlyWrapper() 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;
+  AbstractionPattern addingMoveOnlyWrapper() const;
 
   /// Given that the value being abstracted is a tuple type, return
   /// the abstraction pattern for its object type.

include/swift/SIL/SILBuilder.h

@@ -1299,14 +1299,16 @@ class SILBuilder {
   MoveOnlyWrapperToCopyableValueInst *
   createOwnedMoveOnlyWrapperToCopyableValue(SILLocation loc, SILValue src) {
     return insert(new (getModule()) MoveOnlyWrapperToCopyableValueInst(
-        *F, getSILDebugLocation(loc), src, OwnershipKind::Owned));
+        *F, getSILDebugLocation(loc), src,
+        MoveOnlyWrapperToCopyableValueInst::Owned));
   }
 
   MoveOnlyWrapperToCopyableValueInst *
   createGuaranteedMoveOnlyWrapperToCopyableValue(SILLocation loc,
                                                  SILValue src) {
     return insert(new (getModule()) MoveOnlyWrapperToCopyableValueInst(
-        *F, getSILDebugLocation(loc), src, OwnershipKind::Guaranteed));
+        *F, getSILDebugLocation(loc), src,
+        MoveOnlyWrapperToCopyableValueInst::Guaranteed));
   }
 
   UnconditionalCheckedCastInst *

include/swift/SIL/SILInstruction.h

@@ -7627,19 +7627,29 @@ class CopyableToMoveOnlyWrapperValueInst
 class MoveOnlyWrapperToCopyableValueInst
     : public UnaryInstructionBase<
           SILInstructionKind::MoveOnlyWrapperToCopyableValueInst,
-          SingleValueInstruction>,
-      public OwnershipForwardingMixin {
+          FirstArgOwnershipForwardingSingleValueInst> {
+public:
+  enum InitialKind {
+    Guaranteed,
+    Owned,
+  };
+
+private:
   friend class SILBuilder;
 
+  InitialKind initialKind;
+
   MoveOnlyWrapperToCopyableValueInst(const SILFunction &fn,
                                      SILDebugLocation DebugLoc,
-                                     SILValue operand,
-                                     OwnershipKind forwardingOwnershipKind)
-      : UnaryInstructionBase(DebugLoc, operand,
-                             operand->getType().removingMoveOnlyWrapper()),
-        OwnershipForwardingMixin(
-            SILInstructionKind::MoveOnlyWrapperToCopyableValueInst,
-            forwardingOwnershipKind) {}
+                                     SILValue operand, InitialKind kind)
+      : UnaryInstructionBase(
+            DebugLoc, operand, operand->getType().removingMoveOnlyWrapper(),
+            kind == InitialKind::Guaranteed ? OwnershipKind::Guaranteed
+                                            : OwnershipKind::Owned),
+        initialKind(kind) {}
+
+public:
+  InitialKind getInitialKind() const { return initialKind; }
 };
 
 /// Given an object reference, return true iff it is non-nil and refers
@@ -9783,8 +9793,7 @@ inline bool OwnershipForwardingMixin::isa(SILInstructionKind kind) {
          OwnershipForwardingConversionInst::classof(kind) ||
          OwnershipForwardingSelectEnumInstBase::classof(kind) ||
          OwnershipForwardingMultipleValueInstruction::classof(kind) ||
-         kind == SILInstructionKind::MarkMustCheckInst ||
-         kind == SILInstructionKind::MoveOnlyWrapperToCopyableValueInst;
+         kind == SILInstructionKind::MarkMustCheckInst;
 }
 
 inline OwnershipForwardingMixin *

include/swift/SIL/TypeLowering.h

@@ -296,7 +296,7 @@ class TypeLowering {
     IsInfiniteType_t isInfinite() const {
       return IsInfiniteType_t((Flags & InfiniteFlag) != 0);
     }
-    IsMoveOnly_t isMoveOnly() const {
+    IsMoveOnly_t isMoveOnlyWrapped() const {
       return IsMoveOnly_t((Flags & MoveOnlyFlag) != 0);
     }
 

lib/SIL/IR/AbstractionPattern.cpp

@@ -401,7 +401,7 @@ AbstractionPattern::getTupleElementType(unsigned index) const {
   llvm_unreachable("bad kind");
 }
 
-AbstractionPattern AbstractionPattern::withoutMoveOnly() const {
+AbstractionPattern AbstractionPattern::removingMoveOnlyWrapper() const {
   switch (getKind()) {
   case Kind::Invalid:
     llvm_unreachable("querying invalid abstraction pattern!");
@@ -435,7 +435,7 @@ AbstractionPattern AbstractionPattern::withoutMoveOnly() const {
   llvm_unreachable("bad kind");
 }
 
-AbstractionPattern AbstractionPattern::withMoveOnly() const {
+AbstractionPattern AbstractionPattern::addingMoveOnlyWrapper() const {
   switch (getKind()) {
   case Kind::Invalid:
     llvm_unreachable("querying invalid abstraction pattern!");

lib/SIL/IR/SILPrinter.cpp

@@ -1921,15 +1921,11 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
 
   void visitMoveOnlyWrapperToCopyableValueInst(
       MoveOnlyWrapperToCopyableValueInst *I) {
-    switch (I->getForwardingOwnershipKind()) {
-    case OwnershipKind::None:
-    case OwnershipKind::Any:
-    case OwnershipKind::Unowned:
-      llvm_unreachable("Move only values are always non-trivial");
-    case OwnershipKind::Owned:
+    switch (I->getInitialKind()) {
+    case MoveOnlyWrapperToCopyableValueInst::Owned:
       *this << "[owned] ";
       break;
-    case OwnershipKind::Guaranteed:
+    case MoveOnlyWrapperToCopyableValueInst::Guaranteed:
       *this << "[guaranteed] ";
       break;
     }

lib/SIL/IR/TypeLowering.cpp

@@ -697,7 +697,7 @@ namespace {
     RetTy visitSILMoveOnlyType(CanSILMoveOnlyType type,
                                AbstractionPattern origType,
                                IsTypeExpansionSensitive_t isSensitive) {
-      AbstractionPattern innerAbstraction = origType.withoutMoveOnly();
+      AbstractionPattern innerAbstraction = origType.removingMoveOnlyWrapper();
       CanType innerType = type->getInnerType();
       auto &lowering =
           TC.getTypeLowering(innerAbstraction, innerType, Expansion);
@@ -2558,7 +2558,11 @@ TypeConverter::getTypeLowering(SILType type,
                                CanGenericSignature sig) {
   // The type lowering for a type parameter relies on its context.
   assert(sig || !type.getASTType()->hasTypeParameter());
-  auto loweredType = type.getASTType();
+
+  // We use the Raw AST type to ensure that moveonlywrapped values use the move
+  // only type lowering. This ensures that trivial moveonlywrapped values are
+  // not trivial.
+  auto loweredType = type.getRawASTType();
   auto isTypeExpansionSensitive = loweredType->hasOpaqueArchetype()
                                       ? IsTypeExpansionSensitive
                                       : IsNotTypeExpansionSensitive;