[NoncopyableGenerics] fix isNoncopyable for packs

We're not yet going to allow noncopyable types into packs, so this
change prevents the use of `~Copyable` on an `each T` generic parameter.
 It also fixes how we query for whether a `repeat X` parameter is
 copyable.

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -3084,6 +3084,10 @@ ERROR(requires_not_suitable_archetype,none,
       "generic parameter or associated type",
       (Type))
 
+ERROR(requires_not_suitable_inverse_subject,none,
+      "cannot apply inverse %1 to type %0 in conformance requirement",
+      (Type, Type))
+
 ERROR(invalid_shape_requirement,none,
       "invalid same-shape requirement between %0 and %1",
       (Type, Type))

lib/AST/RequirementMachine/Diagnostics.cpp

@@ -105,6 +105,23 @@ bool swift::rewriting::diagnoseRequirementErrors(
       break;
     }
 
+    case RequirementError::Kind::InvalidInverseSubject: {
+      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_subject,
+                         subjectType, constraintType);
+      diagnosedError = true;
+      break;
+    }
+
     case RequirementError::Kind::InvalidShapeRequirement: {
       if (error.requirement.hasError())
         break;

lib/AST/RequirementMachine/Diagnostics.h

@@ -34,6 +34,9 @@ struct RequirementError {
     /// A type requirement on a trivially invalid subject type,
     /// e.g. Bool: Collection.
     InvalidRequirementSubject,
+    /// An inverse constraint applied to an invalid subject type,
+    /// e.g., each T : ~Copyable
+    InvalidInverseSubject,
     /// An invalid shape requirement, e.g. T.shape == Int.shape
     InvalidShapeRequirement,
     /// A pair of conflicting requirements, T == Int, T == String
@@ -78,6 +81,11 @@ struct RequirementError {
     return {Kind::InvalidRequirementSubject, req, loc};
   }
 
+  static RequirementError forInvalidInverseSubject(Requirement req,
+                                                   SourceLoc loc) {
+    return {Kind::InvalidInverseSubject, req, loc};
+  }
+
   static RequirementError forInvalidShapeRequirement(Requirement req,
                                                      SourceLoc loc) {
     return {Kind::InvalidShapeRequirement, req, loc};

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -393,13 +393,20 @@ static void desugarConformanceRequirement(Requirement req,
     }
 
   } else if (constraintType->is<InverseType>()) {
+    auto subject = req.getFirstType();
+
     // Fast-path
-    if (req.getFirstType()->isTypeParameter()) {
-      result.push_back(req);
-      return;
+    if (subject->isTypeParameter()) {
+      if (!subject->isParameterPack()) {
+        result.push_back(req);
+        return;
+      }
+      // Disallow parameter packs for now.
+      errors.push_back(RequirementError::forInvalidInverseSubject(req, loc));
+    } else {
+      // Only permit type-parameter subjects.
+      errors.push_back(RequirementError::forInvalidRequirementSubject(req, loc));
     }
-    // Only permit type-parameter subjects for inverse-conformance requirements.
-    errors.push_back(RequirementError::forInvalidRequirementSubject(req, loc));
   }
 
   for (auto subReq : subReqs)

lib/Sema/TypeCheckInvertible.cpp

@@ -134,6 +134,12 @@ bool IsNoncopyableRequest::evaluate(Evaluator &evaluator,
   assert(!type->hasTypeParameter() && "forgot to mapTypeIntoContext first");
   auto &ctx = type->getASTContext();
 
+  // Pack expansions such as `repeat T` themselves do not have conformances,
+  // so check its pattern type for conformance.
+  if (auto *pet = type->getAs<PackExpansionType>()) {
+    type = pet->getPatternType()->getCanonicalType();
+  }
+
   auto *copyable = ctx.getProtocol(KnownProtocolKind::Copyable);
   if (!copyable)
     llvm_unreachable("missing Copyable protocol!");

test/Generics/inverse_copyable_requirement.swift

@@ -290,7 +290,30 @@ func tryToDoBadMetatypeStuff() {
   doBadMetatypeStuff(MO.self)
 }
 
+func totallyInvalid<T>(_ t: T) where MO: ~Copyable {}
+// expected-error@-1{{type 'MO' in conformance requirement does not refer to a generic parameter or associated type}}
+
 func packingHeat<each T>(_ t: repeat each T) {} // expected-note {{generic parameter 'each T' has an implicit Copyable requirement}}
 func packIt() {
   packingHeat(MO())  // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'each T' in 'packingHeat'}}
+  packingHeat(10)
+}
+
+func packingUniqueHeat_1<each T: ~Copyable>(_ t: repeat each T) {}
+// expected-error@-1{{cannot apply inverse '~Copyable' to type 'each T' in conformance requirement}}
+// expected-note@-2{{generic parameter 'each T' has an implicit Copyable requirement}}
+
+func packingUniqueHeat_2<each T>(_ t: repeat each T)
+   where repeat each T: ~Copyable {}
+// expected-error@-1{{cannot apply inverse '~Copyable' to type 'each T' in conformance requirement}}
+// expected-note@-3{{generic parameter 'each T' has an implicit Copyable requirement}}
+
+func packItUniquely() {
+  packingUniqueHeat_1(MO())
+  // expected-error@-1{{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'each T' in 'packingUniqueHeat_1'}}
+
+  packingUniqueHeat_2(MO())
+  // expected-error@-1{{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'each T' in 'packingUniqueHeat_2'}}
+
+  packingUniqueHeat_1(10)
 }