[move-only] Implement very initial work for move only

include/swift/AST/Attr.def

@@ -735,6 +735,12 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(_local, KnownToBeLocal,
   APIBreakingToAdd | APIBreakingToRemove,
   130)
 
+SIMPLE_DECL_ATTR(_moveOnly, MoveOnly,
+  OnNominalType |
+  UserInaccessible |
+  ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
+  131)
+
 // If you're adding a new underscored attribute here, please document it in
 // docs/ReferenceGuides/UnderscoredAttributes.md.
 

include/swift/AST/Decl.h

@@ -2262,12 +2262,19 @@ class ValueDecl : public Decl {
     /// Whether this declaration produces an implicitly unwrapped
     /// optional result.
     unsigned isIUO : 1;
+
+    /// Whether the "isMoveOnly" bit has been computed yet.
+    unsigned isMoveOnlyComputed : 1;
+
+    /// Whether this declaration can not be copied and thus is move only.
+    unsigned isMoveOnly : 1;
   } LazySemanticInfo = { };
 
   friend class DynamicallyReplacedDeclRequest;
   friend class OverriddenDeclsRequest;
   friend class IsObjCRequest;
   friend class IsFinalRequest;
+  friend class IsMoveOnlyRequest;
   friend class IsDynamicRequest;
   friend class IsImplicitlyUnwrappedOptionalRequest;
   friend class InterfaceTypeRequest;
@@ -2542,6 +2549,9 @@ class ValueDecl : public Decl {
   /// Is this declaration 'final'?
   bool isFinal() const;
 
+  /// Is this declaration 'moveOnly'?
+  bool isMoveOnly() const;
+
   /// Is this declaration marked with 'dynamic'?
   bool isDynamic() const;
 

include/swift/AST/DiagnosticsSema.def

@@ -6396,5 +6396,8 @@ ERROR(concurrency_task_to_thread_model_global_actor_annotation,none,
       "annotating a type with a global actor %0 is not permitted within %1",
       (TypeRepr*, StringRef))
 
+ERROR(moveOnly_not_allowed_here,none,
+      "'moveOnly' may only be applied to classes, structs, and enums", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/TypeCheckRequests.h

@@ -395,6 +395,26 @@ class IsFinalRequest :
   void cacheResult(bool value) const;
 };
 
+/// Determine whether the given declaration is 'moveOnly'.
+class IsMoveOnlyRequest
+    : public SimpleRequest<IsMoveOnlyRequest, bool(ValueDecl *),
+                           RequestFlags::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  bool evaluate(Evaluator &evaluator, ValueDecl *decl) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<bool> getCachedResult() const;
+  void cacheResult(bool value) const;
+};
+
 /// Determine whether the given declaration is 'dynamic''.
 class IsDynamicRequest :
     public SimpleRequest<IsDynamicRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -207,6 +207,8 @@ SWIFT_REQUEST(TypeChecker, IsDynamicRequest, bool(ValueDecl *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsFinalRequest, bool(ValueDecl *), SeparatelyCached,
               NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, IsMoveOnlyRequest, bool(ValueDecl *), SeparatelyCached,
+              NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsGetterMutatingRequest, bool(AbstractStorageDecl *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsImplicitlyUnwrappedOptionalRequest,

include/swift/SIL/SILInstruction.h

@@ -7587,8 +7587,8 @@ class MarkMustCheckInst
         OwnershipForwardingMixin(SILInstructionKind::MarkMustCheckInst,
                                  operand->getOwnershipKind()),
         kind(checkKind) {
-    assert(operand->getType().isMoveOnlyWrapped() &&
-           "mark_must_check can only take a move only wrapped value");
+    assert(operand->getType().isMoveOnly() &&
+           "mark_must_check can only take a move only typed value");
   }
 
 public:

include/swift/SIL/SILType.h

@@ -601,6 +601,10 @@ class SILType {
   /// Returns true if this is the AnyObject SILType;
   bool isAnyObject() const { return getASTType()->isAnyObject(); }
 
+  /// Returns true if this type is a first class move only type or a move only
+  /// wrapped type.
+  bool isMoveOnly() const;
+
   /// 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

lib/AST/Decl.cpp

@@ -3102,6 +3102,12 @@ bool ValueDecl::isFinal() const {
                            getAttrs().hasAttribute<FinalAttr>());
 }
 
+bool ValueDecl::isMoveOnly() const {
+  return evaluateOrDefault(getASTContext().evaluator,
+                           IsMoveOnlyRequest{const_cast<ValueDecl *>(this)},
+                           getAttrs().hasAttribute<MoveOnlyAttr>());
+}
+
 bool ValueDecl::isDynamic() const {
   ASTContext &ctx = getASTContext();
   return evaluateOrDefault(ctx.evaluator,

lib/AST/TypeCheckRequests.cpp

@@ -305,6 +305,29 @@ void IsFinalRequest::cacheResult(bool value) const {
     decl->getAttrs().add(new (decl->getASTContext()) FinalAttr(/*Implicit=*/true));
 }
 
+//----------------------------------------------------------------------------//
+// isMoveOnly computation.
+//----------------------------------------------------------------------------//
+
+Optional<bool> IsMoveOnlyRequest::getCachedResult() const {
+  auto decl = std::get<0>(getStorage());
+  if (decl->LazySemanticInfo.isMoveOnlyComputed)
+    return decl->LazySemanticInfo.isMoveOnly;
+
+  return None;
+}
+
+void IsMoveOnlyRequest::cacheResult(bool value) const {
+  auto decl = std::get<0>(getStorage());
+  decl->LazySemanticInfo.isMoveOnlyComputed = true;
+  decl->LazySemanticInfo.isMoveOnly = value;
+
+  // Add an attribute for printing
+  if (value && !decl->getAttrs().hasAttribute<MoveOnlyAttr>())
+    decl->getAttrs().add(new (decl->getASTContext())
+                             MoveOnlyAttr(/*Implicit=*/true));
+}
+
 //----------------------------------------------------------------------------//
 // isDynamic computation.
 //----------------------------------------------------------------------------//

lib/SIL/IR/SILType.cpp

@@ -924,3 +924,11 @@ SILType::getSingletonAggregateFieldType(SILModule &M,
 
   return SILType();
 }
+
+// TODO: Create isPureMoveOnly.
+bool SILType::isMoveOnly() const {
+  if (auto *nom = getNominalOrBoundGenericNominal())
+    if (nom->isMoveOnly())
+      return true;
+  return isMoveOnlyWrapped();
+}

lib/SIL/Verifier/SILVerifier.cpp

@@ -2701,8 +2701,8 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
             "copy_value is only valid in functions with qualified "
             "ownership");
     require(I->getModule().getStage() == SILStage::Raw ||
-                !I->getOperand()->getType().isMoveOnlyWrapped(),
-            "@moveOnly types can only be copied in Raw SIL?!");
+                !I->getOperand()->getType().isMoveOnly(),
+            "'MoveOnly' types can only be copied in Raw SIL?!");
   }
 
   void checkDestroyValueInst(DestroyValueInst *I) {

lib/SILGen/SILGenConstructor.cpp

@@ -26,6 +26,7 @@
 #include "swift/AST/PropertyWrappers.h"
 #include "swift/Basic/Defer.h"
 #include "swift/SIL/SILArgument.h"
+#include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILUndef.h"
 #include "swift/SIL/TypeLowering.h"
 
@@ -386,6 +387,7 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
 
   // Allocate the local variable for 'self'.
   emitLocalVariableWithCleanup(selfDecl, MUIKind)->finishInitialization(*this);
+
   SILValue selfLV = VarLocs[selfDecl].value;
 
   // Emit the prolog.
@@ -831,6 +833,11 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
                                 StoreOwnershipQualifier::Init);
     } else {
       selfArg = B.createMarkUninitialized(selfDecl, selfArg, MUKind);
+      if (selfArg.getType().isMoveOnly()) {
+        assert(selfArg.getOwnershipKind() == OwnershipKind::Owned);
+        selfArg = B.createMarkMustCheckInst(
+            selfDecl, selfArg, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+      }
       VarLocs[selfDecl] = VarLoc::get(selfArg.getValue());
     }
   }

lib/SILGen/SILGenDecl.cpp

@@ -572,15 +572,21 @@ class LetValueInitialization : public Initialization {
           // why we want this is even if we are only performing a borrow for our
           // lexical lifetime, we want to ensure that our defs see this
           // initialization as consuming this value.
-          if (value->getType().isMoveOnlyWrapped() &&
-              value->getOwnershipKind() == OwnershipKind::Owned) {
+          if (value->getOwnershipKind() == OwnershipKind::Owned) {
             assert(wasPlusOne);
             // NOTE: If our type is trivial when not wrapped in a
             // SILMoveOnlyWrappedType, this will return a trivial value. We rely
             // on the checker to determine if this is an acceptable use of the
             // value.
-            value = SGF.B.createOwnedMoveOnlyWrapperToCopyableValue(PrologueLoc,
-                                                                    value);
+            if (value->getType().isMoveOnly()) {
+              if (value->getType().isMoveOnlyWrapped()) {
+                value = SGF.B.createOwnedMoveOnlyWrapperToCopyableValue(
+                    PrologueLoc, value);
+              } else {
+                // Change this to be lexical and get rid of borrow scope?
+                value = SGF.B.createMoveValue(PrologueLoc, value);
+              }
+            }
           }
 
           // If we still have a non-trivial thing, emit code that will need to

lib/SILGen/SILGenPattern.cpp

@@ -2835,9 +2835,13 @@ void SILGenFunction::emitSwitchStmt(SwitchStmt *S) {
   auto subject = ([&]() -> ConsumableManagedValue {
     // If we have a move only value, ensure plus one and convert it. Switches
     // always consume move only values.
-    if (subjectMV.getType().isMoveOnlyWrapped()) {
-      subjectMV = B.createOwnedMoveOnlyWrapperToCopyableValue(
-          S, subjectMV.ensurePlusOne(*this, S));
+    if (subjectMV.getType().isMoveOnly()) {
+      if (subjectMV.getType().isMoveOnlyWrapped()) {
+        subjectMV = B.createOwnedMoveOnlyWrapperToCopyableValue(
+            S, subjectMV.ensurePlusOne(*this, S));
+      } else {
+        subjectMV = B.createMoveValue(S, subjectMV.ensurePlusOne(*this, S));
+      }
     }
 
     // If we have a plus one value...

lib/SILGen/SILGenProlog.cpp

@@ -314,6 +314,20 @@ struct ArgumentInitHelper {
                 loc, value, MarkMustCheckInst::CheckKind::NoImplicitCopy);
             SGF.emitManagedRValueWithCleanup(value);
           }
+        } else if (value->getType().isMoveOnly()) {
+          if (value->getOwnershipKind() == OwnershipKind::Owned) {
+            value = SGF.B.createMoveValue(loc, argrv.forward(SGF),
+                                          /*isLexical*/ true);
+            value = SGF.B.createMarkMustCheckInst(
+                loc, value, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+            SGF.emitManagedRValueWithCleanup(value);
+          } else {
+            assert(value->getOwnershipKind() == OwnershipKind::Guaranteed);
+            value = SGF.B.createCopyValue(loc, value);
+            value = SGF.B.createMarkMustCheckInst(
+                loc, value, MarkMustCheckInst::CheckKind::NoCopy);
+            SGF.emitManagedRValueWithCleanup(value);
+          }
         } else {
           if (value->getOwnershipKind() == OwnershipKind::Owned) {
             value = SILValue(

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp

@@ -11,12 +11,14 @@
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "definite-init"
+
 #include "DIMemoryUseCollector.h"
 #include "swift/AST/Expr.h"
 #include "swift/SIL/ApplySite.h"
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILBuilder.h"
+#include "swift/SIL/SILInstruction.h"
 #include "swift/SILOptimizer/Utils/DistributedActor.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Debug.h"
@@ -1211,6 +1213,7 @@ void ElementUseCollector::collectClassSelfUses(SILValue ClassPointer) {
       Uses.append(beginAccess->getUses().begin(), beginAccess->getUses().end());
       continue;
     }
+
     if (isa<EndAccessInst>(User))
       continue;
 
@@ -1489,9 +1492,9 @@ void ElementUseCollector::collectClassSelfUses(
 
     // Look through begin_borrow, upcast, unchecked_ref_cast
     // and copy_value.
-    if (isa<BeginBorrowInst>(User) || isa<BeginAccessInst>(User)
-        || isa<UpcastInst>(User) || isa<UncheckedRefCastInst>(User)
-        || isa<CopyValueInst>(User)) {
+    if (isa<BeginBorrowInst>(User) || isa<BeginAccessInst>(User) ||
+        isa<UpcastInst>(User) || isa<UncheckedRefCastInst>(User) ||
+        isa<CopyValueInst>(User) || isa<MarkMustCheckInst>(User)) {
       auto value = cast<SingleValueInstruction>(User);
       std::copy(value->use_begin(), value->use_end(),
                 std::back_inserter(Worklist));

lib/SILOptimizer/Mandatory/MoveOnlyChecker.cpp

@@ -543,6 +543,46 @@ bool MoveOnlyChecker::searchForCandidateMarkMustChecks() {
       if (!mmci || !mmci->hasMoveCheckerKind())
         continue;
 
+      // Handle guaranteed/owned move only typed arguments.
+      //
+      // We are pattern matching against these patterns:
+      //
+      // bb0(%0 : @guaranteed $T):
+      //   %1 = copy_value %0
+      //   %2 = mark_must_check [no_copy] %1
+      // bb0(%0 : @owned $T):
+      //   %1 = copy_value %0
+      //   %2 = mark_must_check [no_copy] %1
+      if (mmci->getOperand()->getType().isMoveOnly() &&
+          !mmci->getOperand()->getType().isMoveOnlyWrapped()) {
+        if (auto *cvi = dyn_cast<CopyValueInst>(mmci->getOperand())) {
+          if (auto *arg = dyn_cast<SILFunctionArgument>(cvi->getOperand())) {
+            if (arg->getOwnershipKind() == OwnershipKind::Guaranteed) {
+              moveIntroducersToProcess.insert(mmci);
+              continue;
+            }
+          }
+        }
+
+        if (auto *mvi = dyn_cast<MoveValueInst>(mmci->getOperand())) {
+          if (mvi->isLexical()) {
+            if (auto *arg = dyn_cast<SILFunctionArgument>(mvi->getOperand())) {
+              if (arg->getOwnershipKind() == OwnershipKind::Owned) {
+                moveIntroducersToProcess.insert(mmci);
+                continue;
+              }
+            }
+          }
+        }
+
+        if (auto *arg = dyn_cast<SILFunctionArgument>(mmci->getOperand())) {
+          if (arg->getOwnershipKind() == OwnershipKind::Owned) {
+            moveIntroducersToProcess.insert(mmci);
+            continue;
+          }
+        }
+      }
+
       // Handle guaranteed arguments.
       //
       // We are pattern matching this pattern:

lib/Sema/TypeCheckAttr.cpp

@@ -218,6 +218,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   }
 
   void visitFinalAttr(FinalAttr *attr);
+  void visitMoveOnlyAttr(MoveOnlyAttr *attr);
   void visitCompileTimeConstAttr(CompileTimeConstAttr *attr) {}
   void visitIBActionAttr(IBActionAttr *attr);
   void visitIBSegueActionAttr(IBSegueActionAttr *attr);
@@ -1909,6 +1910,14 @@ void AttributeChecker::visitFinalAttr(FinalAttr *attr) {
   }
 }
 
+void AttributeChecker::visitMoveOnlyAttr(MoveOnlyAttr *attr) {
+  if (isa<NominalTypeDecl>(D))
+    return;
+
+  diagnose(attr->getLocation(), diag::moveOnly_not_allowed_here)
+    .fixItRemove(attr->getRange());
+}
+
 /// Return true if this is a builtin operator that cannot be defined in user
 /// code.
 static bool isBuiltinOperator(StringRef name, DeclAttribute *attr) {