[Concurrency] Diagnose ConcurrentValue restrictions on classes.

One cannot introduce ConcurrentValue conformance on a class
that has a (non-NSObject) superclass, nor put a ConcurrentValue
conformance on an open class.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4324,6 +4324,13 @@ ERROR(concurrent_value_outside_source_file,none,
       "conformance 'ConcurrentValue' must occur in the same source file as "
       "%0 %1; use 'UnsafeConcurrentValue' for retroactive conformance",
       (DescriptiveDeclKind, DeclName))
+ERROR(concurrent_value_open_class,none,
+      "open class %0 cannot conform to `ConcurrentValue`; "
+      "use `UnsafeConcurrentValue`", (DeclName))
+ERROR(concurrent_value_inherit,none,
+      "`ConcurrentValue` class %1 cannot inherit from another class"
+      "%select{| other than 'NSObject'}0",
+      (bool, DeclName))
 
 ERROR(actorindependent_let,none,
       "'@actorIndependent' is meaningless on 'let' declarations because "

lib/Sema/TypeCheckConcurrency.cpp

@@ -2305,10 +2305,12 @@ void swift::checkConcurrentValueConformance(ProtocolConformance *conformance) {
   if (!nominal)
     return;
 
-  // Actors implicitly conform to ConcurrentValue and protect their state.
   auto classDecl = dyn_cast<ClassDecl>(nominal);
-  if (classDecl && classDecl->isActor())
-    return;
+  if (classDecl) {
+    // Actors implicitly conform to ConcurrentValue and protect their state.
+    if (classDecl->isActor())
+      return;
+  }
 
   // ConcurrentValue can only be used in the same source file.
   auto conformanceDecl = conformanceDC->getAsDecl();
@@ -2320,6 +2322,29 @@ void swift::checkConcurrentValueConformance(ProtocolConformance *conformance) {
     return;
   }
 
+  if (classDecl) {
+    // An open class cannot conform to `ConcurrentValue`.
+    if (classDecl->getFormalAccess() == AccessLevel::Open) {
+      classDecl->diagnose(
+          diag::concurrent_value_open_class, classDecl->getName());
+      return;
+    }
+
+    // A 'ConcurrentValue' class cannot inherit from another class, although
+    // we allow `NSObject` for Objective-C interoperability.
+    if (!isa<InheritedProtocolConformance>(conformance)) {
+      if (auto superclassDecl = classDecl->getSuperclassDecl()) {
+        if (!superclassDecl->isNSObject()) {
+          classDecl->diagnose(
+              diag::concurrent_value_inherit,
+              nominal->getASTContext().LangOpts.EnableObjCInterop,
+              classDecl->getName());
+          return;
+        }
+      }
+    }
+  }
+
   // Stored properties of structs and classes must have
   // ConcurrentValue-conforming types.
   if (isa<StructDecl>(nominal) || classDecl) {

test/Concurrency/concurrent_value_checking.swift

@@ -221,9 +221,20 @@ class C5: UnsafeConcurrentValue {
 }
 
 class C6: C5 {
-  var y: Int = 0 // still okay
+  var y: Int = 0 // still okay, it's unsafe
 }
 
+class C7<T>: ConcurrentValue { }
+
+class C8: C7<Int> { } // okay
+
+open class C9: ConcurrentValue { } // expected-error{{open class 'C9' cannot conform to `ConcurrentValue`; use `UnsafeConcurrentValue`}}
+
+public class C10: ConcurrentValue { }
+// expected-note@-1{{superclass is declared here}}
+open class C11: C10 { }
+// expected-error@-1{{superclass 'C10' of open class must be open}}
+// expected-error@-2{{open class 'C11' cannot conform to `ConcurrentValue`; use `UnsafeConcurrentValue`}}
 
 // ----------------------------------------------------------------------
 // UnsafeConcurrentValue disabling checking

test/Concurrency/concurrent_value_checking_objc.swift

@@ -0,0 +1,22 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-concurrency -enable-experimental-concurrent-value-checking
+
+// REQUIRES: concurrency
+// REQUIRES: objc_interop
+
+import Foundation
+
+class A: NSObject, ConcurrentValue {
+  let x: Int = 5
+}
+
+class B: NSObject, ConcurrentValue {
+  var x: Int = 5 // expected-error{{stored property 'x' of 'ConcurrentValue'-conforming class 'B' is mutable}}
+}
+
+class C { }
+
+class D: NSObject, ConcurrentValue {
+  let c: C = C() // expected-error{{stored property 'c' of 'ConcurrentValue'-conforming class 'D' has non-concurrent-value type 'C'}}
+}
+
+