[sema] Ban user created read/set accessor that produce noncopyable types.

The reason why we are doing this is that this combination of read/set forces the
compiler to emit a copy if we want to emit a modify operation.

The reason why we are forced to emit such a copy is that:

1. _read provides a guaranteed value in memory
2. performing a modify requires an owned value in memory.

This together implies that the only way we can do this is to copy from the _read
into temporary memory. But we have a noncopyable type so we can't do this.

rdar://112915525

Author: gottesmm

include/swift/AST/DiagnosticsSema.def

@@ -7365,6 +7365,9 @@ ERROR(noncopyable_types_cannot_be_resilient, none,
       "non-@frozen public and @usableFromInline noncopyable types are not "
       "supported",
       (const ValueDecl *))
+ERROR(noncopyable_cannot_have_read_set_accessor,none,
+      "noncopyable %select{variable|subscript}0 cannot provide a read and set accessor",
+      (unsigned))
 
 //------------------------------------------------------------------------------
 // MARK: Runtime discoverable attributes (@runtimeMetadata)

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2479,10 +2479,11 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       }
     }
 
-    // If this is an init accessor property with a default initializer,
-    // make sure that it subsumes initializers of all of its "initializes"
-    // stored properties.
     if (auto *var = PBD->getSingleVar()) {
+
+      // If this is an init accessor property with a default initializer,
+      // make sure that it subsumes initializers of all of its "initializes"
+      // stored properties.
       auto *initAccessor = var->getAccessor(AccessorKind::Init);
       if (initAccessor && PBD->isInitialized(0)) {
         for (auto *property : initAccessor->getInitializedProperties()) {
@@ -2491,6 +2492,26 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
             propertyBinding->setInitializerSubsumed(0);
         }
       }
+
+      // If we have a pure noncopyable type, we cannot have explicit read/set
+      // accessors since this means that we cannot call mutating methods without
+      // copying. We do not want to support types that one cannot define a
+      // modify operation via a get/set or a modify.
+      if (var->getInterfaceType()->isPureMoveOnly()) {
+        if (auto *read = var->getAccessor(AccessorKind::Read)) {
+          if (!read->isImplicit()) {
+            if (auto *set = var->getAccessor(AccessorKind::Set)) {
+              if (!set->isImplicit()) {
+                var->diagnose(diag::noncopyable_cannot_have_read_set_accessor,
+                              0);
+                PBD->setInvalid();
+                var->setInvalid();
+                return;
+              }
+            }
+          }
+        }
+      }
     }
   }
 
@@ -2562,6 +2583,23 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
           .fixItReplace(SD->getStaticLoc(), "static");
     }
 
+    // Reject noncopyable typed subscripts with read/set accessors since we
+    // cannot define modify operations upon them without copying the read.
+    if (SD->getElementInterfaceType()->isPureMoveOnly()) {
+      if (auto *read = SD->getAccessor(AccessorKind::Read)) {
+        if (!read->isImplicit()) {
+          if (auto *set = SD->getAccessor(AccessorKind::Set)) {
+            if (!set->isImplicit()) {
+              SD->diagnose(diag::noncopyable_cannot_have_read_set_accessor,
+                           1);
+              SD->setInvalid();
+              return;
+            }
+          }
+        }
+      }
+    }
+
     // Now check all the accessors.
     SD->visitEmittedAccessors([&](AccessorDecl *accessor) {
       visit(accessor);