[Sema] add redundant ~Copyable requirement warning

Originally I tried to implement a fancy redundant-inverse error
diagnostic that identifies the "previous" requirement already seen. I
ended up removing this error diagnostic because it was tricky to
implement well and we weren't diagnosing other redundant requirements.

Turns out we do have a mode of the compiler to diagnose redundant
requirements, but as warnings, using `-warn-redundant-requirements`.
This warning is much simpler in that it just points to one requirement
that is redundant.

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -3170,7 +3170,7 @@ ERROR(recursive_superclass_constraint,none,
 ERROR(requires_same_concrete_type,none,
       "generic signature requires types %0 and %1 to be the same", (Type, Type))
 WARNING(redundant_conformance_constraint,none,
-        "redundant conformance constraint %0 : %1", (Type, ProtocolDecl *))
+        "redundant conformance constraint %0 : %1", (Type, Type))
 
 WARNING(missing_protocol_refinement, none,
         "protocol %0 should be declared to refine %1 due to a same-type constraint on 'Self'",

lib/AST/RequirementMachine/Diagnostics.cpp

@@ -227,7 +227,7 @@ bool swift::rewriting::diagnoseRequirementErrors(
       case RequirementKind::Conformance:
         ctx.Diags.diagnose(loc, diag::redundant_conformance_constraint,
                            requirement.getFirstType(),
-                           requirement.getProtocolDecl());
+                           requirement.getSecondType());
         break;
       case RequirementKind::Superclass:
         ctx.Diags.diagnose(loc, diag::redundant_superclass_constraint,

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -823,8 +823,19 @@ void swift::rewriting::expandDefaultRequirements(ASTContext &ctx,
       return true;
     }
 
+    auto currentDefaults = defaults[subject];
+    auto inverseKind = inverse->getInverseKind();
+
+    // Check if this inverse is redundant.
+    if (!currentDefaults.contains(inverseKind)) {
+      errors.push_back(
+          RequirementError::forRedundantRequirement(req, structReq.loc));
+      return true;
+    }
+
     // Apply the inverse to the subject's defaults.
-    defaults[subject].remove(inverse->getInverseKind());
+    currentDefaults.remove(inverseKind);
+    defaults[subject] = currentDefaults;
 
     // Remove this inverse conformance requirement.
     return true;

test/Parse/inverses.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift -enable-experimental-feature NoncopyableGenerics
+// RUN: %target-typecheck-verify-swift -enable-experimental-feature NoncopyableGenerics -warn-redundant-requirements
 
 // REQUIRES: asserts
 
@@ -25,16 +25,21 @@ func blah<T>(_ t: borrowing T) where T: ~Copyable,
 func foo<T: ~Copyable>(x: borrowing T) {}
 
 struct Buurap<T: ~Copyable> where T: ~Copyable {}
+// expected-warning@-1 {{redundant conformance constraint 'T' : '~Copyable'}}
 
 struct ExtraNoncopyStruct: ~Copyable, ~Copyable {}
 struct ExtraNoncopyEnum: ~Copyable, ~Copyable {}
+
 protocol ExtraNoncopyProto: ~Copyable, ~Copyable {}
+// expected-warning@-1 {{redundant conformance constraint 'Self' : '~Copyable'}}
 
 protocol Foo: ~Copyable
          where Self: ~Copyable {
+         // expected-warning@-1 {{redundant conformance constraint 'Self' : '~Copyable'}}
 
     associatedtype Touch : ~Copyable,
                            ~Copyable
+    // expected-warning@-1 {{redundant conformance constraint 'Self.Touch' : '~Copyable'}}
 
     func test<T>(_ t: T) where T: ~Self  // expected-error {{type 'Self' is not invertible}}
 }