[no-implicit-copy] A few small patches to simplify a larger patch.

include/swift/AST/Types.h

@@ -5004,7 +5004,7 @@ DEFINE_EMPTY_CAN_TYPE_WRAPPER(SILBoxType, Type)
 
 class SILMoveOnlyWrappedType;
 class SILModule; // From SIL
-typedef CanTypeWrapper<SILMoveOnlyWrappedType> CanMoveOnlyType;
+typedef CanTypeWrapper<SILMoveOnlyWrappedType> CanSILMoveOnlyWrappedType;
 
 /// 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
@@ -5022,7 +5022,7 @@ class SILMoveOnlyWrappedType final : public TypeBase,
 public:
   CanType getInnerType() const { return innerType; }
 
-  static CanMoveOnlyType get(CanType innerType);
+  static CanSILMoveOnlyWrappedType get(CanType innerType);
 
   static bool classof(const TypeBase *T) {
     return T->getKind() == TypeKind::SILMoveOnlyWrapped;

include/swift/SIL/ApplySite.h

@@ -297,6 +297,11 @@ class ApplySite {
     getArgumentOperands()[i].set(V);
   }
 
+  void setCallee(SILValue V) const {
+    unsigned calleeIndex = getCalleeOperand()->getOperandNumber();
+    getInstruction()->getAllOperands()[calleeIndex].set(V);
+  }
+
   /// Return the operand index of the first applied argument.
   unsigned getOperandIndexOfFirstArgument() const {
     FOREACH_IMPL_RETURN(getArgumentOperandNumber());

include/swift/SIL/SILInstruction.h

@@ -7580,7 +7580,10 @@ class MarkMustCheckInst
       : UnaryInstructionBase(DebugLoc, operand, operand->getType()),
         OwnershipForwardingMixin(SILInstructionKind::MarkMustCheckInst,
                                  operand->getOwnershipKind()),
-        kind(checkKind) {}
+        kind(checkKind) {
+    assert(operand->getType().isMoveOnlyWrapped() &&
+           "mark_must_check can only take a move only wrapped value");
+  }
 
 public:
   CheckKind getCheckKind() const { return kind; }

include/swift/SIL/SILType.h

@@ -93,11 +93,11 @@ class SILParser;
 /// In addition to the Swift type system, SIL adds "address" types that can
 /// reference any Swift type (but cannot take the address of an address). *T
 /// is the type of an address pointing at T.
-///
 class SILType {
 public:
   /// The unsigned is a SILValueCategory.
   using ValueType = llvm::PointerIntPair<TypeBase *, 2, unsigned>;
+
 private:
   ValueType value;
 
@@ -151,7 +151,7 @@ class SILType {
 
   /// Returns the \p Category variant of this type.
   SILType getCategoryType(SILValueCategory Category) const {
-    return SILType(getASTType(), Category);
+    return SILType(getRawASTType(), Category);
   }
 
   /// Returns the variant of this type that matches \p Ty.getCategory()
@@ -194,7 +194,6 @@ class SILType {
     return removingMoveOnlyWrapper().getRawASTType();
   }
 
-private:
   /// 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()); }

lib/SILGen/SILGenBuilder.cpp

@@ -921,3 +921,25 @@ ManagedValue SILGenBuilder::createGuaranteedMoveOnlyWrapperToCopyableValue(
   assert(mdi->getOperand()->getType().isObject() && "Expected an object?!");
   return ManagedValue::forUnmanaged(mdi);
 }
+
+ManagedValue
+SILGenBuilder::createCopyableToMoveOnlyWrapperValue(SILLocation loc,
+                                                    ManagedValue value) {
+  assert(value.isPlusOne(SGF) && "Argument must be at +1!");
+  CleanupCloner cloner(*this, value);
+  SILValue v = value.forward(getSILGenFunction());
+  auto *mdi = SILBuilder::createCopyableToMoveOnlyWrapperValue(loc, v);
+  if (v->getType().isTrivial(getFunction()))
+    return SGF.emitManagedRValueWithCleanup(mdi);
+  return cloner.clone(mdi);
+}
+
+ManagedValue
+SILGenBuilder::createMarkMustCheckInst(SILLocation loc, ManagedValue value,
+                                       MarkMustCheckInst::CheckKind kind) {
+  assert(value.isPlusOne(SGF) && "Argument must be at +1!");
+  CleanupCloner cloner(*this, value);
+  auto *mdi = SILBuilder::createMarkMustCheckInst(
+      loc, value.forward(getSILGenFunction()), kind);
+  return cloner.clone(mdi);
+}

lib/SILGen/SILGenBuilder.h

@@ -28,6 +28,7 @@
 #include "RValue.h"
 #include "swift/Basic/ProfileCounter.h"
 #include "swift/SIL/SILBuilder.h"
+#include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILLocation.h"
 
 namespace swift {
@@ -414,6 +415,17 @@ class SILGenBuilder : public SILBuilder {
   ManagedValue
   createGuaranteedMoveOnlyWrapperToCopyableValue(SILLocation loc,
                                                  ManagedValue value);
+
+  using SILBuilder::createCopyableToMoveOnlyWrapperValue;
+  /// Create a copyable_to_moveonlywrapper. This expects a +1 value and returns
+  /// a +1 value. Semantically though the two things are different entities so
+  /// we are not forwarding ownership in the sense of the word.
+  ManagedValue createCopyableToMoveOnlyWrapperValue(SILLocation loc,
+                                                    ManagedValue value);
+
+  using SILBuilder::createMarkMustCheckInst;
+  ManagedValue createMarkMustCheckInst(SILLocation loc, ManagedValue value,
+                                       MarkMustCheckInst::CheckKind kind);
 };
 
 } // namespace Lowering

lib/SILGen/SILGenProlog.cpp

@@ -109,28 +109,29 @@ class EmitBBArguments : public CanTypeVisitor<EmitBBArguments,
 
     // This can happen if the value is resilient in the calling convention
     // but not resilient locally.
-    if (argType.isLoadable(SGF.F)) {
+    bool argIsLoadable = argType.isLoadable(SGF.F);
+    if (argIsLoadable) {
       if (argType.isAddress()) {
         if (mv.isPlusOne(SGF))
           mv = SGF.B.createLoadTake(loc, mv);
         else
           mv = SGF.B.createLoadBorrow(loc, mv);
         argType = argType.getObjectType();
       }
-    } else {
-      if (isNoImplicitCopy) {
-        // We do not support no implicit copy address only types. Emit an error.
-        auto diag = diag::noimplicitcopy_used_on_generic_or_existential;
-        diagnose(SGF.getASTContext(), mv.getValue().getLoc().getSourceLoc(),
-                 diag);
-      }
     }
 
     if (argType.getASTType() != paramType.getASTType()) {
       // Reabstract the value if necessary.
       mv = SGF.emitOrigToSubstValue(loc, mv.ensurePlusOne(SGF, loc), orig, t);
     }
 
+    if (isNoImplicitCopy && !argIsLoadable) {
+      // We do not support no implicit copy address only types. Emit an error.
+      auto diag = diag::noimplicitcopy_used_on_generic_or_existential;
+      diagnose(SGF.getASTContext(), mv.getValue().getLoc().getSourceLoc(),
+               diag);
+    }
+
     // If the value is a (possibly optional) ObjC block passed into the entry
     // point of the function, then copy it so we can treat the value reliably
     // as a heap object. Escape analysis can eliminate this copy if it's

lib/SILOptimizer/Mandatory/CMakeLists.txt

@@ -36,5 +36,5 @@ target_sources(swiftSILOptimizer PRIVATE
   YieldOnceCheck.cpp
   MandatoryCombine.cpp
   OSLogOptimization.cpp
-  MoveOnlyTypeEliminator.cpp
+  MoveOnlyWrappedTypeEliminator.cpp
   OwnershipModelEliminator.cpp)