[move-only] Add a move only request to lookup if a ValueDecl is a "move only type".

I also created a SILType::isMoveOnly() helper that returns true if a type is
a move only wrapped type or a first class move only type. The verifier check
that move only types aren't copied in canonical SIL was rewired to use that as well.

Author: gottesmm

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/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,9 @@ SILType::getSingletonAggregateFieldType(SILModule &M,
 
   return SILType();
 }
+
+bool SILType::isMoveOnly() const {
+  if (auto *nom = getNominalOrBoundGenericNominal())
+    return nom->isMoveOnly();
+  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/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) {