GSB: Skip same-type requirement minimization if there are no same-type requirements

The logic here is pretty expensive, and there's no reason to
do it at all if we aren't going to end up with any same-type
requirements.

Author: slavapestov

lib/AST/GenericSignatureBuilder.cpp

@@ -6470,14 +6470,16 @@ GenericSignatureBuilder::finalize(TypeArrayView<GenericTypeParamType> genericPar
     checkLayoutConstraints(genericParams, &equivClass);
   };
 
-  // FIXME: Expand all conformance requirements. This is expensive :(
-  for (auto &equivClass : Impl->EquivalenceClasses) {
+  if (!Impl->ExplicitSameTypeRequirements.empty()) {
+    // FIXME: Expand all conformance requirements. This is expensive :(
+    for (auto &equivClass : Impl->EquivalenceClasses) {
       expandSameTypeConstraints(*this, &equivClass);
-  }
+    }
 
-  // Check same-type constraints.
-  for (auto &equivClass : Impl->EquivalenceClasses) {
-    checkSameTypeConstraints(genericParams, &equivClass);
+    // Check same-type constraints.
+    for (auto &equivClass : Impl->EquivalenceClasses) {
+      checkSameTypeConstraints(genericParams, &equivClass);
+    }
   }
 
   // Check for generic parameters which have been made concrete or equated
@@ -8082,63 +8084,65 @@ void GenericSignatureBuilder::enumerateRequirements(
   }
 
   // Collect all same type requirements.
-  for (auto &equivClass : Impl->EquivalenceClasses) {
-    if (equivClass.derivedSameTypeComponents.empty()) {
-      checkSameTypeConstraints(genericParams, &equivClass);
-    }
-
-    for (unsigned i : indices(equivClass.derivedSameTypeComponents)) {
-      // Dig out the subject type and its corresponding component.
-      auto &component = equivClass.derivedSameTypeComponents[i];
-      Type subjectType = component.type;
+  if (!Impl->ExplicitSameTypeRequirements.empty()) {
+    for (auto &equivClass : Impl->EquivalenceClasses) {
+      if (equivClass.derivedSameTypeComponents.empty()) {
+        checkSameTypeConstraints(genericParams, &equivClass);
+      }
 
-      assert(!subjectType->hasError());
-      assert(!subjectType->findUnresolvedDependentMemberType());
+      for (unsigned i : indices(equivClass.derivedSameTypeComponents)) {
+        // Dig out the subject type and its corresponding component.
+        auto &component = equivClass.derivedSameTypeComponents[i];
+        Type subjectType = component.type;
+
+        assert(!subjectType->hasError());
+        assert(!subjectType->findUnresolvedDependentMemberType());
+
+        // If this equivalence class is bound to a concrete type, equate the
+        // anchor with a concrete type.
+        if (Type concreteType = equivClass.concreteType) {
+          concreteType = getCanonicalTypeInContext(concreteType, genericParams);
+
+          // If the parent of this anchor is also a concrete type, don't
+          // create a requirement.
+          if (!subjectType->is<GenericTypeParamType>() &&
+              maybeResolveEquivalenceClass(
+                subjectType->castTo<DependentMemberType>()->getBase(),
+                ArchetypeResolutionKind::WellFormed,
+                /*wantExactPotentialArchetype=*/false)
+                .getEquivalenceClass(*this)->concreteType)
+            continue;
 
-      // If this equivalence class is bound to a concrete type, equate the
-      // anchor with a concrete type.
-      if (Type concreteType = equivClass.concreteType) {
-        concreteType = getCanonicalTypeInContext(concreteType, genericParams);
+          // Drop recursive and invalid concrete-type constraints.
+          if (equivClass.recursiveConcreteType ||
+              equivClass.invalidConcreteType)
+            continue;
 
-        // If the parent of this anchor is also a concrete type, don't
-        // create a requirement.
-        if (!subjectType->is<GenericTypeParamType>() &&
-            maybeResolveEquivalenceClass(
-              subjectType->castTo<DependentMemberType>()->getBase(),
-              ArchetypeResolutionKind::WellFormed,
-              /*wantExactPotentialArchetype=*/false)
-              .getEquivalenceClass(*this)->concreteType)
+          // Filter out derived requirements... except for concrete-type
+          // requirements on generic parameters. The exception is due to
+          // the canonicalization of generic signatures, which never
+          // eliminates generic parameters even when they have been
+          // mapped to a concrete type.
+          if (subjectType->is<GenericTypeParamType>() ||
+              component.concreteTypeSource == nullptr ||
+              !component.concreteTypeSource->isDerivedRequirement()) {
+            recordRequirement(RequirementKind::SameType,
+                              subjectType, concreteType);
+          }
           continue;
+        }
 
-        // Drop recursive and invalid concrete-type constraints.
-        if (equivClass.recursiveConcreteType ||
-            equivClass.invalidConcreteType)
-          continue;
+        // If we're at the last anchor in the component, do nothing;
+        if (i + 1 != equivClass.derivedSameTypeComponents.size()) {
+          // Form a same-type constraint from this anchor within the component
+          // to the next.
+          // FIXME: Distinguish between explicit and inferred here?
+          auto &nextComponent = equivClass.derivedSameTypeComponents[i + 1];
+          Type otherSubjectType = nextComponent.type;
 
-        // Filter out derived requirements... except for concrete-type
-        // requirements on generic parameters. The exception is due to
-        // the canonicalization of generic signatures, which never
-        // eliminates generic parameters even when they have been
-        // mapped to a concrete type.
-        if (subjectType->is<GenericTypeParamType>() ||
-            component.concreteTypeSource == nullptr ||
-            !component.concreteTypeSource->isDerivedRequirement()) {
           recordRequirement(RequirementKind::SameType,
-                            subjectType, concreteType);
+                            subjectType, otherSubjectType);
         }
-        continue;
-      }
-
-      // If we're at the last anchor in the component, do nothing;
-      if (i + 1 != equivClass.derivedSameTypeComponents.size()) {
-        // Form a same-type constraint from this anchor within the component
-        // to the next.
-        // FIXME: Distinguish between explicit and inferred here?
-        auto &nextComponent = equivClass.derivedSameTypeComponents[i + 1];
-        Type otherSubjectType = nextComponent.type;
-
-        recordRequirement(RequirementKind::SameType,
-                          subjectType, otherSubjectType);
       }
     }
   }

test/Generics/indirectly_concrete_generic_param.swift

@@ -0,0 +1,17 @@
+// RUN: %target-typecheck-verify-swift
+// RUN: %target-swift-frontend -typecheck -debug-generic-signatures %s 2>&1 | %FileCheck %s
+
+class S<T, U> where T : P, U == T.T {}
+
+protocol P {
+  associatedtype T
+}
+
+struct G<X, T, U> {}
+
+class C : P {
+  typealias T = Int
+}
+
+// CHECK-LABEL: Generic signature: <X, T, U where X : S<T, C.T>, T : C, U == C.T>
+extension G where X : S<T, U>, T : C {}