[Sema] prevent inverse-constraints on outer params

Since there is no propagation of inverse constraints in the requirement
machine, we need to fully desugar these requirements at the point of
defining a generic parameter. That desugaring involves determining which
default conformance requirements need to be applied to a generic
parameter, accounting for inverses.

But, nested generic contexts in scope of those expanded generic
parameters can still write constraints on that outer parameter. For
example, this method's where clause can have its own constraints on `T`:

```
struct S<T> {
 func f() where T: ~Copyable {}
}
```

But, the generic signature of `S` already has a `T: Copyable` that was
expanded. The method `f` will always see a `T` that conforms to
`Copyable`, so it's impossible for `f` to claim that it applies for
`T`'s that lack Copyable.

Put another way, it's not valid for this method `f`, whose generic
signature is based on its parent's `S`, to weaken or remove requirements
 from parent's signature. Only positive requirements can be
 added to them.

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -3088,6 +3088,11 @@ ERROR(requires_not_suitable_inverse_subject,none,
       "cannot apply inverse %1 to type %0 in conformance requirement",
       (Type, Type))
 
+ERROR(requires_not_suitable_inverse_outer_subject,none,
+      "cannot add inverse constraint '%0: %1' "
+      "on generic parameter '%0' defined in outer scope",
+      (StringRef, StringRef))
+
 ERROR(invalid_shape_requirement,none,
       "invalid same-shape requirement between %0 and %1",
       (Type, Type))

lib/AST/RequirementMachine/Diagnostics.cpp

@@ -122,6 +122,23 @@ bool swift::rewriting::diagnoseRequirementErrors(
       break;
     }
 
+    case RequirementError::Kind::InvalidInverseOuterSubject: {
+      if (error.requirement.hasError())
+        break;
+
+      assert(error.requirement.getKind() == RequirementKind::Conformance);
+
+      auto subjectType = error.requirement.getFirstType();
+      auto constraintType = error.requirement.getSecondType();
+
+      assert(constraintType->is<InverseType>());
+
+      ctx.Diags.diagnose(loc, diag::requires_not_suitable_inverse_outer_subject,
+                         subjectType.getString(), constraintType.getString());
+      diagnosedError = true;
+      break;
+    }
+
     case RequirementError::Kind::InvalidShapeRequirement: {
       if (error.requirement.hasError())
         break;

lib/AST/RequirementMachine/Diagnostics.h

@@ -37,6 +37,10 @@ struct RequirementError {
     /// An inverse constraint applied to an invalid subject type,
     /// e.g., each T : ~Copyable
     InvalidInverseSubject,
+    /// The inverse constraint requirement cannot applied to the subject because
+    /// it's an outer generic parameter, e.g.,
+    ///   protocol P { func f() where Self: ~Copyable }
+    InvalidInverseOuterSubject,
     /// An invalid shape requirement, e.g. T.shape == Int.shape
     InvalidShapeRequirement,
     /// A pair of conflicting requirements, T == Int, T == String
@@ -86,6 +90,11 @@ struct RequirementError {
     return {Kind::InvalidInverseSubject, req, loc};
   }
 
+  static RequirementError forInvalidInverseOuterSubject(Requirement req,
+                                                        SourceLoc loc) {
+    return {Kind::InvalidInverseOuterSubject, req, loc};
+  }
+
   static RequirementError forInvalidShapeRequirement(Requirement req,
                                                      SourceLoc loc) {
     return {Kind::InvalidShapeRequirement, req, loc};

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -768,6 +768,9 @@ void swift::rewriting::realizeRequirement(
 /// Desugars and expands all default conformance requirements on \c subject,
 /// accounting for and eliminating inverse constraints.
 ///
+/// For inverse constraints on subjects other than the ones specified, they are
+/// removed and diagnosed as errors.
+///
 /// \param subjects the subject types for which we should expand defaults.
 void swift::rewriting::expandDefaultRequirements(ASTContext &ctx,
                                  SmallVectorImpl<Type> const& subjects,
@@ -791,10 +794,22 @@ void swift::rewriting::expandDefaultRequirements(ASTContext &ctx,
     if (!inverse)
       return false;
 
+    // At this point, we have a conformance constraint with an inverse.
     auto subject = req.getFirstType()->getCanonicalType();
 
-    if (defaults.count(subject) == 0)
-      return false;
+    // If the inverse is on a subject that wasn't permitted by our caller, then
+    // remove and diagnose as an error. This can happen when an inner context
+    // has a constraint on some outer generic parameter, e.g.,
+    //
+    //     protocol P {
+    //       func f() where Self: ~Copyable
+    //     }
+    //
+    if (defaults.count(subject) == 0) {
+      errors.push_back(
+          RequirementError::forInvalidInverseOuterSubject(req, structReq.loc));
+      return true;
+    }
 
     // TODO: check for redundant inverses.
 

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -837,12 +837,15 @@ InferredGenericSignatureRequest::evaluate(
   auto *moduleForInference = lookupDC->getParentModule();
   auto &ctx = moduleForInference->getASTContext();
 
-  // Expand default requirements for all generic parameters.
-  SmallVector<Type, 8> gpTypes;
-  for (auto gtpt : genericParams)
-    gpTypes.push_back(Type(gtpt)); // NOTE: wish we had std::views::transform
-
-  expandDefaultRequirements(ctx, gpTypes, requirements, errors);
+  // After realizing requirements, expand default requirements only for local
+  // generic parameters, as the outer parameters have already been expanded.
+  SmallVector<Type, 4> localGPs;
+  if (genericParamList)
+    for (auto *gtpd : genericParamList->getParams())
+      localGPs.push_back(gtpd->getDeclaredInterfaceType());
+
+  // Expand defaults and eliminate all inverse-conformance requirements.
+  expandDefaultRequirements(ctx, localGPs, requirements, errors);
 
   // Perform requirement inference from function parameter and result
   // types and such.

test/Generics/inverse_copyable_scoping.swift

@@ -0,0 +1,44 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-feature NoncopyableGenerics
+
+// REQUIRES: asserts
+
+protocol NoCopyReq: ~Copyable {}
+
+protocol P {
+  func f() where Self: ~Copyable // expected-error {{cannot add inverse constraint 'Self: ~Copyable' on generic parameter 'Self' defined in outer scope}}
+
+  func g<T>(_: T) where Self: ~Copyable // expected-error {{cannot add inverse constraint 'Self: ~Copyable' on generic parameter 'Self' defined in outer scope}}
+
+  associatedtype AT where Self: ~Copyable // expected-error {{constraint with subject type of 'Self' is not supported; consider adding requirement to protocol inheritance clause instead}}
+
+  // expected-error@+1 {{cannot add inverse constraint 'Self.Alice: ~Copyable' on generic parameter 'Self.Alice' defined in outer scope}}
+  associatedtype Bob where Alice: NoCopyReq & ~Copyable
+  associatedtype Alice where Bob: ~Copyable
+  // expected-error@-1 {{cannot add inverse constraint 'Self.Bob: ~Copyable' on generic parameter 'Self.Bob' defined in outer scope}}
+}
+
+protocol U {}
+
+extension U where Self: ~Copyable {} // expected-error {{cannot add inverse constraint 'Self: ~Copyable' on generic parameter 'Self' defined in outer scope}}
+
+extension P {
+  func g() where Self: ~Copyable {} // expected-error {{cannot add inverse constraint 'Self: ~Copyable' on generic parameter 'Self' defined in outer scope}}
+
+  typealias Me = Self where Self: ~Copyable // expected-error {{cannot add inverse constraint 'Self: ~Copyable' on generic parameter 'Self' defined in outer scope}}
+
+  typealias MeAndU = Self where Self: U
+}
+
+struct S<T> {
+
+  // expected-note@+2 3{{add}}
+  // expected-error@+1 {{parameter of noncopyable type 'U' must specify ownership}}
+  func fn<U>(_ u: U)
+    where T: ~Copyable, // expected-error {{cannot add inverse constraint 'T: ~Copyable' on generic parameter 'T' defined in outer scope}}
+          U: ~Copyable
+          {}
+
+  func onlyCopyable() where T: Copyable {}
+}
+
+extension S where T: NoCopyReq & ~Copyable {} // expected-error {{cannot add inverse constraint 'T: ~Copyable' on generic parameter 'T' defined in outer scope}}