1 | //===--- HeuristicResolver.cpp ---------------------------*- C++-*-===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | |
9 | #include "HeuristicResolver.h" |
10 | #include "clang/AST/ASTContext.h" |
11 | #include "clang/AST/CXXInheritance.h" |
12 | #include "clang/AST/DeclTemplate.h" |
13 | #include "clang/AST/ExprCXX.h" |
14 | #include "clang/AST/Type.h" |
15 | |
16 | namespace clang { |
17 | namespace clangd { |
18 | |
19 | // Convenience lambdas for use as the 'Filter' parameter of |
20 | // HeuristicResolver::resolveDependentMember(). |
21 | const auto NoFilter = [](const NamedDecl *D) { return true; }; |
22 | const auto NonStaticFilter = [](const NamedDecl *D) { |
23 | return D->isCXXInstanceMember(); |
24 | }; |
25 | const auto StaticFilter = [](const NamedDecl *D) { |
26 | return !D->isCXXInstanceMember(); |
27 | }; |
28 | const auto ValueFilter = [](const NamedDecl *D) { return isa<ValueDecl>(D); }; |
29 | const auto TypeFilter = [](const NamedDecl *D) { return isa<TypeDecl>(D); }; |
30 | const auto TemplateFilter = [](const NamedDecl *D) { |
31 | return isa<TemplateDecl>(D); |
32 | }; |
33 | |
34 | namespace { |
35 | |
36 | const Type *resolveDeclsToType(const std::vector<const NamedDecl *> &Decls, |
37 | ASTContext &Ctx) { |
38 | if (Decls.size() != 1) // Names an overload set -- just bail. |
39 | return nullptr; |
40 | if (const auto *TD = dyn_cast<TypeDecl>(Decls[0])) { |
41 | return Ctx.getTypeDeclType(TD).getTypePtr(); |
42 | } |
43 | if (const auto *VD = dyn_cast<ValueDecl>(Decls[0])) { |
44 | return VD->getType().getTypePtrOrNull(); |
45 | } |
46 | return nullptr; |
47 | } |
48 | |
49 | } // namespace |
50 | |
51 | // Helper function for HeuristicResolver::resolveDependentMember() |
52 | // which takes a possibly-dependent type `T` and heuristically |
53 | // resolves it to a CXXRecordDecl in which we can try name lookup. |
54 | CXXRecordDecl *HeuristicResolver::resolveTypeToRecordDecl(const Type *T) const { |
55 | assert(T); |
56 | |
57 | // Unwrap type sugar such as type aliases. |
58 | T = T->getCanonicalTypeInternal().getTypePtr(); |
59 | |
60 | if (const auto *DNT = T->getAs<DependentNameType>()) { |
61 | T = resolveDeclsToType(resolveDependentNameType(DNT), Ctx); |
62 | if (!T) |
63 | return nullptr; |
64 | T = T->getCanonicalTypeInternal().getTypePtr(); |
65 | } |
66 | |
67 | if (const auto *RT = T->getAs<RecordType>()) |
68 | return dyn_cast<CXXRecordDecl>(RT->getDecl()); |
69 | |
70 | if (const auto *ICNT = T->getAs<InjectedClassNameType>()) |
71 | T = ICNT->getInjectedSpecializationType().getTypePtrOrNull(); |
72 | if (!T) |
73 | return nullptr; |
74 | |
75 | const auto *TST = T->getAs<TemplateSpecializationType>(); |
76 | if (!TST) |
77 | return nullptr; |
78 | |
79 | const ClassTemplateDecl *TD = dyn_cast_or_null<ClassTemplateDecl>( |
80 | TST->getTemplateName().getAsTemplateDecl()); |
81 | if (!TD) |
82 | return nullptr; |
83 | |
84 | return TD->getTemplatedDecl(); |
85 | } |
86 | |
87 | const Type *HeuristicResolver::getPointeeType(const Type *T) const { |
88 | if (!T) |
89 | return nullptr; |
90 | |
91 | if (T->isPointerType()) |
92 | return T->castAs<PointerType>()->getPointeeType().getTypePtrOrNull(); |
93 | |
94 | // Try to handle smart pointer types. |
95 | |
96 | // Look up operator-> in the primary template. If we find one, it's probably a |
97 | // smart pointer type. |
98 | auto ArrowOps = resolveDependentMember( |
99 | T, Ctx.DeclarationNames.getCXXOperatorName(OO_Arrow), NonStaticFilter); |
100 | if (ArrowOps.empty()) |
101 | return nullptr; |
102 | |
103 | // Getting the return type of the found operator-> method decl isn't useful, |
104 | // because we discarded template arguments to perform lookup in the primary |
105 | // template scope, so the return type would just have the form U* where U is a |
106 | // template parameter type. |
107 | // Instead, just handle the common case where the smart pointer type has the |
108 | // form of SmartPtr<X, ...>, and assume X is the pointee type. |
109 | auto *TST = T->getAs<TemplateSpecializationType>(); |
110 | if (!TST) |
111 | return nullptr; |
112 | if (TST->template_arguments().size() == 0) |
113 | return nullptr; |
114 | const TemplateArgument &FirstArg = TST->template_arguments()[0]; |
115 | if (FirstArg.getKind() != TemplateArgument::Type) |
116 | return nullptr; |
117 | return FirstArg.getAsType().getTypePtrOrNull(); |
118 | } |
119 | |
120 | std::vector<const NamedDecl *> HeuristicResolver::resolveMemberExpr( |
121 | const CXXDependentScopeMemberExpr *ME) const { |
122 | // If the expression has a qualifier, first try resolving the member |
123 | // inside the qualifier's type. |
124 | // Note that we cannot use a NonStaticFilter in either case, for a couple |
125 | // of reasons: |
126 | // 1. It's valid to access a static member using instance member syntax, |
127 | // e.g. `instance.static_member`. |
128 | // 2. We can sometimes get a CXXDependentScopeMemberExpr for static |
129 | // member syntax too, e.g. if `X::static_member` occurs inside |
130 | // an instance method, it's represented as a CXXDependentScopeMemberExpr |
131 | // with `this` as the base expression as `X` as the qualifier |
132 | // (which could be valid if `X` names a base class after instantiation). |
133 | if (NestedNameSpecifier *NNS = ME->getQualifier()) { |
134 | if (const Type *QualifierType = resolveNestedNameSpecifierToType(NNS)) { |
135 | auto Decls = |
136 | resolveDependentMember(QualifierType, ME->getMember(), NoFilter); |
137 | if (!Decls.empty()) |
138 | return Decls; |
139 | } |
140 | } |
141 | |
142 | // If that didn't yield any results, try resolving the member inside |
143 | // the expression's base type. |
144 | const Type *BaseType = ME->getBaseType().getTypePtrOrNull(); |
145 | if (ME->isArrow()) { |
146 | BaseType = getPointeeType(BaseType); |
147 | } |
148 | if (!BaseType) |
149 | return {}; |
150 | if (const auto *BT = BaseType->getAs<BuiltinType>()) { |
151 | // If BaseType is the type of a dependent expression, it's just |
152 | // represented as BuiltinType::Dependent which gives us no information. We |
153 | // can get further by analyzing the dependent expression. |
154 | Expr *Base = ME->isImplicitAccess() ? nullptr : ME->getBase(); |
155 | if (Base && BT->getKind() == BuiltinType::Dependent) { |
156 | BaseType = resolveExprToType(Base); |
157 | } |
158 | } |
159 | return resolveDependentMember(BaseType, ME->getMember(), NoFilter); |
160 | } |
161 | |
162 | std::vector<const NamedDecl *> HeuristicResolver::resolveDeclRefExpr( |
163 | const DependentScopeDeclRefExpr *RE) const { |
164 | return resolveDependentMember(RE->getQualifier()->getAsType(), |
165 | RE->getDeclName(), StaticFilter); |
166 | } |
167 | |
168 | std::vector<const NamedDecl *> |
169 | HeuristicResolver::resolveTypeOfCallExpr(const CallExpr *CE) const { |
170 | const auto *CalleeType = resolveExprToType(CE->getCallee()); |
171 | if (!CalleeType) |
172 | return {}; |
173 | if (const auto *FnTypePtr = CalleeType->getAs<PointerType>()) |
174 | CalleeType = FnTypePtr->getPointeeType().getTypePtr(); |
175 | if (const FunctionType *FnType = CalleeType->getAs<FunctionType>()) { |
176 | if (const auto *D = |
177 | resolveTypeToRecordDecl(FnType->getReturnType().getTypePtr())) { |
178 | return {D}; |
179 | } |
180 | } |
181 | return {}; |
182 | } |
183 | |
184 | std::vector<const NamedDecl *> |
185 | HeuristicResolver::resolveCalleeOfCallExpr(const CallExpr *CE) const { |
186 | if (const auto *ND = dyn_cast_or_null<NamedDecl>(CE->getCalleeDecl())) { |
187 | return {ND}; |
188 | } |
189 | |
190 | return resolveExprToDecls(CE->getCallee()); |
191 | } |
192 | |
193 | std::vector<const NamedDecl *> HeuristicResolver::resolveUsingValueDecl( |
194 | const UnresolvedUsingValueDecl *UUVD) const { |
195 | return resolveDependentMember(UUVD->getQualifier()->getAsType(), |
196 | UUVD->getNameInfo().getName(), ValueFilter); |
197 | } |
198 | |
199 | std::vector<const NamedDecl *> HeuristicResolver::resolveDependentNameType( |
200 | const DependentNameType *DNT) const { |
201 | return resolveDependentMember( |
202 | resolveNestedNameSpecifierToType(DNT->getQualifier()), |
203 | DNT->getIdentifier(), TypeFilter); |
204 | } |
205 | |
206 | std::vector<const NamedDecl *> |
207 | HeuristicResolver::resolveTemplateSpecializationType( |
208 | const DependentTemplateSpecializationType *DTST) const { |
209 | return resolveDependentMember( |
210 | resolveNestedNameSpecifierToType(DTST->getQualifier()), |
211 | DTST->getIdentifier(), TemplateFilter); |
212 | } |
213 | |
214 | std::vector<const NamedDecl *> |
215 | HeuristicResolver::resolveExprToDecls(const Expr *E) const { |
216 | if (const auto *ME = dyn_cast<CXXDependentScopeMemberExpr>(E)) { |
217 | return resolveMemberExpr(ME); |
218 | } |
219 | if (const auto *RE = dyn_cast<DependentScopeDeclRefExpr>(E)) { |
220 | return resolveDeclRefExpr(RE); |
221 | } |
222 | if (const auto *OE = dyn_cast<OverloadExpr>(E)) { |
223 | return {OE->decls_begin(), OE->decls_end()}; |
224 | } |
225 | if (const auto *CE = dyn_cast<CallExpr>(E)) { |
226 | return resolveTypeOfCallExpr(CE); |
227 | } |
228 | if (const auto *ME = dyn_cast<MemberExpr>(E)) |
229 | return {ME->getMemberDecl()}; |
230 | |
231 | return {}; |
232 | } |
233 | |
234 | const Type *HeuristicResolver::resolveExprToType(const Expr *E) const { |
235 | std::vector<const NamedDecl *> Decls = resolveExprToDecls(E); |
236 | if (!Decls.empty()) |
237 | return resolveDeclsToType(Decls, Ctx); |
238 | |
239 | return E->getType().getTypePtr(); |
240 | } |
241 | |
242 | const Type *HeuristicResolver::resolveNestedNameSpecifierToType( |
243 | const NestedNameSpecifier *NNS) const { |
244 | if (!NNS) |
245 | return nullptr; |
246 | |
247 | // The purpose of this function is to handle the dependent (Kind == |
248 | // Identifier) case, but we need to recurse on the prefix because |
249 | // that may be dependent as well, so for convenience handle |
250 | // the TypeSpec cases too. |
251 | switch (NNS->getKind()) { |
252 | case NestedNameSpecifier::TypeSpec: |
253 | case NestedNameSpecifier::TypeSpecWithTemplate: |
254 | return NNS->getAsType(); |
255 | case NestedNameSpecifier::Identifier: { |
256 | return resolveDeclsToType( |
257 | resolveDependentMember( |
258 | resolveNestedNameSpecifierToType(NNS->getPrefix()), |
259 | NNS->getAsIdentifier(), TypeFilter), |
260 | Ctx); |
261 | } |
262 | default: |
263 | break; |
264 | } |
265 | return nullptr; |
266 | } |
267 | |
268 | namespace { |
269 | |
270 | bool isOrdinaryMember(const NamedDecl *ND) { |
271 | return ND->isInIdentifierNamespace(Decl::IDNS_Ordinary | Decl::IDNS_Tag | |
272 | Decl::IDNS_Member); |
273 | } |
274 | |
275 | bool findOrdinaryMember(const CXXRecordDecl *RD, CXXBasePath &Path, |
276 | DeclarationName Name) { |
277 | Path.Decls = RD->lookup(Name).begin(); |
278 | for (DeclContext::lookup_iterator I = Path.Decls, E = I.end(); I != E; ++I) |
279 | if (isOrdinaryMember(*I)) |
280 | return true; |
281 | |
282 | return false; |
283 | } |
284 | |
285 | } // namespace |
286 | |
287 | bool HeuristicResolver::findOrdinaryMemberInDependentClasses( |
288 | const CXXBaseSpecifier *Specifier, CXXBasePath &Path, |
289 | DeclarationName Name) const { |
290 | CXXRecordDecl *RD = |
291 | resolveTypeToRecordDecl(Specifier->getType().getTypePtr()); |
292 | if (!RD) |
293 | return false; |
294 | return findOrdinaryMember(RD, Path, Name); |
295 | } |
296 | |
297 | std::vector<const NamedDecl *> HeuristicResolver::lookupDependentName( |
298 | CXXRecordDecl *RD, DeclarationName Name, |
299 | llvm::function_ref<bool(const NamedDecl *ND)> Filter) const { |
300 | std::vector<const NamedDecl *> Results; |
301 | |
302 | // Lookup in the class. |
303 | bool AnyOrdinaryMembers = false; |
304 | for (const NamedDecl *ND : RD->lookup(Name)) { |
305 | if (isOrdinaryMember(ND)) |
306 | AnyOrdinaryMembers = true; |
307 | if (Filter(ND)) |
308 | Results.push_back(ND); |
309 | } |
310 | if (AnyOrdinaryMembers) |
311 | return Results; |
312 | |
313 | // Perform lookup into our base classes. |
314 | CXXBasePaths Paths; |
315 | Paths.setOrigin(RD); |
316 | if (!RD->lookupInBases( |
317 | [&](const CXXBaseSpecifier *Specifier, CXXBasePath &Path) { |
318 | return findOrdinaryMemberInDependentClasses(Specifier, Path, Name); |
319 | }, |
320 | Paths, /*LookupInDependent=*/true)) |
321 | return Results; |
322 | for (DeclContext::lookup_iterator I = Paths.front().Decls, E = I.end(); |
323 | I != E; ++I) { |
324 | if (isOrdinaryMember(*I) && Filter(*I)) |
325 | Results.push_back(*I); |
326 | } |
327 | return Results; |
328 | } |
329 | |
330 | std::vector<const NamedDecl *> HeuristicResolver::resolveDependentMember( |
331 | const Type *T, DeclarationName Name, |
332 | llvm::function_ref<bool(const NamedDecl *ND)> Filter) const { |
333 | if (!T) |
334 | return {}; |
335 | if (auto *ET = T->getAs<EnumType>()) { |
336 | auto Result = ET->getDecl()->lookup(Name); |
337 | return {Result.begin(), Result.end()}; |
338 | } |
339 | if (auto *RD = resolveTypeToRecordDecl(T)) { |
340 | if (!RD->hasDefinition()) |
341 | return {}; |
342 | RD = RD->getDefinition(); |
343 | return lookupDependentName(RD, Name, Filter); |
344 | } |
345 | return {}; |
346 | } |
347 | |
348 | } // namespace clangd |
349 | } // namespace clang |
350 | |