[CodeCompletion] Suggest static members on protocol extensions with Self bound in unresolved member lookup

rdar://122758029

Author: ahoppen

lib/Sema/IDETypeCheckingRequests.cpp

@@ -116,6 +116,31 @@ class ContainsSpecializableArchetype : public TypeWalker {
   }
 };
 
+/// Returns `true` if `ED` is an extension of `PD` that binds `Self` to a
+/// concrete type, like `extension MyProto where Self == MyStruct {}`.
+///
+/// In these cases, it is possible to access static members defined in the
+/// extension when perfoming unresolved member lookup in a type context of
+/// `PD`.
+static bool isExtensionWithSelfBound(const ExtensionDecl *ED,
+                                     ProtocolDecl *PD) {
+  if (!ED || !PD) {
+    return false;
+  }
+  GenericSignature genericSig = ED->getGenericSignature();
+  if (ED->getExtendedNominal() != PD) {
+    return false;
+  }
+  Type selfType = genericSig->getConcreteType(ED->getSelfInterfaceType());
+  if (!selfType) {
+    return false;
+  }
+  if (selfType->is<ExistentialType>()) {
+    return false;
+  }
+  return true;
+}
+
 static bool isExtensionAppliedInternal(const DeclContext *DC, Type BaseTy,
                                        const ExtensionDecl *ED) {
   // We can't do anything if the base type has unbound generic parameters.
@@ -131,6 +156,10 @@ static bool isExtensionAppliedInternal(const DeclContext *DC, Type BaseTy,
     return true;
 
   GenericSignature genericSig = ED->getGenericSignature();
+  if (isExtensionWithSelfBound(
+          ED, dyn_cast_or_null<ProtocolDecl>(BaseTy->getAnyNominal()))) {
+    return true;
+  }
   auto *module = DC->getParentModule();
   SubstitutionMap substMap = BaseTy->getContextSubstitutionMap(
       module, ED->getExtendedNominal());
@@ -142,7 +171,10 @@ static bool isExtensionAppliedInternal(const DeclContext *DC, Type BaseTy,
 
 static bool isMemberDeclAppliedInternal(const DeclContext *DC, Type BaseTy,
                                         const ValueDecl *VD) {
-  if (BaseTy->isExistentialType() && VD->isStatic())
+  if (BaseTy->isExistentialType() && VD->isStatic() &&
+      !isExtensionWithSelfBound(
+          dyn_cast<ExtensionDecl>(VD->getDeclContext()),
+          dyn_cast_or_null<ProtocolDecl>(BaseTy->getAnyNominal())))
     return false;
 
   // We can't leak type variables into another constraint system.

test/IDE/complete_protocol_static_member_with_protocol_contextual_type.swift

@@ -0,0 +1,27 @@
+// RUN: %batch-code-completion
+
+protocol MyProto {}
+protocol MyOtherProto: MyProto {}
+struct MyStruct : MyProto {}
+extension MyProto where Self == MyStruct {
+  static var constrainedOnMyStruct: MyStruct { fatalError() }
+}
+extension MyProto where Self: MyOtherProto {
+  static var constrainedonMyInheritanceOfOtherProto: MyOtherProto { fatalError() }
+}
+extension MyProto where Self == MyOtherProto {
+  static var constrainedonMyEqualityOfOtherProto: MyOtherProto { fatalError() }
+}
+
+
+func testOnMyProto() {
+  let _: MyProto = .#^ON_MY_PROTO^#
+// ON_MY_PROTO: Begin completions, 1 items
+// ON_MY_PROTO-DAG: Decl[StaticVar]/CurrNominal/TypeRelation[Convertible]: constrainedOnMyStruct[#MyStruct#];
+}
+
+func testOnMyOtherProto() {
+  // constrainedOnMyStruct is not valid here
+  let _: MyOtherProto = .#^ON_MY_OTHER_PROTO^#
+// ON_MY_OTHER_PROTO-NOT: Begin completions
+}