[Mangling] Mangle generic signature requirements not satisfied by parent context.

The mangler had some ad hoc logic for only mangling requirements in a
generic signature that are not requirements in the parent context's
generic signature. However, it was based on an heuristic that isn't
correct. Replace that logic with a check to determine whether
the requirement is satisfied by the parent generic signature, which is
far simpler.

Fixes rdar://problem/31889040 / SR-6107.

Author: DougGregor

lib/AST/ASTMangler.cpp

@@ -1736,17 +1736,6 @@ static bool isMethodDecl(const Decl *decl) {
     && decl->getDeclContext()->isTypeContext();
 }
 
-static bool genericParamIsBelowDepth(Type type, unsigned methodDepth) {
-  if (!type->hasTypeParameter())
-    return true;
-
-  return !type.findIf([methodDepth](Type t) -> bool {
-    if (auto *gp = t->getAs<GenericTypeParamType>())
-      return gp->getDepth() >= methodDepth;
-    return false;
-  });
-}
-
 CanType ASTMangler::getDeclTypeForMangling(
     const ValueDecl *decl,
     ArrayRef<GenericTypeParamType *> &genericParams,
@@ -1803,25 +1792,12 @@ CanType ASTMangler::getDeclTypeForMangling(
 
         requirementsBuf.clear();
         for (auto &reqt : sig->getRequirements()) {
-          switch (reqt.getKind()) {
-        case RequirementKind::Conformance:
-        case RequirementKind::Layout:
-        case RequirementKind::Superclass:
-          // We don't need the requirement if the constrained type is below the
-          // method depth.
-          if (genericParamIsBelowDepth(reqt.getFirstType(), initialParamDepth))
-            continue;
-          break;
-        case RequirementKind::SameType:
-          // We don't need the requirement if both types are below the method
-          // depth, or non-dependent.
-          if (genericParamIsBelowDepth(reqt.getFirstType(), initialParamDepth) &&
-              genericParamIsBelowDepth(reqt.getSecondType(), initialParamDepth))
+          // If the requirement is satisfied by the enclosing context,
+          // we don't need to mangle it here.
+          if (parentGenericSig->isRequirementSatisfied(reqt))
             continue;
-          break;
-          }
 
-          // If we fell through the switch, mangle the requirement.
+          // Mangle the requirement.
           requirementsBuf.push_back(reqt);
         }
         requirements = requirementsBuf;

lib/AST/GenericSignature.cpp

@@ -678,14 +678,17 @@ bool GenericSignature::isRequirementSatisfied(Requirement requirement) {
   case RequirementKind::Layout: {
     auto requiredLayout = requirement.getLayoutConstraint();
 
-    if (canFirstType->isTypeParameter())
-      return getLayoutConstraint(canFirstType) == requiredLayout;
-    else {
-      // The requirement is on a concrete type, so it's either globally correct
-      // or globally incorrect, independent of this generic context. The latter
-      // case should be diagnosed elsewhere, so let's assume it's correct.
-      return true;
+    if (canFirstType->isTypeParameter()) {
+      if (auto layout = getLayoutConstraint(canFirstType))
+        return static_cast<bool>(layout.merge(requiredLayout));
+
+      return false;
     }
+
+    // The requirement is on a concrete type, so it's either globally correct
+    // or globally incorrect, independent of this generic context. The latter
+    // case should be diagnosed elsewhere, so let's assume it's correct.
+    return true;
   }
   }
 }

test/SILGen/mangling_generic_extensions.swift

@@ -21,7 +21,7 @@ extension Foo {
   // NO-SELF-LABEL: sil hidden @_T027mangling_generic_extensions3FooV4zangyqd__lF
   func zang<U>(_: U) { }
   // NO-SELF-LABEL: sil hidden @_T027mangling_generic_extensions3FooV4zungyqd__AA8RuncibleRd__3HatQyd__Rs_lF
-  func zung<U: Runcible where U.Hat == T>(_: U) { }
+  func zung<U: Runcible>(_: U) where U.Hat == T { }
 }
 
 extension Foo where T: Runcible {
@@ -56,3 +56,14 @@ extension Runcible where Self.Spoon == Self.Hat {
   // CHECK-LABEL: sil hidden @_T027mangling_generic_extensions8RunciblePA2aBRz5SpoonQz3HatRtzlE5runceyyF
   func runce() {}
 }
+
+
+struct Bar<T: Runcible, U: Runcible> { }
+
+extension Bar {
+  // CHECK-LABEL: _T027mangling_generic_extensions3BarV4bar1yqd__AA8RuncibleRd__AaE5SpoonRpzAFQy_AGRSlF
+  func bar1<V: Runcible>(_: V) where U.Spoon: Runcible, T.Spoon == U.Spoon { }
+
+  // CHECK-LABEL: _T027mangling_generic_extensions3BarV4bar1yqd__AA8RuncibleRd__AaE5SpoonRp_lF
+  func bar1<V: Runcible>(_: V) where U.Spoon: Runcible { }
+}