Merge pull request swiftlang#36657 from xedin/rdar-75978086

[CSBindings] A couple of adjustments to transitive protocol inference

Author: xedin

lib/Sema/CSBindings.cpp

@@ -290,25 +290,51 @@ void BindingSet::inferTransitiveProtocolRequirements(
     // If current type variable is part of an equivalence
     // class, make it a "representative" and let it infer
     // supertypes and direct protocol requirements from
-    // other members.
-    for (const auto &entry : bindings.Info.EquivalentTo) {
-      auto eqBindings = inferredBindings.find(entry.first);
-      if (eqBindings != inferredBindings.end()) {
-        const auto &bindings = eqBindings->getSecond();
-
-        llvm::SmallPtrSet<Constraint *, 2> placeholder;
-        // Add any direct protocols from members of the
-        // equivalence class, so they could be propagated
-        // to all of the members.
-        propagateProtocolsTo(currentVar, bindings.getConformanceRequirements(),
-                             placeholder);
-
-        // Since type variables are equal, current type variable
-        // becomes a subtype to any supertype found in the current
-        // equivalence  class.
-        for (const auto &eqEntry : bindings.Info.SubtypeOf)
-          addToWorkList(currentVar, eqEntry.first);
-      }
+    // other members and their equivalence classes.
+    SmallSetVector<TypeVariableType *, 4> equivalenceClass;
+    {
+      SmallVector<TypeVariableType *, 4> workList;
+      workList.push_back(currentVar);
+
+      do {
+        auto *typeVar = workList.pop_back_val();
+
+        if (!equivalenceClass.insert(typeVar))
+          continue;
+
+        auto bindingSet = inferredBindings.find(typeVar);
+        if (bindingSet == inferredBindings.end())
+          continue;
+
+        auto &equivalences = bindingSet->getSecond().Info.EquivalentTo;
+        for (const auto &eqVar : equivalences) {
+          workList.push_back(eqVar.first);
+        }
+      } while (!workList.empty());
+    }
+
+    for (const auto &memberVar : equivalenceClass) {
+      if (memberVar == currentVar)
+        continue;
+
+      auto eqBindings = inferredBindings.find(memberVar);
+      if (eqBindings == inferredBindings.end())
+        continue;
+
+      const auto &bindings = eqBindings->getSecond();
+
+      llvm::SmallPtrSet<Constraint *, 2> placeholder;
+      // Add any direct protocols from members of the
+      // equivalence class, so they could be propagated
+      // to all of the members.
+      propagateProtocolsTo(currentVar, bindings.getConformanceRequirements(),
+                           placeholder);
+
+      // Since type variables are equal, current type variable
+      // becomes a subtype to any supertype found in the current
+      // equivalence  class.
+      for (const auto &eqEntry : bindings.Info.SubtypeOf)
+        addToWorkList(currentVar, eqEntry.first);
     }
 
     // More subtype/equivalences relations have been added.
@@ -435,7 +461,6 @@ void BindingSet::inferTransitiveBindings(
 
 void BindingSet::finalize(
     llvm::SmallDenseMap<TypeVariableType *, BindingSet> &inferredBindings) {
-  inferTransitiveProtocolRequirements(inferredBindings);
   inferTransitiveBindings(inferredBindings);
 
   determineLiteralCoverage();
@@ -452,11 +477,14 @@ void BindingSet::finalize(
       // func foo<T: P>(_: T) {}
       // foo(.bar) <- `.bar` should be a static member of `P`.
       // \endcode
-      if (!hasViableBindings() && TransitiveProtocols.hasValue()) {
-        for (auto *constraint : *TransitiveProtocols) {
-          auto protocolTy = constraint->getSecondType();
-          addBinding(
-              {protocolTy, AllowedBindingKind::Exact, constraint});
+      if (!hasViableBindings()) {
+        inferTransitiveProtocolRequirements(inferredBindings);
+
+        if (TransitiveProtocols.hasValue()) {
+          for (auto *constraint : *TransitiveProtocols) {
+            auto protocolTy = constraint->getSecondType();
+            addBinding({protocolTy, AllowedBindingKind::Exact, constraint});
+          }
         }
       }
     }

lib/Sema/ConstraintSystem.cpp

@@ -1710,6 +1710,7 @@ ConstraintSystem::getTypeOfMemberReference(
         // Concrete type replacing `Self` could be generic, so we need
         // to make sure that it's opened before use.
         baseOpenedTy = openType(concreteSelf, replacements);
+        baseObjTy = baseOpenedTy;
       }
     }
   } else if (baseObjTy->isExistentialType()) {

test/Constraints/static_member_on_protocol_with_opaque_result.swift

@@ -0,0 +1,19 @@
+// RUN: %target-swift-frontend -disable-availability-checking -typecheck -verify %s
+
+// rdar://75978086 - static member lookup doesn't work with opaque types
+
+protocol Intent {}
+
+extension Intent where Self == Intents.List {
+  static func orderedList() -> Self {
+    return Intents.List.orderedList(nestedIn: nil)
+  }
+}
+
+enum Intents {
+  enum List: Intent {
+  case orderedList(nestedIn: Any?)
+  }
+}
+
+let rdar75978086: some Intent = .orderedList() // Ok

unittests/Sema/BindingInferenceTests.cpp

@@ -300,3 +300,39 @@ TEST_F(SemaTest, TestComplexTransitiveProtocolInference) {
       *bindingsForT5.TransitiveProtocols,
       {protocolTy1, protocolTy2, protocolTy3, protocolTy4});
 }
+
+/// Let's try a situation where there protocols are inferred from
+/// multiple sources on different levels of equivalence chain.
+///
+/// T0 = T1
+///         = T2 (P0)
+///              = T3 (P1)
+TEST_F(SemaTest, TestTransitiveProtocolInferenceThroughEquivalenceChains) {
+  ConstraintSystemOptions options;
+  ConstraintSystem cs(DC, options);
+
+  auto *protocolTy0 = createProtocol("P0");
+  auto *protocolTy1 = createProtocol("P1");
+
+  auto *nilLocator = cs.getConstraintLocator({});
+
+  auto typeVar0 = cs.createTypeVariable(nilLocator, /*options=*/0);
+  // Allow this type variable to be bound to l-value type to prevent
+  // it from being merged with the rest of the type variables.
+  auto typeVar1 =
+    cs.createTypeVariable(nilLocator, /*options=*/TVO_CanBindToLValue);
+  auto typeVar2 = cs.createTypeVariable(nilLocator, /*options=*/0);
+  auto typeVar3 = cs.createTypeVariable(nilLocator, TVO_CanBindToLValue);
+
+  cs.addConstraint(ConstraintKind::Conversion, typeVar0, typeVar1, nilLocator);
+  cs.addConstraint(ConstraintKind::Equal, typeVar1, typeVar2, nilLocator);
+  cs.addConstraint(ConstraintKind::Equal, typeVar2, typeVar3, nilLocator);
+  cs.addConstraint(ConstraintKind::ConformsTo, typeVar2, protocolTy0, nilLocator);
+  cs.addConstraint(ConstraintKind::ConformsTo, typeVar3, protocolTy1, nilLocator);
+
+  auto bindings = inferBindings(cs, typeVar0);
+
+  ASSERT_TRUE(bool(bindings.TransitiveProtocols));
+  verifyProtocolInferenceResults(*bindings.TransitiveProtocols,
+                                 {protocolTy0, protocolTy1});
+}

unittests/Sema/SemaFixture.cpp

@@ -136,6 +136,7 @@ BindingSet SemaTest::inferBindings(ConstraintSystem &cs,
       continue;
 
     auto &bindings = cachedBindings->getSecond();
+    bindings.inferTransitiveProtocolRequirements(cache);
     bindings.finalize(cache);
   }