LookupVisibleDecls: Fix duplicate completion results when inheritance is used with protocol conformance

Consider this setup:

protocol Proto {
  func foo() {}
}

class Base : Proto {
  func foo() {}
}

class Derived : Base {
  ...
}

When completing members of a Derived instance, we find both the protocol's
foo() and the base class's foo(). These have the following types:

- Proto.foo: <Self : Proto> (Self) -> () -> ()
- Base.foo: (Base) -> () -> ()

If we simply substitute the base type (Derived) into the type of the protocol
member, we get (Derived) -> () -> (), which is different than the type of
Base.foo, so we get both declarations in the completion list.

Instead, use the 'Self' type for the specific class of the conformance,
which in this case is 'Base' even if we're looking at members of 'Derived'.

Fixes <rdar://problem/21161476>, <https://bugs.swift.org/browse/SR-1181>.

Author: slavapestov

lib/AST/LookupVisibleDecls.cpp

@@ -679,6 +679,23 @@ template <> struct DenseMapInfo<FoundDeclTy> {
 
 } // namespace llvm
 
+// If a class 'Base' conforms to 'Proto', and my base type is a subclass
+// 'Derived' of 'Base', use 'Base' not 'Derived' as the 'Self' type in the
+// substitution map.
+static Type getBaseTypeForMember(ModuleDecl *M, ValueDecl *OtherVD, Type BaseTy) {
+  if (auto *Proto = OtherVD->getDeclContext()->getSelfProtocolDecl()) {
+    if (BaseTy->getClassOrBoundGenericClass()) {
+      if (auto Conformance = M->lookupConformance(BaseTy, Proto)) {
+        auto *Superclass = Conformance->getConcrete()->getRootConformance()
+            ->getType()->getClassOrBoundGenericClass();
+        return BaseTy->getSuperclassForDecl(Superclass);
+      }
+    }
+  }
+
+  return BaseTy;
+}
+
 namespace {
 
 class OverrideFilteringConsumer : public VisibleDeclConsumer {
@@ -789,7 +806,8 @@ class OverrideFilteringConsumer : public VisibleDeclConsumer {
       auto OtherSignature = OtherVD->getOverloadSignature();
       auto OtherSignatureType = OtherVD->getOverloadSignatureType();
       if (OtherSignatureType && shouldSubst) {
-        auto subs = BaseTy->getMemberSubstitutionMap(M, OtherVD);
+        auto ActualBaseTy = getBaseTypeForMember(M, OtherVD, BaseTy);
+        auto subs = ActualBaseTy->getMemberSubstitutionMap(M, OtherVD);
         if (auto CT = OtherSignatureType.subst(subs))
           OtherSignatureType = CT->getCanonicalType();
       }