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

[sammccall]

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

3456 ↗

(On Diff #398996)

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

3456 ↗

(On Diff #398996)

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

3459 ↗

(On Diff #398996)

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

clang/lib/Sema/SemaCodeComplete.cpp

5416–5422

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

5425

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 ↗

(On Diff #398996)

yes

clang/lib/Sema/SemaCodeComplete.cpp

5425

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

clang/lib/Sema/SemaCodeComplete.cpp

QualType getApproximateType(const Expr *E) {
   }
   // A dependent member: approximate-resolve the base, then lookup.
   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);
+    auto *RD = Base.isNull()
+                   ? nullptr
+                   : llvm::dyn_cast<CXXRecordDecl>(getAsRecordDecl(Base));
     if (RD && RD->isCompleteDefinition()) {
-      for (const auto *Member : RD->lookup(CDSME->getMember()))
-        if (const ValueDecl *VD = llvm::dyn_cast<ValueDecl>(Member))
-          return VD->getType().getNonReferenceType();
+      // Look up member heuristically, including in bases.
+      for (const auto *Member : RD->lookupDependentName(
+               CDSME->getMember(), [](const NamedDecl *Member) {
+                 return llvm::isa<ValueDecl>(Member);
+               })) {
+        return llvm::cast<ValueDecl>(Member)->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) {
   if (auto *PLE = llvm::dyn_cast_or_null<ParenListExpr>(Base)) {

clang/test/CodeCompletion/member-access.cpp

 // CHECK-RECOVERY: [#int#]member
 template <typename T>
 void fooDependent(T t) {
   // Overload not resolved, but we notice all candidates return the same type.
   overloaded(t).
 }
 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:295:17 %s -o - | FileCheck -check-prefix=CHECK-OVERLOAD %s
 // CHECK-OVERLOAD: [#int#]member
+
+struct Base4 {
+  Base4 base4();
+};
+
+template <typename T>
+struct Derived2 : Base4 {};
+
+template <typename T>
+void testMembersFromBasesInDependentContext() {
+  Derived2<T> X;
+  (void)X.base4().base4();
+  // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:310:19 %s -o - | FileCheck -check-prefix=CHECK-MEMBERS-FROM-BASE-DEPENDENT %s
+  // CHECK-MEMBERS-FROM-BASE-DEPENDENT: [#Base4#]base4
+}