Sema: Handle generic-signature-based existential availability

Author: AnthonyLatsis

lib/Sema/ConstraintSystem.cpp

@@ -5789,6 +5789,68 @@ void ConstraintSystem::maybeProduceFallbackDiagnostic(
   ctx.Diags.diagnose(target.getLoc(), diag::failed_to_produce_diagnostic);
 }
 
+/// A protocol member accessed with an existential value might have generic
+/// constraints that require the ability to spell an opened archetype in order
+/// to be satisfied. Such are
+/// - superclass requirements, when the object is a non-'Self'-rooted type
+///   parameter, and the subject is dependent on 'Self', e.g. U : G<Self.A>
+/// - same-type requirements, when one side is dependent on 'Self', and the
+///   other is a non-'Self'-rooted type parameter, e.g. U.Element == Self.
+///
+/// Because opened archetypes are not part of the surface language, these
+/// constraints render the member inaccessible.
+static bool doesMemberHaveUnfulfillableConstraintsWithExistentialBase(
+    const ValueDecl *member) {
+  const auto sig =
+      member->getInnermostDeclContext()->getGenericSignatureOfContext();
+
+  // Fast path: the member is generic only over 'Self'.
+  if (sig.getGenericParams().size() == 1) {
+    return false;
+  }
+
+  const auto selfTy = sig.getGenericParams().front();
+
+  const auto isDependentOnSelf = [&](Type ty) {
+    return ty.findIf([&](Type ty) {
+      return ty->is<GenericTypeParamType>() && ty->isEqual(selfTy);
+    });
+  };
+
+  for (const auto &req : sig.getRequirements()) {
+    switch (req.getKind()) {
+    case RequirementKind::Superclass: {
+      if (!req.getFirstType()->getRootGenericParam()->isEqual(selfTy) &&
+          isDependentOnSelf(req.getSecondType())) {
+        return true;
+      }
+
+      break;
+    }
+    case RequirementKind::SameType: {
+      const auto isNonSelfRootedTypeParam = [&](Type ty) {
+        return ty->isTypeParameter() &&
+               !ty->getRootGenericParam()->isEqual(selfTy);
+      };
+
+      const auto lhs = req.getFirstType();
+      const auto rhs = req.getSecondType();
+      if ((isNonSelfRootedTypeParam(lhs) && isDependentOnSelf(rhs)) ||
+          (isNonSelfRootedTypeParam(rhs) && isDependentOnSelf(lhs))) {
+        return true;
+      }
+
+      break;
+    }
+    case RequirementKind::Conformance:
+    case RequirementKind::Layout:
+      break;
+    }
+  }
+
+  return false;
+}
+
 bool ConstraintSystem::isAvailableInExistential(const ProtocolDecl *proto,
                                                 const ValueDecl *member) const {
   // If the type of the member references 'Self' in non-covariant position, or
@@ -5805,6 +5867,10 @@ bool ConstraintSystem::isAvailableInExistential(const ProtocolDecl *proto,
       return false;
   }
 
+  if (doesMemberHaveUnfulfillableConstraintsWithExistentialBase(member)) {
+    return false;
+  }
+
   return true;
 }
 

test/decl/protocol/protocols_with_self_or_assoc_reqs.swift

@@ -474,6 +474,55 @@ do {
   }
 }
 
+protocol UnfulfillableGenericRequirements {
+  associatedtype A
+}
+extension UnfulfillableGenericRequirements {
+  func method1() where A : C<Self> {}
+  // expected-note@-1 {{where 'Self.A' = '(UnfulfillableGenericRequirements).A', 'C<Self>' = 'C<UnfulfillableGenericRequirements>'}}
+  func method2() where A: Sequence, A.Element == Self {}
+  // expected-note@-1 {{where 'Self' = 'UnfulfillableGenericRequirements', 'Self.A.Element' = '(UnfulfillableGenericRequirements).A.Element'}}
+  // expected-note@-2 {{where 'Self.A' = '(UnfulfillableGenericRequirements).A'}}
+  func method3<U>(_: U) -> U {}
+  func method4<U>(_: U) where U : C<Self> {}
+  // expected-note@-1 {{where 'U' = 'Bool', 'C<Self>' = 'C<UnfulfillableGenericRequirements>'}}
+  func method5<U>(_: U) where U: Sequence, Self == U.Element {}
+  // expected-note@-1 {{where 'U' = 'Bool'}}
+
+  // expected-note@+3 {{where 'Self.A' = '(UnfulfillableGenericRequirements).A'}}
+  // expected-note@+2 {{where 'Self.A.Element' = '(UnfulfillableGenericRequirements).A.Element'}}
+  // expected-note@+1 {{where 'U' = 'Bool'}}
+  func method6<U>(_: U) where U: UnfulfillableGenericRequirements,
+                              A: Sequence, A.Element: Sequence,
+                              U.A == A.Element.Element {}
+  func method7<U>(_: U) where U: UnfulfillableGenericRequirements & C<Self> {}
+  // expected-note@-1 {{where 'U' = 'C<UnfulfillableGenericRequirements>'}}
+}
+do {
+  let exist: any UnfulfillableGenericRequirements
+
+  exist.method1() // expected-error {{instance method 'method1()' requires that '(UnfulfillableGenericRequirements).A' inherit from 'C<UnfulfillableGenericRequirements>'}}
+  exist.method2()
+  // expected-error@-1 {{instance method 'method2()' requires the types 'UnfulfillableGenericRequirements' and '(UnfulfillableGenericRequirements).A.Element' be equivalent}}
+  // expected-error@-2 {{instance method 'method2()' requires that '(UnfulfillableGenericRequirements).A' conform to 'Sequence'}}
+  _ = exist.method3(false)
+  exist.method4(false)
+  // expected-error@-1 {{instance method 'method4' requires that 'Bool' inherit from 'C<UnfulfillableGenericRequirements>'}}
+  // expected-error@-2 {{member 'method4' cannot be used on value of protocol type 'UnfulfillableGenericRequirements'; use a generic constraint instead}}
+  exist.method5(false)
+  // expected-error@-1 {{instance method 'method5' requires that 'Bool' conform to 'Sequence'}}
+  // expected-error@-2 {{member 'method5' cannot be used on value of protocol type 'UnfulfillableGenericRequirements'; use a generic constraint instead}}
+  exist.method6(false)
+  // expected-error@-1 {{instance method 'method6' requires that '(UnfulfillableGenericRequirements).A.Element' conform to 'Sequence'}}
+  // expected-error@-2 {{instance method 'method6' requires that '(UnfulfillableGenericRequirements).A' conform to 'Sequence'}}
+  // expected-error@-3 {{instance method 'method6' requires that 'Bool' conform to 'UnfulfillableGenericRequirements'}}
+  // expected-error@-4 {{member 'method6' cannot be used on value of protocol type 'UnfulfillableGenericRequirements'; use a generic constraint instead}}
+  exist.method7(false)
+  // expected-error@-1 {{instance method 'method7' requires that 'C<UnfulfillableGenericRequirements>' conform to 'UnfulfillableGenericRequirements'}}
+  // expected-error@-2 {{member 'method7' cannot be used on value of protocol type 'UnfulfillableGenericRequirements'; use a generic constraint instead}}
+  // expected-error@-3 {{cannot convert value of type 'Bool' to expected argument type 'C<UnfulfillableGenericRequirements>'}}
+}
+
 // Settable storage members with a 'Self' result type may not be used with an
 // existential base.
 protocol P2 {