[clang][CodeComplete] Perform approximate member search in bases

[sammccall]

clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp

3456

"undeducedtype" seems like a strange name for this test - MemberFromBaseOfDependent?

3456

you might want this test in clang/test/CodeCompletion as well/instead.

3459

does this also work if the base is dependent (Base<T>)?

clang/lib/Sema/SemaCodeComplete.cpp

5414

could be a little more precise: "look up member heuristically, including in bases"

5423

This case seems very nearly dead. Technically it is possible to get a CXXDependentScopeMemberExpr in C using recovery expr, but I can't find a case where this is useful. Maybe drop it?

[kadircet]

• Replace clangd unittest with clang lit
• get rid of non-cxxrecorddecl handling

[kadircet]

clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp

3459

yes

clang/lib/Sema/SemaCodeComplete.cpp

5423

ah right, i was mostly concerned about objc records, forgetting that we only perform this in dependent contexts :D

clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp

for (auto DocumentationFormat :
        {MarkupKind::PlainText, MarkupKind::Markdown}) {
     auto Sigs = signatures(Code.code(), Code.point(), /*IndexSymbols=*/{},
                            DocumentationFormat);
     ASSERT_EQ(Sigs.signatures.size(), 1U);
     EXPECT_EQ(Sigs.signatures[0].documentation.kind, DocumentationFormat);
   }
 }
 
+TEST(CompletionTest, UndeducedType) {
+  clangd::CodeCompleteOptions Opts;
+  const std::string Code = R"cpp(
+struct Base { Base foo(); };
+
+template <typename T> struct Foo : Base {
+  void bar() { this->foo().^foo(); }
+};
+  )cpp";
+
+  EXPECT_THAT(completions(Code, {}, Opts).Completions,
+              Contains(Labeled("foo()")));
+}
 } // namespace
 } // namespace clangd
 } // namespace clang

clang/lib/Sema/SemaCodeComplete.cpp

QualType getApproximateType(const Expr *E) {
   if (const auto *CDSME = llvm::dyn_cast<CXXDependentScopeMemberExpr>(E)) {
     QualType Base = CDSME->isImplicitAccess()
                         ? CDSME->getBaseType()
                         : getApproximateType(CDSME->getBase());
     if (CDSME->isArrow() && !Base.isNull())
       Base = Base->getPointeeType(); // could handle unique_ptr etc here?
     RecordDecl *RD = Base.isNull() ? nullptr : getAsRecordDecl(Base);
     if (RD && RD->isCompleteDefinition()) {
-      for (const auto *Member : RD->lookup(CDSME->getMember()))
+      // For c++ records perform a dependent name lookup, which also takes care
+      // of the bases.
+      if (auto *CXXRD = llvm::dyn_cast<CXXRecordDecl>(RD)) {
+        for (const auto *Member : CXXRD->lookupDependentName(
+                 CDSME->getMember(), [](const NamedDecl *Member) {
+                   return llvm::isa<ValueDecl>(Member);
+                 })) {
+          return llvm::cast<ValueDecl>(Member)->getType().getNonReferenceType();
+        }
+      } else {
+        for (const auto *Member : RD->lookup(CDSME->getMember())) {
           if (const ValueDecl *VD = llvm::dyn_cast<ValueDecl>(Member))
             return VD->getType().getNonReferenceType();
         }
       }
+    }
+  }
   return Unresolved;
 }
 
 // If \p Base is ParenListExpr, assume a chain of comma operators and pick the
 // last expr. We expect other ParenListExprs to be resolved to e.g. constructor
 // calls before here. (So the ParenListExpr should be nonempty, but check just
 // in case)
 Expr *unwrapParenList(Expr *Base) {