[GenericEnvironment] Drop same-element requirements from opened element generic

signatures to avoid ending up with a same-element requirement on the element
generic parameter.

Author: hborla

lib/AST/ASTContext.cpp

@@ -5662,28 +5662,40 @@ ASTContext::getOpenedElementSignature(CanGenericSignature baseGenericSig) {
   };
 
   for (auto requirement : baseGenericSig.getRequirements()) {
-    requirements.push_back(requirement);
-
     // If this requirement contains parameter packs, create a new requirement
     // for the corresponding pack element.
     switch (requirement.getKind()) {
     case RequirementKind::SameShape:
-      // Drop same-shape requirements from the element signature.
+      requirements.push_back(requirement);
+      // Same-shape requirements don't apply to elements.
       break;
     case RequirementKind::Conformance:
     case RequirementKind::Superclass:
     case RequirementKind::SameType: {
       auto firstType = eraseParameterPackRec(requirement.getFirstType());
       auto secondType = eraseParameterPackRec(requirement.getSecondType());
       if (firstType->isEqual(requirement.getFirstType()) &&
-          secondType->isEqual(requirement.getSecondType()))
+          secondType->isEqual(requirement.getSecondType())) {
+        requirements.push_back(requirement);
         break;
+      }
+
+      // FIXME: For now, Drop same-element requirements from opened
+      // element signatures. Otherwise, we can end up with a signature:
+      //
+      //    <T..., U, T_Element> where T == U, T_Element == U
+      //
+      // implying that T == T_Element
+      if (requirement.getKind() != RequirementKind::SameType) {
+        requirements.push_back(requirement);
+      }
 
       requirements.emplace_back(requirement.getKind(),
                                 firstType, secondType);
       break;
     }
     case RequirementKind::Layout: {
+      requirements.push_back(requirement);
       auto firstType = eraseParameterPackRec(requirement.getFirstType());
       if (firstType->isEqual(requirement.getFirstType()))
         break;

test/Constraints/pack-expansion-expressions.swift

@@ -42,3 +42,19 @@ func localValuePack<T...>(_ t: T...) -> (T..., T...) {
 
   return (local..., localAnnotated...)
 }
+
+protocol P {
+  associatedtype A
+
+  var value: A { get }
+
+  func f(_ self: Self) -> Self
+}
+
+func outerArchetype<T..., U>(t: T..., u: U) where T: P {
+  let _: ((T.A, U)...) = ((t.value, u)...)
+}
+
+func sameElement<T..., U>(t: T..., u: U) where T: P, T == U {
+  let _: (T...) =  (t.f(u)...)
+}