[Generics] ~Copyable in inheritance clauses

Have `~Copyable` change the signatures of a generic type param,
protocol, or associated type if written in the inheritance clause
position.

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -2349,6 +2349,10 @@ ERROR(inferred_opaque_type,none,
       "property definition has inferred type %0, involving the 'some' "
       "return type of another declaration", (Type))
 
+// Inverse Constraints
+ERROR(inverse_type_not_invertable,none,
+      "type %0 is not invertable", (Type))
+
 // Extensions
 ERROR(non_nominal_extension,none,
       "non-nominal type %0 cannot be extended", (Type))

include/swift/AST/KnownProtocols.h

@@ -14,6 +14,7 @@
 #define SWIFT_AST_KNOWNPROTOCOLS_H
 
 #include "swift/Basic/InlineBitfield.h"
+#include "swift/Basic/FixedBitSet.h"
 #include "swift/Config.h"
 
 namespace llvm {
@@ -41,6 +42,12 @@ enum : uint8_t {
 enum : unsigned { NumKnownProtocolKindBits =
   countBitsUsed(static_cast<unsigned>(NumKnownProtocols - 1)) };
 
+using KnownProtocolSet = FixedBitSet<NumKnownProtocols, KnownProtocolKind>;
+
+/// Produces a set of all protocols that have an inverse, i.e., for every
+/// known protocol KP in the set, ~KP exists.
+KnownProtocolSet getInvertableProtocols();
+
 /// Retrieve the name of the given known protocol.
 llvm::StringRef getProtocolName(KnownProtocolKind kind);
 

lib/AST/ASTContext.cpp

@@ -102,6 +102,10 @@ llvm::StringRef swift::getProtocolName(KnownProtocolKind kind) {
   llvm_unreachable("bad KnownProtocolKind");
 }
 
+KnownProtocolSet swift::getInvertableProtocols() {
+  return { KnownProtocolKind::Copyable };
+}
+
 namespace {
 enum class SearchPathKind : uint8_t {
   Import = 1 << 0,

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -732,6 +732,7 @@ void swift::rewriting::realizeInheritedRequirements(
   auto inheritedTypes = decl->getInherited();
   auto *dc = decl->getInnermostDeclContext();
   auto *moduleForInference = dc->getParentModule();
+  auto defaults = getInvertableProtocols();
 
   for (auto index : inheritedTypes.getIndices()) {
     Type inheritedType =
@@ -749,6 +750,17 @@ void swift::rewriting::realizeInheritedRequirements(
 
     auto *typeRepr = inheritedTypes.getTypeRepr(index);
     SourceLoc loc = (typeRepr ? typeRepr->getStartLoc() : SourceLoc());
+
+    // For any inverses, we only need to cancel out a default requirement.
+    if (dyn_cast_or_null<InverseTypeRepr>(typeRepr)) {
+      if (auto protoTy = inheritedType->getAs<ProtocolType>())
+        if (auto protoDecl = protoTy->getDecl())
+          if (auto kp = protoDecl->getKnownProtocolKind())
+            defaults.remove(*kp);
+
+      continue;
+    }
+
     if (shouldInferRequirements) {
       inferRequirements(inheritedType, loc, moduleForInference,
                         decl->getInnermostDeclContext(), result);
@@ -759,15 +771,17 @@ void swift::rewriting::realizeInheritedRequirements(
 
   auto &ctx = dc->getASTContext();
   if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
-    // All associated types or generic type params are Copyable by default.
-    // TODO: if we saw ~Copyable in the inherited types list earlier, skip this!
+    // Add the remaining default conformance requirements to this
+    // associated type or generic type param.
+    for (auto kp : defaults) {
+      ProtocolDecl *decl = ctx.getProtocol(kp);
+      assert(decl && "couldn't load protocol??");
 
-    if (auto *copyable = ctx.getProtocol(KnownProtocolKind::Copyable)) {
       SourceLoc loc = decl->getLoc();
-      Type copyableType = copyable->getDeclaredInterfaceType();
+      Type protocolType = decl->getDeclaredInterfaceType();
 
-      // Add Copyable as an "inferred" requirement.
-      Requirement req(RequirementKind::Conformance, type, copyableType);
+      // Add the protocol as an "inferred" requirement.
+      Requirement req(RequirementKind::Conformance, type, protocolType);
       result.push_back({req, loc, /*wasInferred=*/true});
     }
   }

lib/Sema/TypeCheckType.cpp

@@ -5046,14 +5046,14 @@ NeverNullType TypeResolver::resolveInverseType(InverseTypeRepr *repr,
   if (ty->hasError())
     return ErrorType::get(getASTContext());
 
-  // TODO: more user-friendly verification
-
   if (auto protoTy = ty->getAs<ProtocolType>())
     if (auto protoDecl = protoTy->getDecl())
-      if (protoDecl->isSpecificProtocol(KnownProtocolKind::Copyable))
-        return ty;
+      if (auto kp = protoDecl->getKnownProtocolKind())
+        if (getInvertableProtocols().contains(*kp))
+          return ty;
 
-  llvm_unreachable("todo: verification");
+  diagnoseInvalid(repr, repr->getLoc(), diag::inverse_type_not_invertable, ty);
+  return ErrorType::get(getASTContext());
 }
 
 NeverNullType TypeResolver::resolveProtocolType(ProtocolTypeRepr *repr,

test/Generics/inverse_constraints.swift

@@ -0,0 +1,53 @@
+// RUN: %target-swift-frontend -enable-experimental-feature NoncopyableGenerics -typecheck %s -debug-generic-signatures 2>&1 | %FileCheck %s
+
+// CHECK-LABEL: (file).genericFn@
+// CHECK: Generic signature: <T where T : Copyable>
+func genericFn<T>(_ t: T) {}
+
+// CHECK-LABEL: .withInverse@
+// CHECK: Generic signature: <T>
+func withInverse<T: ~Copyable>(_ t: T) {}
+
+// CHECK-LABEL: .S1@
+// CHECK: Generic signature: <T where T : Copyable>
+struct S1<T> {}
+
+// CHECK-LABEL: .S1_I@
+// CHECK: Generic signature: <T>
+struct S1_I<T: ~Copyable> {}
+
+// CHECK-LABEL: .C1@
+// CHECK: Generic signature: <T, U where T : Copyable, U : Copyable>
+class C1<T, U> {}
+
+// CHECK-LABEL: .C1_IC@
+// CHECK: Generic signature: <T, U where U : Copyable>
+class C1_IC<T: ~Copyable, U> {}
+
+// CHECK-LABEL: .C1_CI@
+// CHECK: Generic signature: <T, U where T : Copyable>
+class C1_CI<T, U: ~Copyable> {}
+
+// CHECK-LABEL: .C1_II@
+// CHECK: Generic signature: <T, U>
+class C1_II<T: ~Copyable, U: ~Copyable> {}
+
+// CHECK-LABEL: .P1@
+// CHECK: Requirement signature: <Self where Self : Copyable>
+protocol P1 {}
+
+// CHECK-LABEL: .P2@
+// CHECK: <Self where Self : Copyable, Self.[P2]A : Copyable>
+protocol P2 { associatedtype A }
+
+// CHECK-LABEL: .P2_IC@
+// CHECK: <Self where Self.[P2_IC]A : Copyable>
+protocol P2_IC: ~Copyable { associatedtype A }
+
+// CHECK-LABEL: .P2_CI@
+// CHECK: Requirement signature: <Self where Self : Copyable>
+protocol P2_CI { associatedtype A: ~Copyable }
+
+// CHECK-LABEL: .P2_II@
+// CHECK: Requirement signature: <Self>
+protocol P2_II: ~Copyable { associatedtype A: ~Copyable }