[NCGenerics] fix AnyObject and inverses

resolves rdar://120512544

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -7586,6 +7586,10 @@ WARNING(redundant_inverse_constraint,none,
 ERROR(inverse_on_class, none,
       "classes cannot be '~%0'",
       (StringRef))
+ERROR(inverse_with_class_constraint, none,
+      "composition involving %select{class requirement %2|'AnyObject'}0 "
+      "cannot contain '~%1'",
+      (bool, StringRef, Type))
 ERROR(inverse_extension, none,
       "cannot apply inverse %0 to extension",
       (Type))

lib/AST/ASTPrinter.cpp

@@ -1470,8 +1470,8 @@ static void reconstituteInverses(GenericSignature genericSig,
   for (auto tp : typeParams) {
     assert(tp);
 
-    // Any generic parameter requiring a class could not have an inverse.
-    if (genericSig->requiresClass(tp))
+    // Any generic parameter with a superclass bound could not have an inverse.
+    if (genericSig->getSuperclassBound(tp))
       continue;
 
     auto defaults = InverseRequirement::expandDefault(tp);

lib/AST/RequirementMachine/Diagnostics.cpp

@@ -564,11 +564,23 @@ void RequirementMachine::computeRequirementDiagnostics(
                                                 getGenericParams());
 
   // Check that the generic parameters with inverses truly lack the conformance.
-  for (auto const& inverse : inverses)
-    if (requiresProtocol(inverse.subject, inverse.protocol))
+  for (auto const& inverse : inverses) {
+    // The Superclass and AnyObject checks here are based on the assumption that
+    // a class cannot have an inverse applied to it. As a result, the existence
+    // of a superclass bound always implies the existence of the conformance.
+    // Thus, an inverse being present is a conflict.
+    //
+    // While AnyObject doesn't imply the conformance in the signature, we don't
+    // want a generic parameter to be a class that can't be copied, since we
+    // don't allow that for concrete classes today. Thus, we artificially
+    // prevent AnyObject from being mixed with inverses.
+    if (requiresProtocol(inverse.subject, inverse.protocol) ||
+        getSuperclassBound(inverse.subject, getGenericParams()) ||
+        requiresClass(inverse.subject))
       errors.push_back(
           RequirementError::forConflictingInverseRequirement(inverse,
                                                              inverse.loc));
+  }
 }
 
 std::string RequirementMachine::getRuleAsStringForDiagnostics(

lib/Sema/TypeCheckType.cpp

@@ -4993,6 +4993,7 @@ TypeResolver::resolveCompositionType(CompositionTypeRepr *repr,
   Type SuperclassType;
   SmallVector<Type, 4> Members;
   InvertibleProtocolSet Inverses;
+  bool HasAnyObject = false;
 
   // Whether we saw at least one protocol. A protocol composition
   // must either be empty (in which case it is Any or AnyObject),
@@ -5050,6 +5051,8 @@ TypeResolver::resolveCompositionType(CompositionTypeRepr *repr,
             continue;
         if (!layout.getProtocols().empty())
           HasProtocol = true;
+        if (layout.hasExplicitAnyObject)
+          HasAnyObject = true;
 
         Inverses.insertAll(pct->getInverses());
         Members.push_back(ty);
@@ -5064,6 +5067,17 @@ TypeResolver::resolveCompositionType(CompositionTypeRepr *repr,
     IsInvalid = true;
   }
 
+  // Cannot combine inverses with Superclass or AnyObject in a composition.
+  if ((SuperclassType || HasAnyObject) && !Inverses.empty()) {
+    diagnose(repr->getStartLoc(),
+             diag::inverse_with_class_constraint,
+             HasAnyObject,
+             getProtocolName(getKnownProtocolKind(*Inverses.begin())),
+             SuperclassType);
+    IsInvalid = true;
+  }
+
+
   if (IsInvalid) {
     repr->setInvalid();
     return ErrorType::get(getASTContext());

test/Generics/inverse_generics.swift

@@ -358,3 +358,35 @@ func conflict15<T, C, E>(_ t: T, _ c: C, _ e: borrowing E)
     C: ~Escapable,  // expected-error {{'C' required to be 'Escapable' but is marked with '~Escapable'}}
     C == T.HasE
   {}
+
+
+// Class bounds and AnyObject
+
+class Soup {}
+func checkClassBound1<T>(_ t: T) where T: ~Copyable, T: Soup {}
+// expected-error@-1 {{'T' required to be 'Copyable' but is marked with '~Copyable'}}
+
+// expected-note@+2 3{{add}}
+// expected-error@+1 {{parameter of noncopyable type 'T' must specify ownership}}
+func checkClassBound2<T>(_ t: T) where T: ~Escapable, T: AnyObject, T: ~Copyable {}
+// expected-error@-1 {{'T' required to be 'Escapable' but is marked with '~Escapable'}}
+// expected-error@-2 {{'T' required to be 'Copyable' but is marked with '~Copyable'}}
+
+func checkClassBound3<T>(_ t: T) where T: Soup & ~Copyable & ~Escapable {}
+// expected-error@-1 {{composition involving class requirement 'Soup' cannot contain '~Copyable'}}
+
+public func checkAnyObjInv1<Result: AnyObject>(_ t: borrowing Result) where Result: ~Copyable {}
+// expected-error@-1 {{'Result' required to be 'Copyable' but is marked with '~Copyable'}}
+
+public func checkAnyObjInv2<Result: AnyObject>(_ t: borrowing Result) where Result: ~Escapable {}
+// expected-error@-1 {{'Result' required to be 'Escapable' but is marked with '~Escapable'}}
+
+public func checkAnyObject<Result>(_ t: Result) where Result: AnyObject {
+    checkCopyable(t)
+}
+
+func checkExistentialAndClasses(
+    _ a: any AnyObject & ~Copyable, // expected-error {{composition involving 'AnyObject' cannot contain '~Copyable'}}
+    _ b: any Soup & Copyable & ~Escapable & ~Copyable, // expected-error {{composition involving class requirement 'Soup' cannot contain '~Copyable'}}
+    _ c: some (~Escapable & Removed) & Soup // expected-error {{composition involving class requirement 'Soup' cannot contain '~Escapable'}}
+    ) {}

test/Generics/inverse_signatures.swift

@@ -70,6 +70,15 @@ func withSomeProto(_ t: some NoCopyP) {}
 // CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : Escapable>
 func withInverseSome(_ t: borrowing some ~Copyable) {}
 
+// CHECK-LABEL: .checkAnyObject@
+// CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : AnyObject, τ_0_0 : Copyable, τ_0_0 : Escapable>
+func checkAnyObject<Result>(_ t: Result) where Result: AnyObject {}
+
+// CHECK-LABEL: .checkSoup@
+// CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : Soup>
+class Soup {}
+func checkSoup<T>(_ t: T) where T: Soup {}
+
 // CHECK-LABEL: .S1@
 // CHECK: Generic signature: <T where T : Copyable, T : Escapable>
 struct S1<T> {}

test/ModuleInterface/Inputs/NoncopyableGenerics_Misc.swift

@@ -74,5 +74,9 @@ public class C {}
 public func noInversesSTART() {}
 public func checkAny<Result>(_ t: Result) where Result: Any {}
 public func usingClassConstraint<Result>(arg: Result) -> Result? where Result: C { return arg }
-public func checkAnyObject<Result>(_ t: Result) where Result: AnyObject {}
+public func withAnyObject<Result>(_ t: Result) where Result: AnyObject {}
 public func noInversesEND() {}
+
+public func checkAnyInv1<Result>(_ t: borrowing Result) where Result: Any & ~Copyable {}
+public func checkAnyInv2<Result: Any>(_ t: borrowing Result) where Result: ~Copyable & ~Escapable {}
+public func checkAnyObject<Result>(_ t: Result) where Result: AnyObject {}

test/ModuleInterface/noncopyable_generics.swift

@@ -100,6 +100,10 @@ import NoncopyableGenerics_Misc
 // CHECK-MISC-NOT: ~
 // CHECK-MISC: noInversesEND
 
+// CHECK-MISC: public func checkAnyInv1<Result>(_ t: borrowing Result) where Result : ~Copyable
+// CHECK-MISC: public func checkAnyInv2<Result>(_ t: borrowing Result) where Result : ~Copyable, Result : ~Escapable
+// CHECK-MISC: public func checkAnyObject<Result>(_ t: Result) where Result : AnyObject
+
 ///////////////////////////////////////////////////////////////////////
 // Synthesized conditional conformances are next