[HasNoncopyableAnnotationRequest] handle where

Adds rudiementary support for searching `where` clauses for `~Copyable`
constraints, but the implementation is known to have flaws.

Author: kavon

lib/Sema/TypeCheckDecl.cpp

@@ -942,21 +942,6 @@ bool HasNoncopyableAnnotationRequest::evaluate(Evaluator &evaluator, TypeDecl *d
 
   assert(isa<NominalTypeDecl>(decl) && "todo: handle non-nominals");
 
-  // For protocols, inspect its generic signature for a Copyable requirement
-  if (auto *proto = dyn_cast<ProtocolDecl>(decl)) {
-    auto *copyableProto = ctx.getProtocol(KnownProtocolKind::Copyable);
-    if (!copyableProto)
-      llvm_unreachable("missing Copyable protocol!");
-
-    auto sig = proto->getGenericSignature();
-    auto requiresCopyable =
-        sig->requiresProtocol(proto->getSelfInterfaceType(), copyableProto);
-
-    // TODO: report that something implied Copyable despite writing ~Copyable?
-
-    return !requiresCopyable;
-  }
-
   // Handle the legacy '@_moveOnly' attribute
   if (decl->getAttrs().hasAttribute<MoveOnlyAttr>()) {
     assert(isa<StructDecl>(decl) || isa<EnumDecl>(decl));
@@ -1008,6 +993,52 @@ bool HasNoncopyableAnnotationRequest::evaluate(Evaluator &evaluator, TypeDecl *d
     foundInverse(repr->getLoc(), *kp);
   }
 
+  // Check the where-clause for a constraint Subject: ~Copyable where Subject
+  // refers to the where-clause owner.
+
+  Type owner;
+  if (auto *proto = dyn_cast<ProtocolDecl>(decl)) {
+    owner = proto->getSelfInterfaceType();
+  } else if (auto *nom = dyn_cast<NominalTypeDecl>(decl)) {
+    owner = nom->getDeclaredInterfaceType();
+  }
+  // TODO(kavon): handle other TypeDecls
+
+
+  // Checks a requirement in a where-clause
+  auto checkRequirement = [&](const Requirement &req,
+                              RequirementRepr *repr) -> bool {
+    if (req.getKind() != RequirementKind::Conformance)
+      return false;
+
+    auto constraintTyRepr = repr->getConstraintRepr();
+    if (!dyn_cast_or_null<InverseTypeRepr>(constraintTyRepr))
+      return false;
+
+    auto kp = req.getSecondType()->getKnownProtocol();
+    if (!kp)
+      return false; // diagnosed elsewhere.
+
+    auto subject = req.getFirstType();
+    if (!subject)
+      return false;
+
+    if (subject->getCanonicalType() == owner->getCanonicalType())
+      foundInverse(constraintTyRepr->getLoc(), *kp);
+
+    return false;
+  };
+
+  if (owner) {
+    if (auto *nominal = dyn_cast<NominalTypeDecl>(decl)) {
+      WhereClauseOwner(nominal).visitRequirements(TypeResolutionStage::Structural,
+                                                  checkRequirement);
+    } else if (auto *assocTy = dyn_cast<AssociatedTypeDecl>(decl)) {
+      WhereClauseOwner(assocTy).visitRequirements(TypeResolutionStage::Structural,
+                                                  checkRequirement);
+    }
+  }
+
   return !defaults.contains(KnownProtocolKind::Copyable);
 }
 

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1783,11 +1783,13 @@ static void checkProtocolRefinementRequirements(ProtocolDecl *proto) {
 
     if (EnabledNoncopyableGenerics) {
       // For any protocol 'P', there is an implied requirement 'Self: Copyable',
-      // unless it was suppressed via `Self: ~Copyable`; so skip if present.
+      // unless it was suppressed via `Self: ~Copyable`. So if this suppression
+      // annotation exists yet Copyable was implied anyway, emit a diagnostic.
       if (otherProto->isSpecificProtocol(KnownProtocolKind::Copyable))
-        continue;
+        if (!proto->isNoncopyable())
+          continue; // no ~Copyable annotation
 
-      // TODO: report that something implied Copyable despite writing ~Copyable?
+      // TODO(kavon): emit tailored error diagnostic to remove the ~Copyable
     }
 
     // GenericSignature::getRequiredProtocols() canonicalizes the protocol

test/Generics/inverse_copyable_generics.swift

@@ -8,7 +8,7 @@ extension Cond: Copyable where T: Copyable {} // expected-note {{requirement fro
 public typealias AlwaysCopyable<T> = Cond<T>
 public typealias CondAlias<T> = Cond<T> where T: ~Copyable
 
-func checkCopyable<T>(_ t: T) {}
+func checkCopyable<T>(_ t: T) {} // expected-note {{generic parameter 'T' has an implicit Copyable requirement}}
 
 func test<C, NC: ~Copyable>(_ a: Cond<C>, _ b: borrowing Cond<NC>) {
   checkCopyable(a)
@@ -29,3 +29,33 @@ protocol Removed: ~Copyable {
 protocol Plain {
   func requiresCopyableSelf(_ t: AlwaysCopyable<Self>)
 }
+
+// FIXME: detection of ~Copyable in where-clauses is half-baked.
+protocol RemovedAgain where Self: ~Copyable { // expected-warning {{protocol 'RemovedAgain' should be declared to refine 'Copyable' due to a same-type constraint on 'Self'}}
+    func requiresCopyableSelf(_ t: AlwaysCopyable<Self>)
+}
+
+struct StructContainment<T: ~Copyable> {
+    // expected-note@-1 {{consider removing '~Copyable' from generic parameter 'T' so it conforms to the 'Copyable' protocol}}
+    // expected-note@-2 {{consider removing implicit 'Copyable' conformance from generic struct 'StructContainment'}}
+
+    var storage: T
+    // expected-error@-1 {{stored property 'storage' of 'Copyable'-conforming generic struct 'StructContainment' has noncopyable type 'T'}}
+}
+
+enum EnumContainment<T: ~Copyable> {
+    // expected-note@-1{{consider removing '~Copyable' from generic parameter 'T' so it conforms to the 'Copyable' protocol}}
+    // expected-note@-2{{consider removing implicit 'Copyable' conformance from generic enum 'EnumContainment'}}
+
+    case some(T) // expected-error {{associated value 'some' of 'Copyable'-conforming generic enum 'EnumContainment' has noncopyable type 'T'}}
+    case other(Int)
+    case none
+}
+
+class ClassContainment<T: ~Copyable> {
+    var storage: T
+    init(_ t: consuming T) {
+        storage = t
+        checkCopyable(t) // expected-error {{noncopyable type 'T' cannot be substituted for copyable generic parameter 'T' in 'checkCopyable'}}
+    }
+}

test/Generics/inverse_protocols_errors.swift

@@ -3,7 +3,8 @@
 // REQUIRES: asserts
 
 protocol RegularProto {}
-protocol NCProto: ~Copyable, RegularProto { // FIXME: diagnose the ~Copyable annotation when it's implied.
+protocol NCProto: ~Copyable, RegularProto {
+  // expected-warning@-1 {{protocol 'NCProto' should be declared to refine 'Copyable' due to a same-type constraint on 'Self'}}
   func checkIfCopyableSelf(_ s: Self)
 }
 
@@ -40,3 +41,9 @@ struct NCThinger<T: ~Copyable>: ~Copyable, Hello {
   // expected-note@-3 {{add 'inout' for a mutable reference}}
   // expected-note@-4 {{add 'consuming' to take the value from the caller}}
 }
+
+struct ExtraNoncopyStruct: ~Copyable, ~Copyable {}
+// expected-error@-1 {{duplicate inverse constraint}}
+// expected-note@-2 {{previous inverse constraint here}}
+
+protocol ExtraNoncopyProto: ~Copyable, ~Copyable {}

test/Parse/inverses.swift

@@ -22,17 +22,20 @@ struct S4: ~(Copyable & Equatable) {} // expected-error {{type 'Copyable & Equat
 func blah<T>(_ t: T) where T: ~Copyable,
                            T: ~Hashable {}  // expected-error@:31 {{type 'Hashable' is not invertible}}
 
-func foo<T: ~Copyable>(x: T) {}
+func foo<T: ~Copyable>(x: borrowing T) {}
 
 struct Buurap<T: ~Copyable> {}
 
-protocol Foo where Self: ~Copyable {
+// expected-warning@+1 {{protocol 'Foo' should be declared to refine 'Copyable' due to a same-type constraint on 'Self'}}
+protocol Foo: ~Copyable  // expected-note {{previous inverse constraint here}}
+         where Self: ~Copyable { // expected-error {{duplicate inverse constraint}}
+
     func test<T>(_ t: T) where T: ~Self  // expected-error {{type 'Self' is not invertible}}
 }
 
 protocol Sando { func make() }
 
-class C: ~Copyable,
+class C: ~Copyable,  // expected-error {{classes cannot be noncopyable}}
          ~Sando // expected-error {{type 'Sando' is not invertible}}
          {}
 
@@ -54,6 +57,10 @@ func greenBay<each T: ~Copyable>(_ r: repeat each T) {}
 
 typealias Clone = Copyable
 func dup<D: ~Clone>(_ d: D) {}
+// expected-error@-1 {{noncopyable parameter must specify its ownership}}
+// expected-note@-2 {{add 'borrowing'}}
+// expected-note@-3 {{add 'inout'}}
+// expected-note@-4 {{add 'consuming'}}
 
 func superb(_ thing: some ~Copyable, thing2: some ~Clone) {}