Sema: Use new form of getOpenedExistentialSignature() in doesMemberHaveUnfulfillableConstraintsWithExistentialBase()

Author: slavapestov

lib/Sema/ConstraintSystem.cpp

@@ -7447,14 +7447,21 @@ static bool doesMemberHaveUnfulfillableConstraintsWithExistentialBase(
     return false;
   }
 
-  class IsDependentOnSelfInBaseTypeContextWalker : public TypeWalker {
-    CanGenericSignature Sig;
+  auto &ctx = member->getASTContext();
+  auto existentialSig = ctx.getOpenedExistentialSignature(baseTy);
+
+  class IsDependentOnOpenedExistentialSelf : public TypeWalker {
+    OpenedExistentialSignature existentialSig;
 
   public:
-    explicit IsDependentOnSelfInBaseTypeContextWalker(CanGenericSignature Sig)
-        : Sig(Sig) {}
+    explicit IsDependentOnOpenedExistentialSelf(OpenedExistentialSignature existentialSig)
+        : existentialSig(existentialSig) {}
 
     Action walkToTypePre(Type ty) override {
+      // We're looking at the interface type of a protocol member, so it's written
+      // in terms of `Self` (tau_0_0) and possibly type parameters at higher depth:
+      //
+      // <Self, ... where Self: P, ...>
       if (!ty->isTypeParameter()) {
         return Action::Continue;
       }
@@ -7463,25 +7470,44 @@ static bool doesMemberHaveUnfulfillableConstraintsWithExistentialBase(
         return Action::SkipNode;
       }
 
-      if (!Sig->isValidTypeParameter(ty)) {
+      // Ok, we found a type parameter rooted in `Self`. Replace `Self` with the
+      // opened Self type in the existential signature, which looks like this:
+      //
+      // <..., Self where ..., Self: P>
+      ty = ty.subst(
+        [&](SubstitutableType *type) -> Type {
+          return existentialSig.SelfType;
+        },
+        MakeAbstractConformanceForGenericType());
+
+      // Make sure this is valid first.
+      if (!existentialSig.OpenedSig->isValidTypeParameter(ty)) {
         return Action::SkipNode;
       }
 
-      const auto concreteTy = Sig->getConcreteType(ty);
-      if (concreteTy && !concreteTy->hasTypeParameter()) {
+      // If the existential type constrains Self.U to a type from the outer
+      // context, then the reduced type of Self.U in the existential signature
+      // will no longer contain Self.
+      ty = existentialSig.OpenedSig.getReducedType(ty);
+
+      if (!ty.findIf([&](Type t) -> bool {
+          if (auto *paramTy = t->getAs<GenericTypeParamType>())
+            return paramTy->isEqual(existentialSig.SelfType);
+          return false;
+        })) {
         return Action::SkipNode;
       }
 
+      // Ok, we found a type that depends on the opened existential Self.
       return Action::Stop;
     }
-  } isDependentOnSelfWalker(member->getASTContext().getOpenedExistentialSignature(
-      baseTy, GenericSignature()));
+  } isDependentOnSelf(existentialSig);
 
   for (const auto &req : sig.getRequirements()) {
     switch (req.getKind()) {
     case RequirementKind::Superclass: {
       if (req.getFirstType()->getRootGenericParam()->getDepth() > 0 &&
-          req.getSecondType().walk(isDependentOnSelfWalker)) {
+          req.getSecondType().walk(isDependentOnSelf)) {
         return true;
       }
 
@@ -7495,9 +7521,9 @@ static bool doesMemberHaveUnfulfillableConstraintsWithExistentialBase(
       };
 
       if ((isNonSelfRootedTypeParam(req.getFirstType()) &&
-           req.getSecondType().walk(isDependentOnSelfWalker)) ||
+           req.getSecondType().walk(isDependentOnSelf)) ||
           (isNonSelfRootedTypeParam(req.getSecondType()) &&
-           req.getFirstType().walk(isDependentOnSelfWalker))) {
+           req.getFirstType().walk(isDependentOnSelf))) {
         return true;
       }