RequirementMachine: A couple of improvements to concrete contraction

- Allow duplicate concrete type and superclass requirements on the
  same generic parameter, as long as they're identical. This can
  arise if requirement inference infers a requirement which the
  user then explicitly re-states.

- If duplicate requirements are found that name different types, drop
  only that generic parameter from consideration without giving up
  entirely.

- If a generic parameter is subject to both a concrete type and a
  superclass requirement, proceed with the concrete type requirement
  since it is more specific instead of giving up.

Author: slavapestov

lib/AST/RequirementMachine/ConcreteContraction.cpp

@@ -157,8 +157,10 @@ namespace {
 class ConcreteContraction {
   bool Debug;
 
-  llvm::SmallDenseMap<GenericParamKey, Type> ConcreteTypes;
-  llvm::SmallDenseMap<GenericParamKey, Type> Superclasses;
+  llvm::SmallDenseMap<GenericParamKey,
+                      llvm::SmallDenseSet<Type, 1>> ConcreteTypes;
+  llvm::SmallDenseMap<GenericParamKey,
+                      llvm::SmallDenseSet<Type, 1>> Superclasses;
   llvm::SmallDenseMap<GenericParamKey,
                       llvm::SmallVector<ProtocolDecl *, 1>> Conformances;
 
@@ -296,20 +298,22 @@ Type ConcreteContraction::substTypeParameter(
   Type concreteType;
   {
     auto found = ConcreteTypes.find(key);
-    if (found != ConcreteTypes.end())
-      concreteType = found->second;
+    if (found != ConcreteTypes.end() && found->second.size() == 1)
+      concreteType = *found->second.begin();
   }
 
   Type superclass;
   {
     auto found = Superclasses.find(key);
-    if (found != Superclasses.end())
-      superclass = found->second;
+    if (found != Superclasses.end() && found->second.size() == 1)
+      superclass = *found->second.begin();
   }
 
   if (!concreteType && !superclass)
     return type;
 
+  // If we have both, prefer the concrete type requirement since it is more
+  // specific.
   if (!concreteType) {
     assert(superclass);
 
@@ -434,35 +438,15 @@ bool ConcreteContraction::performConcreteContraction(
       if (constraintType->isTypeParameter())
         break;
 
-      auto entry = std::make_pair(GenericParamKey(genericParam),
-                                  constraintType);
-      bool inserted = ConcreteTypes.insert(entry).second;
-      if (!inserted) {
-        if (Debug) {
-          llvm::dbgs() << "@ Concrete contraction cannot proceed: "
-                       << "duplicate concrete type requirements\n";
-        }
-        return false;
-      }
-
+      ConcreteTypes[GenericParamKey(genericParam)].insert(constraintType);
       break;
     }
     case RequirementKind::Superclass: {
       auto constraintType = req.req.getSecondType();
       assert(!constraintType->isTypeParameter() &&
              "You forgot to call desugarRequirement()");
 
-      auto entry = std::make_pair(GenericParamKey(genericParam),
-                                  constraintType);
-      bool inserted = Superclasses.insert(entry).second;
-      if (!inserted) {
-        if (Debug) {
-          llvm::dbgs() << "@ Concrete contraction cannot proceed: "
-                       << "duplicate superclass requirements\n";
-        }
-        return false;
-      }
-
+      Superclasses[GenericParamKey(genericParam)].insert(constraintType);
       break;
     }
     case RequirementKind::Conformance: {
@@ -484,10 +468,10 @@ bool ConcreteContraction::performConcreteContraction(
   for (const auto &pair : Conformances) {
     auto subjectType = pair.first;
     auto found = Superclasses.find(subjectType);
-    if (found == Superclasses.end())
+    if (found == Superclasses.end() || found->second.size() != 1)
       continue;
 
-    auto superclassTy = found->second;
+    auto superclassTy = *found->second.begin();
 
     for (const auto *proto : pair.second) {
       if (auto otherSuperclassTy = proto->getSuperclass()) {
@@ -511,35 +495,27 @@ bool ConcreteContraction::performConcreteContraction(
   if (ConcreteTypes.empty() && Superclasses.empty())
     return false;
 
-  // If a generic parameter is subject to both a concrete type and superclass
-  // requirement, bail out because we're not smart enough to figure out what's
-  // going on.
-  for (auto pair : ConcreteTypes) {
-    auto subjectType = pair.first;
-
-    if (Superclasses.find(subjectType) != Superclasses.end()) {
-      if (Debug) {
-        llvm::dbgs() << "@ Concrete contraction cannot proceed; "
-                     << "τ_" << subjectType.Depth << "_" << subjectType.Index
-                     << " has both a concrete type and superclass requirement";
-      }
-      return false;
-    }
-  }
-
   if (Debug) {
     llvm::dbgs() << "@ Concrete types: @\n";
     for (auto pair : ConcreteTypes) {
       llvm::dbgs() << "- τ_" << pair.first.Depth
-                   << "_" << pair.first.Index << " == "
-                   << pair.second << "\n";
+                   << "_" << pair.first.Index;
+      if (pair.second.size() == 1) {
+        llvm::dbgs() << " == " << *pair.second.begin() << "\n";
+      } else {
+        llvm::dbgs() << " has duplicate concrete type requirements\n";
+      }
     }
 
     llvm::dbgs() << "@ Superclasses: @\n";
     for (auto pair : Superclasses) {
       llvm::dbgs() << "- τ_" << pair.first.Depth
-                   << "_" << pair.first.Index << " : "
-                   << pair.second << "\n";
+                   << "_" << pair.first.Index;
+      if (pair.second.size() == 1) {
+        llvm::dbgs() << " : " << *pair.second.begin() << "\n";
+      } else {
+        llvm::dbgs() << " has duplicate superclass requirements\n";
+      }
     }
   }
 

test/Generics/derived_via_concrete.swift

@@ -1,5 +1,5 @@
 // RUN: %target-typecheck-verify-swift -requirement-machine-inferred-signatures=off
-// RUN: not %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-inferred-signatures=on 2>&1 | %FileCheck %s
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-inferred-signatures=on 2>&1 | %FileCheck %s
 
 // FIXME: Both RUN lines should pass 'on' once diagnostics are implemented.
 
@@ -22,42 +22,53 @@ protocol W {
   associatedtype T : AnyObject
 }
 
-// CHECK: Generic signature: <A, B where A : X<B>, B : P>
+// CHECK-LABEL: .derivedViaConcreteX1@
+// CHECK-NEXT: Generic signature: <A, B where A : X<B>, B : P>
 func derivedViaConcreteX1<A, B>(_: A, _: B)
   where A : U, A : X<B> {}
 // expected-warning@-1 {{redundant conformance constraint 'A' : 'U'}}
 // expected-note@-2 {{conformance constraint 'A' : 'U' implied here}}
 
-// CHECK: Generic signature: <A, B where A : X<B>, B : P>
+// CHECK-LABEL: .derivedViaConcreteX2@
+// CHECK-NEXT: Generic signature: <A, B where A : X<B>, B : P>
 func derivedViaConcreteX2<A, B>(_: A, _: B)
   where A : U, B : P, A : X<B> {}
 // expected-warning@-1 {{redundant conformance constraint 'A' : 'U'}}
 // expected-note@-2 {{conformance constraint 'A' : 'U' implied here}}
 
-// CHECK: Generic signature: <A, B where A : Y<B>, B : C>
+// CHECK-LABEL: .derivedViaConcreteY1@
+// CHECK-NEXT: Generic signature: <A, B where A : Y<B>, B : C>
 func derivedViaConcreteY1<A, B>(_: A, _: B)
   where A : V, A : Y<B> {}
 // expected-warning@-1 {{redundant conformance constraint 'A' : 'V'}}
 // expected-note@-2 {{conformance constraint 'A' : 'V' implied here}}
 
-// CHECK: Generic signature: <A, B where A : Y<B>>
-//
-// FIXME: Should be <A, B where A : Y<B>, B : C>, but redundant
-// superclass requirements currently block concrete contraction.
-
+// CHECK-LABEL: .derivedViaConcreteY2@
+// CHECK-NEXT: Generic signature: <A, B where A : Y<B>, B : C>
 func derivedViaConcreteY2<A, B>(_: A, _: B)
   where A : V, B : C, A : Y<B> {}
 // expected-warning@-1 {{redundant conformance constraint 'A' : 'V'}}
 // expected-note@-2 {{conformance constraint 'A' : 'V' implied here}}
 
-// CHECK: Generic signature: <A, B where A : Z<B>, B : AnyObject>
+// CHECK-LABEL: .derivedViaConcreteZ1@
+// CHECK-NEXT: Generic signature: <A, B where A : Z<B>, B : AnyObject>
 func derivedViaConcreteZ1<A, B>(_: A, _: B)
   where A : W, A : Z<B> {}
 // expected-warning@-1 {{redundant conformance constraint 'A' : 'W'}}
 // expected-note@-2 {{conformance constraint 'A' : 'W' implied here}}
 
-// CHECK: Generic signature: <A, B where A : Z<B>, B : AnyObject>
+// CHECK-LABEL: .derivedViaConcreteZ2@
+// CHECK-NEXT: Generic signature: <A, B where A : Z<B>, B : AnyObject>
 func derivedViaConcreteZ2<A, B>(_: A, _: B)
   where A : W, B : AnyObject, A : Z<B> {}
 // expected-warning@-1 {{redundant conformance constraint 'A' : 'W'}}
 // expected-note@-2 {{conformance constraint 'A' : 'W' implied here}}
+
+class Base {}
+class Derived<T : C> : Base, V {}
+
+struct G<X : Base, Y> {}
+
+// CHECK-LABEL: ExtensionDecl line={{.*}} base=G
+// CHECK-NEXT: Generic signature: <X, Y where X == Derived<Y>, Y : C>
+extension G where X == Derived<Y> {}