AST: Remove bogus PackExpansionType logic in lookupConformance()

Author: slavapestov

lib/AST/Module.cpp

@@ -1949,18 +1949,6 @@ LookupConformanceInModuleRequest::evaluate(
     return getBuiltinBuiltinTypeConformance(type, builtinType, protocol);
   }
 
-  // Specific handling of Copyable and Sendable for pack expansions.
-  // FIXME: Remove.
-  if (auto packExpansion = type->getAs<PackExpansionType>()) {
-    if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable) ||
-        protocol->isSpecificProtocol(KnownProtocolKind::Sendable)) {
-      auto patternType = packExpansion->getPatternType();
-      return (patternType->isTypeParameter()
-               ? ProtocolConformanceRef(protocol)
-               : mod->lookupConformance(patternType, protocol));
-    }
-  }
-
   auto nominal = type->getAnyNominal();
 
   // If we don't have a nominal type, there are no conformances.

lib/AST/Type.cpp

@@ -160,6 +160,10 @@ bool TypeBase::isPureMoveOnly() {
   if (auto *nom = getAnyNominal())
     return nom->isMoveOnly();
 
+  if (auto *expansion = getAs<PackExpansionType>()) {
+    return expansion->getPatternType()->isPureMoveOnly();
+  }
+
   // if any components of the tuple are move-only, then the tuple is move-only.
   if (auto *tupl = getCanonicalType()->getAs<TupleType>()) {
     for (auto eltTy : tupl->getElementTypes())

lib/Sema/CSSimplify.cpp

@@ -8293,6 +8293,17 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
     return SolutionKind::Solved;
   }
 
+  // We sometimes get a pack expansion type here.
+  if (auto *expansionType = type->getAs<PackExpansionType>()) {
+    // FIXME: Locator
+    addConstraint(ConstraintKind::ConformsTo,
+                  expansionType->getPatternType(),
+                  protocol->getDeclaredInterfaceType(),
+                  locator);
+
+    return SolutionKind::Solved;
+  }
+
   // Copyable is checked structurally, so for better performance, split apart
   // this constraint into individual Copyable constraints on each tuple element.
   if (auto *tupleType = type->getAs<TupleType>()) {

test/Generics/tuple-conformances.swift

@@ -38,6 +38,8 @@ func useConformance() {
 ////
 
 extension Builtin.TheTupleType: Equatable where repeat each Elements: Equatable {
+  // FIXME: Hack
+  @_disfavoredOverload
   public static func ==(lhs: Self, rhs: Self) -> Bool {
     var result = true
     func update<E: Equatable>(lhs: E, rhs: E) {