[move-only] Add copyable_to_moveonlywrapper and moveonlywrapper_to_copyable instructions.

These instructions have the following attributes:

1. copyably_to_moveonlywrapper takes in a 'T' and maps it to a '@moveOnly
T'. This is semantically used when initializing a new moveOnly binding from a
copyable value. It semantically destroys its input @owned value and returns a
brand new independent @owned @moveOnly value. It also is used to convert a
trivial copyable value with type 'Trivial' into an owned non-trivial value of
type '@moveOnly Trivial'. If one thinks of '@moveOnly' as a monad, this is how
one injects a copyable value into the move only space.

2. moveonlywrapper_to_copyable takes in a '@moveOnly T' and produces a new 'T'
value. This is a 'forwarding' instruction where at parse time, we only allow for
one to choose it to be [owned] or [guaranteed].

* moveonlywrapper_to_copyable [owned] is used to signal the end of lifetime of
the '@moveOnly' wrapper. SILGen inserts these when ever a move only value has
its ownership passed to a situation where a copyable value is needed. Since it
is consuming, we know that the no implicit copy checker will ensure that if we
need a copy for it, the program will emit a diagnostic.

* moveonlywrapper_to_copyable [guaranteed] is used to pass a @moveOnly T value
as a copyable guaranteed parameter with type 'T' to a function. In the case of
using no-implicit-copy checking this is always fine since no-implicit-copy is a
local pattern. This would be an error when performing no escape
checking. Importantly, this instruction also is where in the case of an
@moveOnly trivial type, we convert from the non-trivial representation to the
trivial representation.

Some important notes:

1. In a forthcoming commit, I am going to rebase the no implicit copy checker on
top of these instructions. By using '@moveOnly' in the type system, we can
ensure that later in the SIL pipeline, we can have optimizations easily ignore
the code.

2. Be aware of is that due to SILGen only emitting '@moveOnly T' along immediate
accesses to the variable and always converts to a copyable representation when
calling other code, we can simply eliminate from the IR all moveonly-ness from
the IR using a lowering pass (that I am going to upstream). In the evil scheme
we are accomplishing here, we perform lowering of trivial values right after
ownership lowering and before diagnostics to simplify the pipeline.

On another note, I also fixed a few things in SILParsing around getASTType() vs
getRawASTType().

Author: gottesmm

include/swift/AST/DiagnosticsParse.def

@@ -655,6 +655,10 @@ ERROR(sil_markmustcheck_invalid_attribute,none,
       "Attribute '[%0]' can not be applied to mark_value_as_moveonly", (StringRef))
 ERROR(sil_markmustcheck_requires_attribute,none,
       "mark_must_check requires an attribute like 'noImplicitCopy'", ())
+ERROR(sil_moveonlytocopyable_invalid_attribute,none,
+      "Attribute '[%0]' can not be applied to moveonly_to_copyable", (StringRef))
+ERROR(sil_moveonlytocopyable_requires_attribute,none,
+      "moveonly_to_copyable requires either a [guaranteed] or [owned] attribute", ())
 
 // SIL Basic Blocks
 ERROR(expected_sil_block_name,none,

include/swift/SIL/SILBuilder.h

@@ -17,6 +17,7 @@
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILDebugScope.h"
 #include "swift/SIL/SILFunction.h"
+#include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILModule.h"
 #include "swift/SIL/SILUndef.h"
 #include "llvm/ADT/PointerUnion.h"
@@ -1289,6 +1290,24 @@ class SILBuilder {
                       MarkMustCheckInst(getSILDebugLocation(loc), src, kind));
   }
 
+  CopyableToMoveOnlyValueInst *createCopyableToMoveOnlyValue(SILLocation loc,
+                                                             SILValue src) {
+    return insert(new (getModule()) CopyableToMoveOnlyValueInst(
+        getSILDebugLocation(loc), src));
+  }
+
+  MoveOnlyToCopyableValueInst *
+  createOwnedMoveOnlyToCopyableValue(SILLocation loc, SILValue src) {
+    return insert(new (getModule()) MoveOnlyToCopyableValueInst(
+        *F, getSILDebugLocation(loc), src, OwnershipKind::Owned));
+  }
+
+  MoveOnlyToCopyableValueInst *
+  createGuaranteedMoveOnlyToCopyableValue(SILLocation loc, SILValue src) {
+    return insert(new (getModule()) MoveOnlyToCopyableValueInst(
+        *F, getSILDebugLocation(loc), src, OwnershipKind::Guaranteed));
+  }
+
   UnconditionalCheckedCastInst *
   createUnconditionalCheckedCast(SILLocation Loc, SILValue op,
                                  SILType destLoweredTy,

include/swift/SIL/SILCloner.h

@@ -24,6 +24,7 @@
 #include "swift/SIL/Dominance.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILDebugScope.h"
+#include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILVisitor.h"
 
 namespace swift {
@@ -1769,6 +1770,31 @@ void SILCloner<ImplClass>::visitMarkMustCheckInst(MarkMustCheckInst *Inst) {
   recordClonedInstruction(Inst, MVI);
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitMoveOnlyToCopyableValueInst(
+    MoveOnlyToCopyableValueInst *inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(inst->getDebugScope()));
+  MoveOnlyToCopyableValueInst *cvt;
+  if (inst->getOwnershipKind() == OwnershipKind::Owned) {
+    cvt = getBuilder().createOwnedMoveOnlyToCopyableValue(
+        getOpLocation(inst->getLoc()), getOpValue(inst->getOperand()));
+  } else {
+    assert(inst->getOwnershipKind() == OwnershipKind::Guaranteed);
+    cvt = getBuilder().createGuaranteedMoveOnlyToCopyableValue(
+        getOpLocation(inst->getLoc()), getOpValue(inst->getOperand()));
+  }
+  recordClonedInstruction(inst, cvt);
+}
+
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitCopyableToMoveOnlyValueInst(
+    CopyableToMoveOnlyValueInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  auto *MVI = getBuilder().createCopyableToMoveOnlyValue(
+      getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand()));
+  recordClonedInstruction(Inst, MVI);
+}
+
 template <typename ImplClass>
 void SILCloner<ImplClass>::visitReleaseValueInst(ReleaseValueInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));

include/swift/SIL/SILInstruction.h

@@ -1316,6 +1316,7 @@ FirstArgOwnershipForwardingSingleValueInst::classof(SILInstructionKind kind) {
   case SILInstructionKind::OpenExistentialRefInst:
   case SILInstructionKind::InitExistentialRefInst:
   case SILInstructionKind::MarkDependenceInst:
+  case SILInstructionKind::MoveOnlyToCopyableValueInst:
     return true;
   default:
     return false;
@@ -7587,6 +7588,58 @@ class MarkMustCheckInst
   bool isNoImplicitCopy() const { return kind == CheckKind::NoImplicitCopy; }
 };
 
+class CopyableToMoveOnlyValueInst
+    : public UnaryInstructionBase<
+          SILInstructionKind::CopyableToMoveOnlyValueInst,
+          SingleValueInstruction> {
+  friend class SILBuilder;
+
+  CopyableToMoveOnlyValueInst(SILDebugLocation DebugLoc, SILValue operand)
+      : UnaryInstructionBase(DebugLoc, operand,
+                             operand->getType().addingMoveOnlyWrapper()) {}
+};
+
+/// Convert from an @moveOnly wrapper type to the underlying copyable type. Can
+/// be either owned or guaranteed.
+///
+/// IMPORTANT: Unlike other forwarding instructions, the ownership of moveonly
+/// to copyable is not forwarded from the operand. Instead in SILBuilder one
+/// must select the specific type of ownership one wishes by using the following
+/// APIs:
+///
+/// * SILBuilder::createOwnedMoveOnlyToCopyableValueInst
+/// * SILBuilder::createGuaranteedMoveOnlyToCopyableValueInst
+///
+/// The reason why this instruction was designed in this manner is that a
+/// frontend chooses the ownership form of this instruction based off of the
+/// semantic place that the value is used. As an example:
+///
+/// 1. When calling a function semantically with guaranteed ownership, the
+///    frontend would use the "guaranteed variant".
+///
+/// 2. When returning a value or assigning into another binding, a frontend
+///    would want to use the owned variant so that the move only checker will
+///    enforce the end of the moved value's lifetime.
+///
+/// NOTE: With time, we are going to eliminate the guaranteed form of this
+/// instruction in favor of a function conversion instruction.
+class MoveOnlyToCopyableValueInst
+    : public UnaryInstructionBase<
+          SILInstructionKind::MoveOnlyToCopyableValueInst,
+          SingleValueInstruction>,
+      public OwnershipForwardingMixin {
+  friend class SILBuilder;
+
+  MoveOnlyToCopyableValueInst(const SILFunction &fn, SILDebugLocation DebugLoc,
+                              SILValue operand,
+                              OwnershipKind forwardingOwnershipKind)
+      : UnaryInstructionBase(DebugLoc, operand,
+                             operand->getType().removingMoveOnlyWrapper()),
+        OwnershipForwardingMixin(
+            SILInstructionKind::MoveOnlyToCopyableValueInst,
+            forwardingOwnershipKind) {}
+};
+
 /// Given an object reference, return true iff it is non-nil and refers
 /// to a native swift object with strong reference count of 1.
 class IsUniqueInst
@@ -9728,7 +9781,8 @@ inline bool OwnershipForwardingMixin::isa(SILInstructionKind kind) {
          OwnershipForwardingConversionInst::classof(kind) ||
          OwnershipForwardingSelectEnumInstBase::classof(kind) ||
          OwnershipForwardingMultipleValueInstruction::classof(kind) ||
-         kind == SILInstructionKind::MarkMustCheckInst;
+         kind == SILInstructionKind::MarkMustCheckInst ||
+         kind == SILInstructionKind::MoveOnlyToCopyableValueInst;
 }
 
 inline OwnershipForwardingMixin *
@@ -9752,6 +9806,8 @@ OwnershipForwardingMixin::get(SILInstruction *inst) {
     return result;
   if (auto *result = dyn_cast<MarkMustCheckInst>(inst))
     return result;
+  if (auto *result = dyn_cast<MoveOnlyToCopyableValueInst>(inst))
+    return result;
   return nullptr;
 }
 

include/swift/SIL/SILNodes.def

@@ -473,6 +473,15 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
   // running the relevant diagnostic.
   SINGLE_VALUE_INST(MarkMustCheckInst, mark_must_check,
                     SingleValueInstruction, None, DoesNotRelease)
+  // Convert a $T to $@moveOnly T. This is the method that one uses to convert a
+  // trivial value to a non-trivial move only value.
+  SINGLE_VALUE_INST(CopyableToMoveOnlyValueInst, copyable_to_moveonly,
+                    SingleValueInstruction, None, DoesNotRelease)
+  // Convert a $@moveOnly T to $T. Ownership is fixed at construction by
+  // frontend to express specific semantics: guaranteed for function arguments
+  // and owned for assignment/return values.
+  SINGLE_VALUE_INST(MoveOnlyToCopyableValueInst, moveonly_to_copyable,
+                    SingleValueInstruction, None, DoesNotRelease)
   // A move_addr is a Raw SIL only instruction that is equivalent to a copy_addr
   // [init]. It is lowered during the diagnostic passes to a copy_addr [init] if
   // the move checker found uses that prevented us from converting this to a

include/swift/SIL/SILType.h

@@ -87,6 +87,7 @@ enum class SILValueCategory : uint8_t {
 };
 
 class SILPrinter;
+class SILParser;
 
 /// SILType - A Swift type that has been lowered to a SIL representation type.
 /// In addition to the Swift type system, SIL adds "address" types that can
@@ -116,6 +117,7 @@ class SILType {
   friend class Lowering::TypeConverter;
   friend struct llvm::DenseMapInfo<SILType>;
   friend class SILPrinter;
+  friend class SILParser;
 
 public:
   SILType() = default;
@@ -160,13 +162,13 @@ class SILType {
   /// Returns the address variant of this type.  Instructions which
   /// manipulate memory will generally work with object addresses.
   SILType getAddressType() const {
-    return SILType(getASTType(), SILValueCategory::Address);
+    return SILType(getRawASTType(), SILValueCategory::Address);
   }
 
   /// Returns the object variant of this type.  Note that address-only
   /// types are not legal to manipulate directly as objects in SIL.
   SILType getObjectType() const {
-    return SILType(getASTType(), SILValueCategory::Object);
+    return SILType(getRawASTType(), SILValueCategory::Object);
   }
 
   /// Returns the canonical AST type referenced by this SIL type.

lib/IRGen/IRGenSIL.cpp

@@ -29,13 +29,14 @@
 #include "swift/Basic/STLExtras.h"
 #include "swift/IRGen/Linking.h"
 #include "swift/SIL/ApplySite.h"
+#include "swift/SIL/BasicBlockDatastructures.h"
 #include "swift/SIL/Dominance.h"
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/MemAccessUtils.h"
 #include "swift/SIL/PrettyStackTrace.h"
-#include "swift/SIL/BasicBlockDatastructures.h"
 #include "swift/SIL/SILDebugScope.h"
 #include "swift/SIL/SILDeclRef.h"
+#include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILLinkage.h"
 #include "swift/SIL/SILModule.h"
 #include "swift/SIL/SILType.h"
@@ -1190,6 +1191,14 @@ class IRGenSILFunction :
   void visitMarkMustCheckInst(MarkMustCheckInst *i) {
     llvm_unreachable("Invalid in Lowered SIL");
   }
+  void visitCopyableToMoveOnlyValueInst(CopyableToMoveOnlyValueInst *i) {
+    auto e = getLoweredExplosion(i->getOperand());
+    setLoweredExplosion(i, e);
+  }
+  void visitMoveOnlyToCopyableValueInst(MoveOnlyToCopyableValueInst *i) {
+    auto e = getLoweredExplosion(i->getOperand());
+    setLoweredExplosion(i, e);
+  }
   void visitReleaseValueInst(ReleaseValueInst *i);
   void visitReleaseValueAddrInst(ReleaseValueAddrInst *i);
   void visitDestroyValueInst(DestroyValueInst *i);

lib/SIL/IR/OperandOwnership.cpp

@@ -256,6 +256,7 @@ OPERAND_OWNERSHIP(DestroyingConsume, EndCOWMutation)
 
 // TODO: Should this be a forwarding consume.
 OPERAND_OWNERSHIP(DestroyingConsume, MoveValue)
+OPERAND_OWNERSHIP(DestroyingConsume, CopyableToMoveOnlyValue)
 
 // Instructions that move an owned value.
 OPERAND_OWNERSHIP(ForwardingConsume, InitExistentialValue)
@@ -328,6 +329,7 @@ FORWARDING_OWNERSHIP(InitExistentialRef)
 FORWARDING_OWNERSHIP(DifferentiableFunction)
 FORWARDING_OWNERSHIP(LinearFunction)
 FORWARDING_OWNERSHIP(MarkMustCheck)
+FORWARDING_OWNERSHIP(MoveOnlyToCopyableValue)
 #undef FORWARDING_OWNERSHIP
 
 // Arbitrary value casts are forwarding instructions that are also allowed to

lib/SIL/IR/SILPrinter.cpp

@@ -23,15 +23,16 @@
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/QuotedString.h"
-#include "swift/Basic/SourceManager.h"
 #include "swift/Basic/STLExtras.h"
+#include "swift/Basic/SourceManager.h"
 #include "swift/Demangling/Demangle.h"
 #include "swift/SIL/ApplySite.h"
 #include "swift/SIL/CFG.h"
 #include "swift/SIL/SILCoverageMap.h"
 #include "swift/SIL/SILDebugScope.h"
 #include "swift/SIL/SILDeclRef.h"
 #include "swift/SIL/SILFunction.h"
+#include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILModule.h"
 #include "swift/SIL/SILPrintContext.h"
 #include "swift/SIL/SILVTable.h"
@@ -1913,6 +1914,26 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     *this << getIDAndType(I->getOperand());
   }
 
+  void visitCopyableToMoveOnlyValueInst(CopyableToMoveOnlyValueInst *I) {
+    *this << getIDAndType(I->getOperand());
+  }
+
+  void visitMoveOnlyToCopyableValueInst(MoveOnlyToCopyableValueInst *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:
+      *this << "[owned] ";
+      break;
+    case OwnershipKind::Guaranteed:
+      *this << "[guaranteed] ";
+      break;
+    }
+    *this << getIDAndType(I->getOperand());
+  }
+
 #define UNCHECKED_REF_STORAGE(Name, ...)                                       \
   void visitStrongCopy##Name##ValueInst(StrongCopy##Name##ValueInst *I) {      \
     *this << getIDAndType(I->getOperand());                                    \

lib/SIL/IR/ValueOwnership.cpp

@@ -75,6 +75,7 @@ CONSTANT_OWNERSHIP_INST(Owned, CopyBlockWithoutEscaping)
 CONSTANT_OWNERSHIP_INST(Owned, CopyValue)
 CONSTANT_OWNERSHIP_INST(Owned, ExplicitCopyValue)
 CONSTANT_OWNERSHIP_INST(Owned, MoveValue)
+CONSTANT_OWNERSHIP_INST(Owned, CopyableToMoveOnlyValue)
 CONSTANT_OWNERSHIP_INST(Owned, EndCOWMutation)
 CONSTANT_OWNERSHIP_INST(Owned, KeyPath)
 CONSTANT_OWNERSHIP_INST(Owned, InitExistentialValue)
@@ -275,6 +276,7 @@ FORWARDING_OWNERSHIP_INST(InitExistentialRef)
 FORWARDING_OWNERSHIP_INST(DifferentiableFunction)
 FORWARDING_OWNERSHIP_INST(LinearFunction)
 FORWARDING_OWNERSHIP_INST(MarkMustCheck)
+FORWARDING_OWNERSHIP_INST(MoveOnlyToCopyableValue)
 #undef FORWARDING_OWNERSHIP_INST
 
 ValueOwnershipKind