[move-only] Ban creating protocol conformances on move only nominal types.

I added code to the type checker that both bans this when one adds the
conformance on the nominal type declaration as well as on extensions. I was
careful to ensure we can still add extensions without an inherited clause.

Doing this until we get the full generics model.

rdar://101874019

Author: gottesmm

include/swift/AST/DiagnosticsSema.def

@@ -6710,13 +6710,11 @@ NOTE(moveonly_copyable_type_that_contains_moveonly_type_location, none,
      "contained move-only %0 '%1.%2'",
      (DescriptiveDeclKind, StringRef, StringRef))
 ERROR(moveonly_cannot_conform_to_protocol, none,
-     "Move only type %0 cannot conform yet to any protocols",
-     (DeclName))
+     "move-only %0 %1 cannot conform yet to any protocols",
+     (DescriptiveDeclKind, DeclName))
 ERROR(moveonly_cannot_conform_to_protocol_with_name, none,
-     "Move only type %0 cannot conform to protocol %1. Move only types are "
-     "unable to conform to protocols yet",
-     (DeclName, DeclName))
-
+     "move-only %0 %1 cannot conform to protocol %2",
+     (DescriptiveDeclKind, DeclName, DeclName))
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -4470,6 +4470,13 @@ ProtocolConformance *GetImplicitSendableRequest::evaluate(
   if (isa<ProtocolDecl>(nominal))
     return nullptr;
 
+  // Move only nominal types are currently never sendable since we have not yet
+  // finished the generics model for them.
+  //
+  // TODO: Remove this once this is complete!
+  if (nominal->isMoveOnly())
+    return nullptr;
+
   // Actor types are always Sendable; they don't get it via this path.
   auto classDecl = dyn_cast<ClassDecl>(nominal);
   if (classDecl && classDecl->isActor())

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2492,6 +2492,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     }
 
     diagnoseCopyableTypeContainingMoveOnlyType(ED);
+    diagnoseMoveOnlyNominalDeclDoesntConformToProtocols(ED);
 
     checkExplicitAvailability(ED);
 
@@ -2535,6 +2536,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     // If this struct is not move only, check that all vardecls of nominal type
     // are not move only.
     diagnoseCopyableTypeContainingMoveOnlyType(SD);
+
+    diagnoseMoveOnlyNominalDeclDoesntConformToProtocols(SD);
   }
 
   /// Check whether the given properties can be @NSManaged in this class.
@@ -2636,6 +2639,17 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     }
   }
 
+  void diagnoseMoveOnlyNominalDeclDoesntConformToProtocols(
+      NominalTypeDecl *nomDecl) {
+    if (!nomDecl->isMoveOnly())
+      return;
+
+    for (auto *prot : nomDecl->getAllProtocols()) {
+      nomDecl->diagnose(diag::moveonly_cannot_conform_to_protocol_with_name,
+                        nomDecl->getDescriptiveKind(),
+                        nomDecl->getBaseName(), prot->getBaseName());
+    }
+  }
 
   void visitClassDecl(ClassDecl *CD) {
     checkUnsupportedNestedType(CD);
@@ -2799,6 +2813,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     TypeChecker::checkConformancesInContext(CD);
 
     maybeDiagnoseClassWithoutInitializers(CD);
+
+    diagnoseMoveOnlyNominalDeclDoesntConformToProtocols(CD);
   }
 
   void visitProtocolDecl(ProtocolDecl *PD) {
@@ -3253,6 +3269,12 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     if (nominal->isDistributedActor())
       TypeChecker::checkDistributedActor(SF, nominal);
+
+    // If we have a move only type and allow it to extend any protocol, error.
+    if (nominal->isMoveOnly() && ED->getInherited().size()) {
+      ED->diagnose(diag::moveonly_cannot_conform_to_protocol,
+                   nominal->getDescriptiveKind(), nominal->getBaseName());
+    }
   }
 
   void visitTopLevelCodeDecl(TopLevelCodeDecl *TLCD) {

test/Interpreter/moveonly_bufferview.swift

@@ -10,16 +10,15 @@
 public struct BufferView<T> {
     var ptr: UnsafeBufferPointer<T>
 
-    deinit {}
-}
-
-extension BufferView : Sequence {
-    public typealias Iterator = UnsafeBufferPointer<T>.Iterator
-    public typealias Element = UnsafeBufferPointer<T>.Element
+    var count: Int {
+        return ptr.count
+    }
 
-    public func makeIterator() -> Self.Iterator {
-        return ptr.makeIterator()
+    subscript(_ x: Int) -> T {
+        return ptr[x]
     }
+
+    deinit {}
 }
 
 extension Array {
@@ -36,8 +35,8 @@ func testBufferView(_ x: __owned [Int]) {
     // CHECK: 2
     // CHECK: 3
     y.withBufferView {
-        for x in $0 {
-            print(x)
+        for i in 0..<$0.count {
+            print($0[i])
         }
     }
 }
@@ -52,8 +51,8 @@ func testConditionalBufferView(_ x: __owned [Int]) {
         // CHECK: 5
         // CHECK: 6
         if getBool() {
-            for z in y {
-                print(z)
+            for i in 0..<y.count {
+                print(y[i])
             }
         }
     }

test/Sema/moveonly_restrictions.swift

@@ -132,3 +132,30 @@ struct UnsafePointerWithOwner<T> {
     func doNothing() {}
 }
 
+// Make sure we error whenever we attempt to conform a move only type to a
+// protocol.
+protocol P {}
+@_moveOnly class ProtocolCheckMoveOnlyKlass {} // expected-error {{move-only class 'ProtocolCheckMoveOnlyKlass' cannot conform to protocol 'P'}}
+@_moveOnly struct ProtocolCheckMoveOnlyStruct { // expected-error {{move-only struct 'ProtocolCheckMoveOnlyStruct' cannot conform to protocol 'P'}}
+    var k: MoveOnlyKlass
+}
+@_moveOnly enum ProtocolCheckMoveOnlyEnum {} // expected-error {{move-only enum 'ProtocolCheckMoveOnlyEnum' cannot conform to protocol 'P'}}
+
+extension ProtocolCheckMoveOnlyKlass : P {} // expected-error {{move-only class 'ProtocolCheckMoveOnlyKlass' cannot conform yet to any protocols}}
+extension ProtocolCheckMoveOnlyStruct : P {} // expected-error {{move-only struct 'ProtocolCheckMoveOnlyStruct' cannot conform yet to any protocols}}
+extension ProtocolCheckMoveOnlyEnum : P {} // expected-error {{move-only enum 'ProtocolCheckMoveOnlyEnum' cannot conform yet to any protocols}}
+
+// But a normal extension is ok.
+extension ProtocolCheckMoveOnlyKlass {}
+extension ProtocolCheckMoveOnlyStruct {}
+extension ProtocolCheckMoveOnlyEnum {}
+
+// Check if we define a move only type and make it conform on the base type
+@_moveOnly
+class MoveOnlyKlassP : P {} // expected-error {{move-only class 'MoveOnlyKlassP' cannot conform to protocol 'P'}}
+@_moveOnly
+struct MoveOnlyStructP : P { // expected-error {{move-only struct 'MoveOnlyStructP' cannot conform to protocol 'P'}}
+    var mv: MoveOnlyKlass
+}
+@_moveOnly
+enum MoveOnlyEnumP : P {} // expected-error {{move-only enum 'MoveOnlyEnumP' cannot conform to protocol 'P'}}