[CSFix] Check for constrained associated types via generic signature

Instead of checking for presence of `where` clause, let's use
requirement signature and check whether any of the requires are
anchored on a particular associated type.

Author: xedin

lib/Sema/CSFix.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/Type.h"
 #include "swift/AST/Types.h"
 #include "swift/AST/ExistentialLayout.h"
+#include "swift/AST/RequirementSignature.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Sema/ConstraintLocator.h"
 #include "swift/Sema/ConstraintSystem.h"
@@ -2234,7 +2235,7 @@ bool AddExplicitExistentialCoercion::isRequired(
         // If result is an existential type and the base has `where` clauses
         // associated with its associated types, the call needs a coercion.
         if (erasedMemberTy->isExistentialType() &&
-            hasConstrainedAssociatedTypes(member)) {
+            hasConstrainedAssociatedTypes(member, *existentialType)) {
           RequiresCoercion = true;
           return Action::Stop;
         }
@@ -2246,7 +2247,7 @@ bool AddExplicitExistentialCoercion::isRequired(
       // e.g. `$T` or `[$T]`.
       if (auto *typeVar = componentTy->getAs<TypeVariableType>()) {
         if (auto existentialType = GetExistentialType(typeVar)) {
-          RequiresCoercion |= hasConstrainedAssociatedTypes(
+          RequiresCoercion |= hasAnyConstrainedAssociatedTypes(
               (*existentialType)->getExistentialLayout());
           return RequiresCoercion ? Action::Stop : Action::SkipChildren;
         }
@@ -2256,19 +2257,105 @@ bool AddExplicitExistentialCoercion::isRequired(
     }
 
   private:
-    bool hasConstrainedAssociatedTypes(DependentMemberType *member) {
-      auto *assocType = member->getAssocType();
+    /// Check whether the given member type has any of its associated
+    /// types constrained by requirements associated with the given
+    /// existential type.
+    static bool hasConstrainedAssociatedTypes(DependentMemberType *member,
+                                              Type existentialTy) {
+      auto layout = existentialTy->getExistentialLayout();
+      for (auto *protocol : layout.getProtocols()) {
+        auto requirementSig = protocol->getRequirementSignature();
+        if (hasConstrainedAssociatedTypes(member,
+                                          requirementSig.getRequirements()))
+          return true;
+      }
+      return false;
+    }
 
-      // If this member has associated type requirements, we are done.
-      if (assocType->getTrailingWhereClause())
-        return true;
+    /// Check whether the given member type has any of its associated
+    /// types constrained by the given requirement set.
+    static bool
+    hasConstrainedAssociatedTypes(DependentMemberType *member,
+                                  ArrayRef<Requirement> requirements) {
+      for (const auto &req : requirements) {
+        switch (req.getKind()) {
+        case RequirementKind::Superclass:
+        case RequirementKind::Conformance:
+        case RequirementKind::Layout: {
+          if (isAnchoredOn(req.getFirstType(), member->getAssocType()))
+            return true;
+          break;
+        }
+
+        case RequirementKind::SameType: {
+          auto lhsTy = req.getFirstType();
+          auto rhsTy = req.getSecondType();
+
+          if (isAnchoredOn(lhsTy, member->getAssocType()) ||
+              isAnchoredOn(rhsTy, member->getAssocType()))
+            return true;
 
-      if (auto *DMT = member->getBase()->getAs<DependentMemberType>())
-        return hasConstrainedAssociatedTypes(DMT);
+          break;
+        }
+        }
+      }
 
       return false;
     }
 
+    /// Check whether any of the protocols mentioned in the given
+    /// existential layout have constraints associated with their
+    /// associated types via a `where` clause, for example:
+    /// `associatedtype A: P where A.B == Int`
+    static bool hasAnyConstrainedAssociatedTypes(ExistentialLayout layout) {
+      for (auto *protocol : layout.getProtocols()) {
+        auto requirementSig = protocol->getRequirementSignature();
+        for (const auto &req : requirementSig.getRequirements()) {
+          switch (req.getKind()) {
+          case RequirementKind::Conformance:
+          case RequirementKind::Layout:
+          case RequirementKind::Superclass: {
+            if (getMemberChainDepth(req.getFirstType()) > 1)
+              return true;
+            break;
+          }
+
+          case RequirementKind::SameType:
+            auto lhsTy = req.getFirstType();
+            auto rhsTy = req.getSecondType();
+
+            if (getMemberChainDepth(lhsTy) > 1 ||
+                getMemberChainDepth(rhsTy) > 1)
+              return true;
+
+            break;
+          }
+        }
+      }
+      return false;
+    }
+
+    /// Check whether the given type is a dependent member type and
+    /// is anchored on the given associated type e.g. type is `A.B.C`
+    /// and associated type is `A.B`.
+    static bool isAnchoredOn(Type type, AssociatedTypeDecl *assocTy,
+                             unsigned depth = 0) {
+      if (auto *member = type->getAs<DependentMemberType>()) {
+        if (member->getAssocType() == assocTy)
+          return depth > 0;
+
+        return isAnchoredOn(member->getBase(), assocTy, depth + 1);
+      }
+
+      return false;
+    }
+
+    static unsigned getMemberChainDepth(Type type, unsigned currDepth = 0) {
+      if (auto *memberTy = type->getAs<DependentMemberType>())
+        return getMemberChainDepth(memberTy->getBase(), currDepth + 1);
+      return currDepth;
+    }
+
     static Type getBaseTypeOfDependentMemberChain(DependentMemberType *member) {
       if (!member->getBase())
         return member;
@@ -2280,17 +2367,6 @@ bool AddExplicitExistentialCoercion::isRequired(
 
       return base;
     }
-
-    static bool hasConstrainedAssociatedTypes(ExistentialLayout layout) {
-      for (auto *protocol : layout.getProtocols()) {
-        if (llvm::any_of(protocol->getAssociatedTypeMembers(),
-                         [](const auto *assocTypeDecl) {
-                           return bool(assocTypeDecl->getTrailingWhereClause());
-                         }))
-          return true;
-      }
-      return false;
-    }
   };
 
   // First, let's check whether coercion is already there.

test/decl/protocol/existential_member_accesses_self_assoctype.swift

@@ -694,7 +694,7 @@ protocol MiscTestsProto {
 do {
   func miscTests(_ arg: any MiscTestsProto) {
     var r: any Sequence & IteratorProtocol = arg.getR()
-    r.makeIterator() // expected-warning {{result of call to 'makeIterator()' is unused}}
+    r.makeIterator() // expected-error {{inferred result type 'any IteratorProtocol' requires explicit coercion due to loss of generic requirements}} {{19-19=as any IteratorProtocol}}
     r.next() // expected-warning {{result of call to 'next()' is unused}}
     r.nonexistent() // expected-error {{value of type 'any IteratorProtocol & Sequence' has no member 'nonexistent'}}
 
@@ -786,8 +786,7 @@ do {
     _ = arg.method3 // expected-error {{member 'method3' cannot be used on value of type 'any ConcreteAssocTypes'; consider using a generic constraint instead}}
     _ = arg.property1 // expected-error {{member 'property1' cannot be used on value of type 'any ConcreteAssocTypes'; consider using a generic constraint instead}}
     // Covariant 'Self' erasure works in conjunction with concrete associated types.
-    let _: (Bool, any ConcreteAssocTypes) = arg.property2 // expected-error {{inferred result type '(Bool, any ConcreteAssocTypes)' requires explicit coercion due to loss of generic requirements}} {{58-58=as (Bool, any ConcreteAssocTypes)}}
-    let _: (Bool, any ConcreteAssocTypes) = arg.property2 as (Bool, any ConcreteAssocTypes) // Ok
+    let _: (Bool, any ConcreteAssocTypes) = arg.property2 // ok
     _ = arg.property3 // expected-error {{member 'property3' cannot be used on value of type 'any ConcreteAssocTypes'; consider using a generic constraint instead}}
     _ = arg[subscript1: false] // expected-error {{member 'subscript' cannot be used on value of type 'any ConcreteAssocTypes'; consider using a generic constraint instead}}
     _ = arg[subscript2: false] // expected-error {{member 'subscript' cannot be used on value of type 'any ConcreteAssocTypes'; consider using a generic constraint instead}}