1//===--------------------- SemaLookup.cpp - Name Lookup ------------------===//
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// This file implements name lookup for C, C++, Objective-C, and
10// Objective-C++.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/CXXInheritance.h"
16#include "clang/AST/Decl.h"
17#include "clang/AST/DeclCXX.h"
18#include "clang/AST/DeclLookups.h"
19#include "clang/AST/DeclObjC.h"
20#include "clang/AST/DeclTemplate.h"
21#include "clang/AST/Expr.h"
22#include "clang/AST/ExprCXX.h"
23#include "clang/Basic/Builtins.h"
24#include "clang/Basic/LangOptions.h"
25#include "clang/Basic/TargetInfo.h"
26#include "clang/Lex/HeaderSearch.h"
27#include "clang/Lex/ModuleLoader.h"
28#include "clang/Lex/Preprocessor.h"
29#include "clang/Sema/DeclSpec.h"
30#include "clang/Sema/Lookup.h"
31#include "clang/Sema/Overload.h"
32#include "clang/Sema/RISCVIntrinsicManager.h"
33#include "clang/Sema/Scope.h"
34#include "clang/Sema/ScopeInfo.h"
35#include "clang/Sema/Sema.h"
36#include "clang/Sema/SemaInternal.h"
37#include "clang/Sema/SemaRISCV.h"
38#include "clang/Sema/TemplateDeduction.h"
39#include "clang/Sema/TypoCorrection.h"
40#include "llvm/ADT/STLExtras.h"
41#include "llvm/ADT/STLForwardCompat.h"
42#include "llvm/ADT/SmallPtrSet.h"
43#include "llvm/ADT/TinyPtrVector.h"
44#include "llvm/ADT/edit_distance.h"
45#include "llvm/Support/Casting.h"
46#include "llvm/Support/ErrorHandling.h"
47#include <algorithm>
48#include <iterator>
49#include <list>
50#include <optional>
51#include <set>
52#include <utility>
53#include <vector>
54
55#include "OpenCLBuiltins.inc"
56
57using namespace clang;
58using namespace sema;
59
60namespace {
61 class UnqualUsingEntry {
62 const DeclContext *Nominated;
63 const DeclContext *CommonAncestor;
64
65 public:
66 UnqualUsingEntry(const DeclContext *Nominated,
67 const DeclContext *CommonAncestor)
68 : Nominated(Nominated), CommonAncestor(CommonAncestor) {
69 }
70
71 const DeclContext *getCommonAncestor() const {
72 return CommonAncestor;
73 }
74
75 const DeclContext *getNominatedNamespace() const {
76 return Nominated;
77 }
78
79 // Sort by the pointer value of the common ancestor.
80 struct Comparator {
81 bool operator()(const UnqualUsingEntry &L, const UnqualUsingEntry &R) {
82 return L.getCommonAncestor() < R.getCommonAncestor();
83 }
84
85 bool operator()(const UnqualUsingEntry &E, const DeclContext *DC) {
86 return E.getCommonAncestor() < DC;
87 }
88
89 bool operator()(const DeclContext *DC, const UnqualUsingEntry &E) {
90 return DC < E.getCommonAncestor();
91 }
92 };
93 };
94
95 /// A collection of using directives, as used by C++ unqualified
96 /// lookup.
97 class UnqualUsingDirectiveSet {
98 Sema &SemaRef;
99
100 typedef SmallVector<UnqualUsingEntry, 8> ListTy;
101
102 ListTy list;
103 llvm::SmallPtrSet<DeclContext*, 8> visited;
104
105 public:
106 UnqualUsingDirectiveSet(Sema &SemaRef) : SemaRef(SemaRef) {}
107
108 void visitScopeChain(Scope *S, Scope *InnermostFileScope) {
109 // C++ [namespace.udir]p1:
110 // During unqualified name lookup, the names appear as if they
111 // were declared in the nearest enclosing namespace which contains
112 // both the using-directive and the nominated namespace.
113 DeclContext *InnermostFileDC = InnermostFileScope->getEntity();
114 assert(InnermostFileDC && InnermostFileDC->isFileContext());
115
116 for (; S; S = S->getParent()) {
117 // C++ [namespace.udir]p1:
118 // A using-directive shall not appear in class scope, but may
119 // appear in namespace scope or in block scope.
120 DeclContext *Ctx = S->getEntity();
121 if (Ctx && Ctx->isFileContext()) {
122 visit(DC: Ctx, EffectiveDC: Ctx);
123 } else if (!Ctx || Ctx->isFunctionOrMethod()) {
124 for (auto *I : S->using_directives())
125 if (SemaRef.isVisible(D: I))
126 visit(UD: I, EffectiveDC: InnermostFileDC);
127 }
128 }
129 }
130
131 // Visits a context and collect all of its using directives
132 // recursively. Treats all using directives as if they were
133 // declared in the context.
134 //
135 // A given context is only every visited once, so it is important
136 // that contexts be visited from the inside out in order to get
137 // the effective DCs right.
138 void visit(DeclContext *DC, DeclContext *EffectiveDC) {
139 if (!visited.insert(Ptr: DC).second)
140 return;
141
142 addUsingDirectives(DC, EffectiveDC);
143 }
144
145 // Visits a using directive and collects all of its using
146 // directives recursively. Treats all using directives as if they
147 // were declared in the effective DC.
148 void visit(UsingDirectiveDecl *UD, DeclContext *EffectiveDC) {
149 DeclContext *NS = UD->getNominatedNamespace();
150 if (!visited.insert(Ptr: NS).second)
151 return;
152
153 addUsingDirective(UD, EffectiveDC);
154 addUsingDirectives(DC: NS, EffectiveDC);
155 }
156
157 // Adds all the using directives in a context (and those nominated
158 // by its using directives, transitively) as if they appeared in
159 // the given effective context.
160 void addUsingDirectives(DeclContext *DC, DeclContext *EffectiveDC) {
161 SmallVector<DeclContext*, 4> queue;
162 while (true) {
163 for (auto *UD : DC->using_directives()) {
164 DeclContext *NS = UD->getNominatedNamespace();
165 if (SemaRef.isVisible(D: UD) && visited.insert(Ptr: NS).second) {
166 addUsingDirective(UD, EffectiveDC);
167 queue.push_back(Elt: NS);
168 }
169 }
170
171 if (queue.empty())
172 return;
173
174 DC = queue.pop_back_val();
175 }
176 }
177
178 // Add a using directive as if it had been declared in the given
179 // context. This helps implement C++ [namespace.udir]p3:
180 // The using-directive is transitive: if a scope contains a
181 // using-directive that nominates a second namespace that itself
182 // contains using-directives, the effect is as if the
183 // using-directives from the second namespace also appeared in
184 // the first.
185 void addUsingDirective(UsingDirectiveDecl *UD, DeclContext *EffectiveDC) {
186 // Find the common ancestor between the effective context and
187 // the nominated namespace.
188 DeclContext *Common = UD->getNominatedNamespace();
189 while (!Common->Encloses(DC: EffectiveDC))
190 Common = Common->getParent();
191 Common = Common->getPrimaryContext();
192
193 list.push_back(Elt: UnqualUsingEntry(UD->getNominatedNamespace(), Common));
194 }
195
196 void done() { llvm::stable_sort(Range&: list, C: UnqualUsingEntry::Comparator()); }
197
198 typedef ListTy::const_iterator const_iterator;
199
200 const_iterator begin() const { return list.begin(); }
201 const_iterator end() const { return list.end(); }
202
203 llvm::iterator_range<const_iterator>
204 getNamespacesFor(const DeclContext *DC) const {
205 return llvm::make_range(p: std::equal_range(first: begin(), last: end(),
206 val: DC->getPrimaryContext(),
207 comp: UnqualUsingEntry::Comparator()));
208 }
209 };
210} // end anonymous namespace
211
212// Retrieve the set of identifier namespaces that correspond to a
213// specific kind of name lookup.
214static inline unsigned getIDNS(Sema::LookupNameKind NameKind,
215 bool CPlusPlus,
216 bool Redeclaration) {
217 unsigned IDNS = 0;
218 switch (NameKind) {
219 case Sema::LookupObjCImplicitSelfParam:
220 case Sema::LookupOrdinaryName:
221 case Sema::LookupRedeclarationWithLinkage:
222 case Sema::LookupLocalFriendName:
223 case Sema::LookupDestructorName:
224 IDNS = Decl::IDNS_Ordinary;
225 if (CPlusPlus) {
226 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Member | Decl::IDNS_Namespace;
227 if (Redeclaration)
228 IDNS |= Decl::IDNS_TagFriend | Decl::IDNS_OrdinaryFriend;
229 }
230 if (Redeclaration)
231 IDNS |= Decl::IDNS_LocalExtern;
232 break;
233
234 case Sema::LookupOperatorName:
235 // Operator lookup is its own crazy thing; it is not the same
236 // as (e.g.) looking up an operator name for redeclaration.
237 assert(!Redeclaration && "cannot do redeclaration operator lookup");
238 IDNS = Decl::IDNS_NonMemberOperator;
239 break;
240
241 case Sema::LookupTagName:
242 if (CPlusPlus) {
243 IDNS = Decl::IDNS_Type;
244
245 // When looking for a redeclaration of a tag name, we add:
246 // 1) TagFriend to find undeclared friend decls
247 // 2) Namespace because they can't "overload" with tag decls.
248 // 3) Tag because it includes class templates, which can't
249 // "overload" with tag decls.
250 if (Redeclaration)
251 IDNS |= Decl::IDNS_Tag | Decl::IDNS_TagFriend | Decl::IDNS_Namespace;
252 } else {
253 IDNS = Decl::IDNS_Tag;
254 }
255 break;
256
257 case Sema::LookupLabel:
258 IDNS = Decl::IDNS_Label;
259 break;
260
261 case Sema::LookupMemberName:
262 IDNS = Decl::IDNS_Member;
263 if (CPlusPlus)
264 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Ordinary;
265 break;
266
267 case Sema::LookupNestedNameSpecifierName:
268 IDNS = Decl::IDNS_Type | Decl::IDNS_Namespace;
269 break;
270
271 case Sema::LookupNamespaceName:
272 IDNS = Decl::IDNS_Namespace;
273 break;
274
275 case Sema::LookupUsingDeclName:
276 assert(Redeclaration && "should only be used for redecl lookup");
277 IDNS = Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Member |
278 Decl::IDNS_Using | Decl::IDNS_TagFriend | Decl::IDNS_OrdinaryFriend |
279 Decl::IDNS_LocalExtern;
280 break;
281
282 case Sema::LookupObjCProtocolName:
283 IDNS = Decl::IDNS_ObjCProtocol;
284 break;
285
286 case Sema::LookupOMPReductionName:
287 IDNS = Decl::IDNS_OMPReduction;
288 break;
289
290 case Sema::LookupOMPMapperName:
291 IDNS = Decl::IDNS_OMPMapper;
292 break;
293
294 case Sema::LookupAnyName:
295 IDNS = Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Member
296 | Decl::IDNS_Using | Decl::IDNS_Namespace | Decl::IDNS_ObjCProtocol
297 | Decl::IDNS_Type;
298 break;
299 }
300 return IDNS;
301}
302
303void LookupResult::configure() {
304 IDNS = getIDNS(NameKind: LookupKind, CPlusPlus: getSema().getLangOpts().CPlusPlus,
305 Redeclaration: isForRedeclaration());
306
307 // If we're looking for one of the allocation or deallocation
308 // operators, make sure that the implicitly-declared new and delete
309 // operators can be found.
310 switch (NameInfo.getName().getCXXOverloadedOperator()) {
311 case OO_New:
312 case OO_Delete:
313 case OO_Array_New:
314 case OO_Array_Delete:
315 getSema().DeclareGlobalNewDelete();
316 break;
317
318 default:
319 break;
320 }
321
322 // Compiler builtins are always visible, regardless of where they end
323 // up being declared.
324 if (IdentifierInfo *Id = NameInfo.getName().getAsIdentifierInfo()) {
325 if (unsigned BuiltinID = Id->getBuiltinID()) {
326 if (!getSema().Context.BuiltinInfo.isPredefinedLibFunction(ID: BuiltinID))
327 AllowHidden = true;
328 }
329 }
330}
331
332bool LookupResult::checkDebugAssumptions() const {
333 // This function is never called by NDEBUG builds.
334 assert(ResultKind != LookupResultKind::NotFound || Decls.size() == 0);
335 assert(ResultKind != LookupResultKind::Found || Decls.size() == 1);
336 assert(ResultKind != LookupResultKind::FoundOverloaded || Decls.size() > 1 ||
337 (Decls.size() == 1 &&
338 isa<FunctionTemplateDecl>((*begin())->getUnderlyingDecl())));
339 assert(ResultKind != LookupResultKind::FoundUnresolvedValue ||
340 checkUnresolved());
341 assert(ResultKind != LookupResultKind::Ambiguous || Decls.size() > 1 ||
342 (Decls.size() == 1 &&
343 (Ambiguity == LookupAmbiguityKind::AmbiguousBaseSubobjects ||
344 Ambiguity == LookupAmbiguityKind::AmbiguousBaseSubobjectTypes)));
345 assert((Paths != nullptr) ==
346 (ResultKind == LookupResultKind::Ambiguous &&
347 (Ambiguity == LookupAmbiguityKind::AmbiguousBaseSubobjectTypes ||
348 Ambiguity == LookupAmbiguityKind::AmbiguousBaseSubobjects)));
349 return true;
350}
351
352// Necessary because CXXBasePaths is not complete in Sema.h
353void LookupResult::deletePaths(CXXBasePaths *Paths) {
354 delete Paths;
355}
356
357/// Get a representative context for a declaration such that two declarations
358/// will have the same context if they were found within the same scope.
359static const DeclContext *getContextForScopeMatching(const Decl *D) {
360 // For function-local declarations, use that function as the context. This
361 // doesn't account for scopes within the function; the caller must deal with
362 // those.
363 if (const DeclContext *DC = D->getLexicalDeclContext();
364 DC->isFunctionOrMethod())
365 return DC;
366
367 // Otherwise, look at the semantic context of the declaration. The
368 // declaration must have been found there.
369 return D->getDeclContext()->getRedeclContext();
370}
371
372/// Determine whether \p D is a better lookup result than \p Existing,
373/// given that they declare the same entity.
374static bool isPreferredLookupResult(Sema &S, Sema::LookupNameKind Kind,
375 const NamedDecl *D,
376 const NamedDecl *Existing) {
377 // When looking up redeclarations of a using declaration, prefer a using
378 // shadow declaration over any other declaration of the same entity.
379 if (Kind == Sema::LookupUsingDeclName && isa<UsingShadowDecl>(Val: D) &&
380 !isa<UsingShadowDecl>(Val: Existing))
381 return true;
382
383 const auto *DUnderlying = D->getUnderlyingDecl();
384 const auto *EUnderlying = Existing->getUnderlyingDecl();
385
386 // If they have different underlying declarations, prefer a typedef over the
387 // original type (this happens when two type declarations denote the same
388 // type), per a generous reading of C++ [dcl.typedef]p3 and p4. The typedef
389 // might carry additional semantic information, such as an alignment override.
390 // However, per C++ [dcl.typedef]p5, when looking up a tag name, prefer a tag
391 // declaration over a typedef. Also prefer a tag over a typedef for
392 // destructor name lookup because in some contexts we only accept a
393 // class-name in a destructor declaration.
394 if (DUnderlying->getCanonicalDecl() != EUnderlying->getCanonicalDecl()) {
395 assert(isa<TypeDecl>(DUnderlying) && isa<TypeDecl>(EUnderlying));
396 bool HaveTag = isa<TagDecl>(Val: EUnderlying);
397 bool WantTag =
398 Kind == Sema::LookupTagName || Kind == Sema::LookupDestructorName;
399 return HaveTag != WantTag;
400 }
401
402 // Pick the function with more default arguments.
403 // FIXME: In the presence of ambiguous default arguments, we should keep both,
404 // so we can diagnose the ambiguity if the default argument is needed.
405 // See C++ [over.match.best]p3.
406 if (const auto *DFD = dyn_cast<FunctionDecl>(Val: DUnderlying)) {
407 const auto *EFD = cast<FunctionDecl>(Val: EUnderlying);
408 unsigned DMin = DFD->getMinRequiredArguments();
409 unsigned EMin = EFD->getMinRequiredArguments();
410 // If D has more default arguments, it is preferred.
411 if (DMin != EMin)
412 return DMin < EMin;
413 // FIXME: When we track visibility for default function arguments, check
414 // that we pick the declaration with more visible default arguments.
415 }
416
417 // Pick the template with more default template arguments.
418 if (const auto *DTD = dyn_cast<TemplateDecl>(Val: DUnderlying)) {
419 const auto *ETD = cast<TemplateDecl>(Val: EUnderlying);
420 unsigned DMin = DTD->getTemplateParameters()->getMinRequiredArguments();
421 unsigned EMin = ETD->getTemplateParameters()->getMinRequiredArguments();
422 // If D has more default arguments, it is preferred. Note that default
423 // arguments (and their visibility) is monotonically increasing across the
424 // redeclaration chain, so this is a quick proxy for "is more recent".
425 if (DMin != EMin)
426 return DMin < EMin;
427 // If D has more *visible* default arguments, it is preferred. Note, an
428 // earlier default argument being visible does not imply that a later
429 // default argument is visible, so we can't just check the first one.
430 for (unsigned I = DMin, N = DTD->getTemplateParameters()->size();
431 I != N; ++I) {
432 if (!S.hasVisibleDefaultArgument(
433 D: ETD->getTemplateParameters()->getParam(Idx: I)) &&
434 S.hasVisibleDefaultArgument(
435 D: DTD->getTemplateParameters()->getParam(Idx: I)))
436 return true;
437 }
438 }
439
440 // VarDecl can have incomplete array types, prefer the one with more complete
441 // array type.
442 if (const auto *DVD = dyn_cast<VarDecl>(Val: DUnderlying)) {
443 const auto *EVD = cast<VarDecl>(Val: EUnderlying);
444 if (EVD->getType()->isIncompleteType() &&
445 !DVD->getType()->isIncompleteType()) {
446 // Prefer the decl with a more complete type if visible.
447 return S.isVisible(D: DVD);
448 }
449 return false; // Avoid picking up a newer decl, just because it was newer.
450 }
451
452 // For most kinds of declaration, it doesn't really matter which one we pick.
453 if (!isa<FunctionDecl>(Val: DUnderlying) && !isa<VarDecl>(Val: DUnderlying)) {
454 // If the existing declaration is hidden, prefer the new one. Otherwise,
455 // keep what we've got.
456 return !S.isVisible(D: Existing);
457 }
458
459 // Pick the newer declaration; it might have a more precise type.
460 for (const Decl *Prev = DUnderlying->getPreviousDecl(); Prev;
461 Prev = Prev->getPreviousDecl())
462 if (Prev == EUnderlying)
463 return true;
464 return false;
465}
466
467/// Determine whether \p D can hide a tag declaration.
468static bool canHideTag(const NamedDecl *D) {
469 // C++ [basic.scope.declarative]p4:
470 // Given a set of declarations in a single declarative region [...]
471 // exactly one declaration shall declare a class name or enumeration name
472 // that is not a typedef name and the other declarations shall all refer to
473 // the same variable, non-static data member, or enumerator, or all refer
474 // to functions and function templates; in this case the class name or
475 // enumeration name is hidden.
476 // C++ [basic.scope.hiding]p2:
477 // A class name or enumeration name can be hidden by the name of a
478 // variable, data member, function, or enumerator declared in the same
479 // scope.
480 // An UnresolvedUsingValueDecl always instantiates to one of these.
481 D = D->getUnderlyingDecl();
482 return isa<VarDecl>(Val: D) || isa<EnumConstantDecl>(Val: D) || isa<FunctionDecl>(Val: D) ||
483 isa<FunctionTemplateDecl>(Val: D) || isa<FieldDecl>(Val: D) ||
484 isa<UnresolvedUsingValueDecl>(Val: D);
485}
486
487/// Resolves the result kind of this lookup.
488void LookupResult::resolveKind() {
489 unsigned N = Decls.size();
490
491 // Fast case: no possible ambiguity.
492 if (N == 0) {
493 assert(ResultKind == LookupResultKind::NotFound ||
494 ResultKind == LookupResultKind::NotFoundInCurrentInstantiation);
495 return;
496 }
497
498 // If there's a single decl, we need to examine it to decide what
499 // kind of lookup this is.
500 if (N == 1) {
501 const NamedDecl *D = (*Decls.begin())->getUnderlyingDecl();
502 if (isa<FunctionTemplateDecl>(Val: D))
503 ResultKind = LookupResultKind::FoundOverloaded;
504 else if (isa<UnresolvedUsingValueDecl>(Val: D))
505 ResultKind = LookupResultKind::FoundUnresolvedValue;
506 return;
507 }
508
509 // Don't do any extra resolution if we've already resolved as ambiguous.
510 if (ResultKind == LookupResultKind::Ambiguous)
511 return;
512
513 llvm::SmallDenseMap<const NamedDecl *, unsigned, 16> Unique;
514 llvm::SmallDenseMap<QualType, unsigned, 16> UniqueTypes;
515
516 bool Ambiguous = false;
517 bool ReferenceToPlaceHolderVariable = false;
518 bool HasTag = false, HasFunction = false;
519 bool HasFunctionTemplate = false, HasUnresolved = false;
520 const NamedDecl *HasNonFunction = nullptr;
521
522 llvm::SmallVector<const NamedDecl *, 4> EquivalentNonFunctions;
523 llvm::BitVector RemovedDecls(N);
524
525 for (unsigned I = 0; I < N; I++) {
526 const NamedDecl *D = Decls[I]->getUnderlyingDecl();
527 D = cast<NamedDecl>(Val: D->getCanonicalDecl());
528
529 // Ignore an invalid declaration unless it's the only one left.
530 // Also ignore HLSLBufferDecl which not have name conflict with other Decls.
531 if ((D->isInvalidDecl() || isa<HLSLBufferDecl>(Val: D)) &&
532 N - RemovedDecls.count() > 1) {
533 RemovedDecls.set(I);
534 continue;
535 }
536
537 // C++ [basic.scope.hiding]p2:
538 // A class name or enumeration name can be hidden by the name of
539 // an object, function, or enumerator declared in the same
540 // scope. If a class or enumeration name and an object, function,
541 // or enumerator are declared in the same scope (in any order)
542 // with the same name, the class or enumeration name is hidden
543 // wherever the object, function, or enumerator name is visible.
544 if (HideTags && isa<TagDecl>(Val: D)) {
545 bool Hidden = false;
546 for (auto *OtherDecl : Decls) {
547 if (canHideTag(D: OtherDecl) && !OtherDecl->isInvalidDecl() &&
548 getContextForScopeMatching(D: OtherDecl)->Equals(
549 DC: getContextForScopeMatching(D: Decls[I]))) {
550 RemovedDecls.set(I);
551 Hidden = true;
552 break;
553 }
554 }
555 if (Hidden)
556 continue;
557 }
558
559 std::optional<unsigned> ExistingI;
560
561 // Redeclarations of types via typedef can occur both within a scope
562 // and, through using declarations and directives, across scopes. There is
563 // no ambiguity if they all refer to the same type, so unique based on the
564 // canonical type.
565 if (const auto *TD = dyn_cast<TypeDecl>(Val: D)) {
566 auto UniqueResult = UniqueTypes.insert(
567 KV: std::make_pair(x: getSema().Context.getCanonicalTypeDeclType(TD), y&: I));
568 if (!UniqueResult.second) {
569 // The type is not unique.
570 ExistingI = UniqueResult.first->second;
571 }
572 }
573
574 // For non-type declarations, check for a prior lookup result naming this
575 // canonical declaration.
576 if (!ExistingI) {
577 auto UniqueResult = Unique.insert(KV: std::make_pair(x&: D, y&: I));
578 if (!UniqueResult.second) {
579 // We've seen this entity before.
580 ExistingI = UniqueResult.first->second;
581 }
582 }
583
584 if (ExistingI) {
585 // This is not a unique lookup result. Pick one of the results and
586 // discard the other.
587 if (isPreferredLookupResult(S&: getSema(), Kind: getLookupKind(), D: Decls[I],
588 Existing: Decls[*ExistingI]))
589 Decls[*ExistingI] = Decls[I];
590 RemovedDecls.set(I);
591 continue;
592 }
593
594 // Otherwise, do some decl type analysis and then continue.
595
596 if (isa<UnresolvedUsingValueDecl>(Val: D)) {
597 HasUnresolved = true;
598 } else if (isa<TagDecl>(Val: D)) {
599 if (HasTag)
600 Ambiguous = true;
601 HasTag = true;
602 } else if (isa<FunctionTemplateDecl>(Val: D)) {
603 HasFunction = true;
604 HasFunctionTemplate = true;
605 } else if (isa<FunctionDecl>(Val: D)) {
606 HasFunction = true;
607 } else {
608 if (HasNonFunction) {
609 // If we're about to create an ambiguity between two declarations that
610 // are equivalent, but one is an internal linkage declaration from one
611 // module and the other is an internal linkage declaration from another
612 // module, just skip it.
613 if (getSema().isEquivalentInternalLinkageDeclaration(A: HasNonFunction,
614 B: D)) {
615 EquivalentNonFunctions.push_back(Elt: D);
616 RemovedDecls.set(I);
617 continue;
618 }
619 if (D->isPlaceholderVar(LangOpts: getSema().getLangOpts()) &&
620 getContextForScopeMatching(D) ==
621 getContextForScopeMatching(D: Decls[I])) {
622 ReferenceToPlaceHolderVariable = true;
623 }
624 Ambiguous = true;
625 }
626 HasNonFunction = D;
627 }
628 }
629
630 // FIXME: This diagnostic should really be delayed until we're done with
631 // the lookup result, in case the ambiguity is resolved by the caller.
632 if (!EquivalentNonFunctions.empty() && !Ambiguous)
633 getSema().diagnoseEquivalentInternalLinkageDeclarations(
634 Loc: getNameLoc(), D: HasNonFunction, Equiv: EquivalentNonFunctions);
635
636 // Remove decls by replacing them with decls from the end (which
637 // means that we need to iterate from the end) and then truncating
638 // to the new size.
639 for (int I = RemovedDecls.find_last(); I >= 0; I = RemovedDecls.find_prev(PriorTo: I))
640 Decls[I] = Decls[--N];
641 Decls.truncate(N);
642
643 if ((HasNonFunction && (HasFunction || HasUnresolved)) ||
644 (HideTags && HasTag && (HasFunction || HasNonFunction || HasUnresolved)))
645 Ambiguous = true;
646
647 if (Ambiguous && ReferenceToPlaceHolderVariable)
648 setAmbiguous(LookupAmbiguityKind::AmbiguousReferenceToPlaceholderVariable);
649 else if (Ambiguous)
650 setAmbiguous(LookupAmbiguityKind::AmbiguousReference);
651 else if (HasUnresolved)
652 ResultKind = LookupResultKind::FoundUnresolvedValue;
653 else if (N > 1 || HasFunctionTemplate)
654 ResultKind = LookupResultKind::FoundOverloaded;
655 else
656 ResultKind = LookupResultKind::Found;
657}
658
659void LookupResult::addDeclsFromBasePaths(const CXXBasePaths &P) {
660 CXXBasePaths::const_paths_iterator I, E;
661 for (I = P.begin(), E = P.end(); I != E; ++I)
662 for (DeclContext::lookup_iterator DI = I->Decls, DE = DI.end(); DI != DE;
663 ++DI)
664 addDecl(D: *DI);
665}
666
667void LookupResult::setAmbiguousBaseSubobjects(CXXBasePaths &P) {
668 Paths = new CXXBasePaths;
669 Paths->swap(Other&: P);
670 addDeclsFromBasePaths(P: *Paths);
671 resolveKind();
672 setAmbiguous(LookupAmbiguityKind::AmbiguousBaseSubobjects);
673}
674
675void LookupResult::setAmbiguousBaseSubobjectTypes(CXXBasePaths &P) {
676 Paths = new CXXBasePaths;
677 Paths->swap(Other&: P);
678 addDeclsFromBasePaths(P: *Paths);
679 resolveKind();
680 setAmbiguous(LookupAmbiguityKind::AmbiguousBaseSubobjectTypes);
681}
682
683void LookupResult::print(raw_ostream &Out) {
684 Out << Decls.size() << " result(s)";
685 if (isAmbiguous()) Out << ", ambiguous";
686 if (Paths) Out << ", base paths present";
687
688 for (iterator I = begin(), E = end(); I != E; ++I) {
689 Out << "\n";
690 (*I)->print(Out, Indentation: 2);
691 }
692}
693
694LLVM_DUMP_METHOD void LookupResult::dump() {
695 llvm::errs() << "lookup results for " << getLookupName().getAsString()
696 << ":\n";
697 for (NamedDecl *D : *this)
698 D->dump();
699}
700
701/// Diagnose a missing builtin type.
702static QualType diagOpenCLBuiltinTypeError(Sema &S, llvm::StringRef TypeClass,
703 llvm::StringRef Name) {
704 S.Diag(Loc: SourceLocation(), DiagID: diag::err_opencl_type_not_found)
705 << TypeClass << Name;
706 return S.Context.VoidTy;
707}
708
709/// Lookup an OpenCL enum type.
710static QualType getOpenCLEnumType(Sema &S, llvm::StringRef Name) {
711 LookupResult Result(S, &S.Context.Idents.get(Name), SourceLocation(),
712 Sema::LookupTagName);
713 S.LookupName(R&: Result, S: S.TUScope);
714 if (Result.empty())
715 return diagOpenCLBuiltinTypeError(S, TypeClass: "enum", Name);
716 EnumDecl *Decl = Result.getAsSingle<EnumDecl>();
717 if (!Decl)
718 return diagOpenCLBuiltinTypeError(S, TypeClass: "enum", Name);
719 return S.Context.getCanonicalTagType(TD: Decl);
720}
721
722/// Lookup an OpenCL typedef type.
723static QualType getOpenCLTypedefType(Sema &S, llvm::StringRef Name) {
724 LookupResult Result(S, &S.Context.Idents.get(Name), SourceLocation(),
725 Sema::LookupOrdinaryName);
726 S.LookupName(R&: Result, S: S.TUScope);
727 if (Result.empty())
728 return diagOpenCLBuiltinTypeError(S, TypeClass: "typedef", Name);
729 TypedefNameDecl *Decl = Result.getAsSingle<TypedefNameDecl>();
730 if (!Decl)
731 return diagOpenCLBuiltinTypeError(S, TypeClass: "typedef", Name);
732 return S.Context.getTypedefType(Keyword: ElaboratedTypeKeyword::None,
733 /*Qualifier=*/std::nullopt, Decl);
734}
735
736/// Get the QualType instances of the return type and arguments for an OpenCL
737/// builtin function signature.
738/// \param S (in) The Sema instance.
739/// \param OpenCLBuiltin (in) The signature currently handled.
740/// \param GenTypeMaxCnt (out) Maximum number of types contained in a generic
741/// type used as return type or as argument.
742/// Only meaningful for generic types, otherwise equals 1.
743/// \param RetTypes (out) List of the possible return types.
744/// \param ArgTypes (out) List of the possible argument types. For each
745/// argument, ArgTypes contains QualTypes for the Cartesian product
746/// of (vector sizes) x (types) .
747static void GetQualTypesForOpenCLBuiltin(
748 Sema &S, const OpenCLBuiltinStruct &OpenCLBuiltin, unsigned &GenTypeMaxCnt,
749 SmallVector<QualType, 1> &RetTypes,
750 SmallVector<SmallVector<QualType, 1>, 5> &ArgTypes) {
751 // Get the QualType instances of the return types.
752 unsigned Sig = SignatureTable[OpenCLBuiltin.SigTableIndex];
753 OCL2Qual(S, Ty: TypeTable[Sig], QT&: RetTypes);
754 GenTypeMaxCnt = RetTypes.size();
755
756 // Get the QualType instances of the arguments.
757 // First type is the return type, skip it.
758 for (unsigned Index = 1; Index < OpenCLBuiltin.NumTypes; Index++) {
759 SmallVector<QualType, 1> Ty;
760 OCL2Qual(S, Ty: TypeTable[SignatureTable[OpenCLBuiltin.SigTableIndex + Index]],
761 QT&: Ty);
762 GenTypeMaxCnt = (Ty.size() > GenTypeMaxCnt) ? Ty.size() : GenTypeMaxCnt;
763 ArgTypes.push_back(Elt: std::move(Ty));
764 }
765}
766
767/// Create a list of the candidate function overloads for an OpenCL builtin
768/// function.
769/// \param Context (in) The ASTContext instance.
770/// \param GenTypeMaxCnt (in) Maximum number of types contained in a generic
771/// type used as return type or as argument.
772/// Only meaningful for generic types, otherwise equals 1.
773/// \param FunctionList (out) List of FunctionTypes.
774/// \param RetTypes (in) List of the possible return types.
775/// \param ArgTypes (in) List of the possible types for the arguments.
776static void GetOpenCLBuiltinFctOverloads(
777 ASTContext &Context, unsigned GenTypeMaxCnt,
778 std::vector<QualType> &FunctionList, SmallVector<QualType, 1> &RetTypes,
779 SmallVector<SmallVector<QualType, 1>, 5> &ArgTypes) {
780 FunctionProtoType::ExtProtoInfo PI(
781 Context.getTargetInfo().getDefaultCallingConv());
782 PI.Variadic = false;
783
784 // Do not attempt to create any FunctionTypes if there are no return types,
785 // which happens when a type belongs to a disabled extension.
786 if (RetTypes.size() == 0)
787 return;
788
789 // Create FunctionTypes for each (gen)type.
790 for (unsigned IGenType = 0; IGenType < GenTypeMaxCnt; IGenType++) {
791 SmallVector<QualType, 5> ArgList;
792
793 for (unsigned A = 0; A < ArgTypes.size(); A++) {
794 // Bail out if there is an argument that has no available types.
795 if (ArgTypes[A].size() == 0)
796 return;
797
798 // Builtins such as "max" have an "sgentype" argument that represents
799 // the corresponding scalar type of a gentype. The number of gentypes
800 // must be a multiple of the number of sgentypes.
801 assert(GenTypeMaxCnt % ArgTypes[A].size() == 0 &&
802 "argument type count not compatible with gentype type count");
803 unsigned Idx = IGenType % ArgTypes[A].size();
804 ArgList.push_back(Elt: ArgTypes[A][Idx]);
805 }
806
807 FunctionList.push_back(x: Context.getFunctionType(
808 ResultTy: RetTypes[(RetTypes.size() != 1) ? IGenType : 0], Args: ArgList, EPI: PI));
809 }
810}
811
812/// When trying to resolve a function name, if isOpenCLBuiltin() returns a
813/// non-null <Index, Len> pair, then the name is referencing an OpenCL
814/// builtin function. Add all candidate signatures to the LookUpResult.
815///
816/// \param S (in) The Sema instance.
817/// \param LR (inout) The LookupResult instance.
818/// \param II (in) The identifier being resolved.
819/// \param FctIndex (in) Starting index in the BuiltinTable.
820/// \param Len (in) The signature list has Len elements.
821static void InsertOCLBuiltinDeclarationsFromTable(Sema &S, LookupResult &LR,
822 IdentifierInfo *II,
823 const unsigned FctIndex,
824 const unsigned Len) {
825 // The builtin function declaration uses generic types (gentype).
826 bool HasGenType = false;
827
828 // Maximum number of types contained in a generic type used as return type or
829 // as argument. Only meaningful for generic types, otherwise equals 1.
830 unsigned GenTypeMaxCnt;
831
832 ASTContext &Context = S.Context;
833
834 for (unsigned SignatureIndex = 0; SignatureIndex < Len; SignatureIndex++) {
835 const OpenCLBuiltinStruct &OpenCLBuiltin =
836 BuiltinTable[FctIndex + SignatureIndex];
837
838 // Ignore this builtin function if it is not available in the currently
839 // selected language version.
840 if (!isOpenCLVersionContainedInMask(LO: Context.getLangOpts(),
841 Mask: OpenCLBuiltin.Versions))
842 continue;
843
844 // Ignore this builtin function if it carries an extension macro that is
845 // not defined. This indicates that the extension is not supported by the
846 // target, so the builtin function should not be available.
847 StringRef Extensions = FunctionExtensionTable[OpenCLBuiltin.Extension];
848 if (!Extensions.empty()) {
849 SmallVector<StringRef, 2> ExtVec;
850 Extensions.split(A&: ExtVec, Separator: " ");
851 bool AllExtensionsDefined = true;
852 for (StringRef Ext : ExtVec) {
853 if (!S.getPreprocessor().isMacroDefined(Id: Ext)) {
854 AllExtensionsDefined = false;
855 break;
856 }
857 }
858 if (!AllExtensionsDefined)
859 continue;
860 }
861
862 SmallVector<QualType, 1> RetTypes;
863 SmallVector<SmallVector<QualType, 1>, 5> ArgTypes;
864
865 // Obtain QualType lists for the function signature.
866 GetQualTypesForOpenCLBuiltin(S, OpenCLBuiltin, GenTypeMaxCnt, RetTypes,
867 ArgTypes);
868 if (GenTypeMaxCnt > 1) {
869 HasGenType = true;
870 }
871
872 // Create function overload for each type combination.
873 std::vector<QualType> FunctionList;
874 GetOpenCLBuiltinFctOverloads(Context, GenTypeMaxCnt, FunctionList, RetTypes,
875 ArgTypes);
876
877 SourceLocation Loc = LR.getNameLoc();
878 DeclContext *Parent = Context.getTranslationUnitDecl();
879 FunctionDecl *NewOpenCLBuiltin;
880
881 for (const auto &FTy : FunctionList) {
882 NewOpenCLBuiltin = FunctionDecl::Create(
883 C&: Context, DC: Parent, StartLoc: Loc, NLoc: Loc, N: II, T: FTy, /*TInfo=*/nullptr, SC: SC_Extern,
884 UsesFPIntrin: S.getCurFPFeatures().isFPConstrained(), isInlineSpecified: false,
885 hasWrittenPrototype: FTy->isFunctionProtoType());
886 NewOpenCLBuiltin->setImplicit();
887
888 // Create Decl objects for each parameter, adding them to the
889 // FunctionDecl.
890 const auto *FP = cast<FunctionProtoType>(Val: FTy);
891 SmallVector<ParmVarDecl *, 4> ParmList;
892 for (unsigned IParm = 0, e = FP->getNumParams(); IParm != e; ++IParm) {
893 ParmVarDecl *Parm = ParmVarDecl::Create(
894 C&: Context, DC: NewOpenCLBuiltin, StartLoc: SourceLocation(), IdLoc: SourceLocation(),
895 Id: nullptr, T: FP->getParamType(i: IParm), TInfo: nullptr, S: SC_None, DefArg: nullptr);
896 Parm->setScopeInfo(scopeDepth: 0, parameterIndex: IParm);
897 ParmList.push_back(Elt: Parm);
898 }
899 NewOpenCLBuiltin->setParams(ParmList);
900
901 // Add function attributes.
902 if (OpenCLBuiltin.IsPure)
903 NewOpenCLBuiltin->addAttr(A: PureAttr::CreateImplicit(Ctx&: Context));
904 if (OpenCLBuiltin.IsConst)
905 NewOpenCLBuiltin->addAttr(A: ConstAttr::CreateImplicit(Ctx&: Context));
906 if (OpenCLBuiltin.IsConv)
907 NewOpenCLBuiltin->addAttr(A: ConvergentAttr::CreateImplicit(Ctx&: Context));
908
909 if (!S.getLangOpts().OpenCLCPlusPlus)
910 NewOpenCLBuiltin->addAttr(A: OverloadableAttr::CreateImplicit(Ctx&: Context));
911
912 LR.addDecl(D: NewOpenCLBuiltin);
913 }
914 }
915
916 // If we added overloads, need to resolve the lookup result.
917 if (Len > 1 || HasGenType)
918 LR.resolveKind();
919}
920
921bool Sema::LookupBuiltin(LookupResult &R) {
922 Sema::LookupNameKind NameKind = R.getLookupKind();
923
924 // If we didn't find a use of this identifier, and if the identifier
925 // corresponds to a compiler builtin, create the decl object for the builtin
926 // now, injecting it into translation unit scope, and return it.
927 if (NameKind == Sema::LookupOrdinaryName ||
928 NameKind == Sema::LookupRedeclarationWithLinkage) {
929 IdentifierInfo *II = R.getLookupName().getAsIdentifierInfo();
930 if (II) {
931 if (NameKind == Sema::LookupOrdinaryName) {
932 if (getLangOpts().CPlusPlus) {
933#define BuiltinTemplate(BIName)
934#define CPlusPlusBuiltinTemplate(BIName) \
935 if (II == getASTContext().get##BIName##Name()) { \
936 R.addDecl(getASTContext().get##BIName##Decl()); \
937 return true; \
938 }
939#include "clang/Basic/BuiltinTemplates.inc"
940 }
941 if (getLangOpts().HLSL) {
942#define BuiltinTemplate(BIName)
943#define HLSLBuiltinTemplate(BIName) \
944 if (II == getASTContext().get##BIName##Name()) { \
945 R.addDecl(getASTContext().get##BIName##Decl()); \
946 return true; \
947 }
948#include "clang/Basic/BuiltinTemplates.inc"
949 }
950 }
951
952 // Check if this is an OpenCL Builtin, and if so, insert its overloads.
953 if (getLangOpts().OpenCL && getLangOpts().DeclareOpenCLBuiltins) {
954 auto Index = isOpenCLBuiltin(Name: II->getName());
955 if (Index.first) {
956 InsertOCLBuiltinDeclarationsFromTable(S&: *this, LR&: R, II, FctIndex: Index.first - 1,
957 Len: Index.second);
958 return true;
959 }
960 }
961
962 if (RISCV().DeclareRVVBuiltins || RISCV().DeclareSiFiveVectorBuiltins ||
963 RISCV().DeclareAndesVectorBuiltins) {
964 if (!RISCV().IntrinsicManager)
965 RISCV().IntrinsicManager = CreateRISCVIntrinsicManager(S&: *this);
966
967 RISCV().IntrinsicManager->InitIntrinsicList();
968
969 if (RISCV().IntrinsicManager->CreateIntrinsicIfFound(LR&: R, II, PP))
970 return true;
971 }
972
973 // If this is a builtin on this (or all) targets, create the decl.
974 if (unsigned BuiltinID = II->getBuiltinID()) {
975 // In C++ and OpenCL (spec v1.2 s6.9.f), we don't have any predefined
976 // library functions like 'malloc'. Instead, we'll just error.
977 if ((getLangOpts().CPlusPlus || getLangOpts().OpenCL) &&
978 Context.BuiltinInfo.isPredefinedLibFunction(ID: BuiltinID))
979 return false;
980
981 if (NamedDecl *D =
982 LazilyCreateBuiltin(II, ID: BuiltinID, S: TUScope,
983 ForRedeclaration: R.isForRedeclaration(), Loc: R.getNameLoc())) {
984 R.addDecl(D);
985 return true;
986 }
987 }
988 }
989 }
990
991 return false;
992}
993
994/// Looks up the declaration of "struct objc_super" and
995/// saves it for later use in building builtin declaration of
996/// objc_msgSendSuper and objc_msgSendSuper_stret.
997static void LookupPredefedObjCSuperType(Sema &Sema, Scope *S) {
998 ASTContext &Context = Sema.Context;
999 LookupResult Result(Sema, &Context.Idents.get(Name: "objc_super"), SourceLocation(),
1000 Sema::LookupTagName);
1001 Sema.LookupName(R&: Result, S);
1002 if (Result.getResultKind() == LookupResultKind::Found)
1003 if (const TagDecl *TD = Result.getAsSingle<TagDecl>())
1004 Context.setObjCSuperType(Context.getCanonicalTagType(TD));
1005}
1006
1007void Sema::LookupNecessaryTypesForBuiltin(Scope *S, unsigned ID) {
1008 if (ID == Builtin::BIobjc_msgSendSuper)
1009 LookupPredefedObjCSuperType(Sema&: *this, S);
1010}
1011
1012/// Determine whether we can declare a special member function within
1013/// the class at this point.
1014static bool CanDeclareSpecialMemberFunction(const CXXRecordDecl *Class) {
1015 // We need to have a definition for the class.
1016 if (!Class->getDefinition() || Class->isDependentContext())
1017 return false;
1018
1019 // We can't be in the middle of defining the class.
1020 return !Class->isBeingDefined();
1021}
1022
1023void Sema::ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class) {
1024 if (!CanDeclareSpecialMemberFunction(Class))
1025 return;
1026
1027 // If the default constructor has not yet been declared, do so now.
1028 if (Class->needsImplicitDefaultConstructor())
1029 DeclareImplicitDefaultConstructor(ClassDecl: Class);
1030
1031 // If the copy constructor has not yet been declared, do so now.
1032 if (Class->needsImplicitCopyConstructor())
1033 DeclareImplicitCopyConstructor(ClassDecl: Class);
1034
1035 // If the copy assignment operator has not yet been declared, do so now.
1036 if (Class->needsImplicitCopyAssignment())
1037 DeclareImplicitCopyAssignment(ClassDecl: Class);
1038
1039 if (getLangOpts().CPlusPlus11) {
1040 // If the move constructor has not yet been declared, do so now.
1041 if (Class->needsImplicitMoveConstructor())
1042 DeclareImplicitMoveConstructor(ClassDecl: Class);
1043
1044 // If the move assignment operator has not yet been declared, do so now.
1045 if (Class->needsImplicitMoveAssignment())
1046 DeclareImplicitMoveAssignment(ClassDecl: Class);
1047 }
1048
1049 // If the destructor has not yet been declared, do so now.
1050 if (Class->needsImplicitDestructor())
1051 DeclareImplicitDestructor(ClassDecl: Class);
1052}
1053
1054/// Determine whether this is the name of an implicitly-declared
1055/// special member function.
1056static bool isImplicitlyDeclaredMemberFunctionName(DeclarationName Name) {
1057 switch (Name.getNameKind()) {
1058 case DeclarationName::CXXConstructorName:
1059 case DeclarationName::CXXDestructorName:
1060 return true;
1061
1062 case DeclarationName::CXXOperatorName:
1063 return Name.getCXXOverloadedOperator() == OO_Equal;
1064
1065 default:
1066 break;
1067 }
1068
1069 return false;
1070}
1071
1072/// If there are any implicit member functions with the given name
1073/// that need to be declared in the given declaration context, do so.
1074static void DeclareImplicitMemberFunctionsWithName(Sema &S,
1075 DeclarationName Name,
1076 SourceLocation Loc,
1077 const DeclContext *DC) {
1078 if (!DC)
1079 return;
1080
1081 switch (Name.getNameKind()) {
1082 case DeclarationName::CXXConstructorName:
1083 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Val: DC))
1084 if (Record->getDefinition() && CanDeclareSpecialMemberFunction(Class: Record)) {
1085 CXXRecordDecl *Class = const_cast<CXXRecordDecl *>(Record);
1086 if (Record->needsImplicitDefaultConstructor())
1087 S.DeclareImplicitDefaultConstructor(ClassDecl: Class);
1088 if (Record->needsImplicitCopyConstructor())
1089 S.DeclareImplicitCopyConstructor(ClassDecl: Class);
1090 if (S.getLangOpts().CPlusPlus11 &&
1091 Record->needsImplicitMoveConstructor())
1092 S.DeclareImplicitMoveConstructor(ClassDecl: Class);
1093 }
1094 break;
1095
1096 case DeclarationName::CXXDestructorName:
1097 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Val: DC))
1098 if (Record->getDefinition() && Record->needsImplicitDestructor() &&
1099 CanDeclareSpecialMemberFunction(Class: Record))
1100 S.DeclareImplicitDestructor(ClassDecl: const_cast<CXXRecordDecl *>(Record));
1101 break;
1102
1103 case DeclarationName::CXXOperatorName:
1104 if (Name.getCXXOverloadedOperator() != OO_Equal)
1105 break;
1106
1107 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Val: DC)) {
1108 if (Record->getDefinition() && CanDeclareSpecialMemberFunction(Class: Record)) {
1109 CXXRecordDecl *Class = const_cast<CXXRecordDecl *>(Record);
1110 if (Record->needsImplicitCopyAssignment())
1111 S.DeclareImplicitCopyAssignment(ClassDecl: Class);
1112 if (S.getLangOpts().CPlusPlus11 &&
1113 Record->needsImplicitMoveAssignment())
1114 S.DeclareImplicitMoveAssignment(ClassDecl: Class);
1115 }
1116 }
1117 break;
1118
1119 case DeclarationName::CXXDeductionGuideName:
1120 S.DeclareImplicitDeductionGuides(Template: Name.getCXXDeductionGuideTemplate(), Loc);
1121 break;
1122
1123 default:
1124 break;
1125 }
1126}
1127
1128// Adds all qualifying matches for a name within a decl context to the
1129// given lookup result. Returns true if any matches were found.
1130static bool LookupDirect(Sema &S, LookupResult &R, const DeclContext *DC) {
1131 bool Found = false;
1132
1133 // Lazily declare C++ special member functions.
1134 if (S.getLangOpts().CPlusPlus)
1135 DeclareImplicitMemberFunctionsWithName(S, Name: R.getLookupName(), Loc: R.getNameLoc(),
1136 DC);
1137
1138 // Perform lookup into this declaration context.
1139 DeclContext::lookup_result DR = DC->lookup(Name: R.getLookupName());
1140 for (NamedDecl *D : DR) {
1141 if ((D = R.getAcceptableDecl(D))) {
1142 R.addDecl(D);
1143 Found = true;
1144 }
1145 }
1146
1147 if (!Found && DC->isTranslationUnit() && S.LookupBuiltin(R))
1148 return true;
1149
1150 if (R.getLookupName().getNameKind()
1151 != DeclarationName::CXXConversionFunctionName ||
1152 R.getLookupName().getCXXNameType()->isDependentType() ||
1153 !isa<CXXRecordDecl>(Val: DC))
1154 return Found;
1155
1156 // C++ [temp.mem]p6:
1157 // A specialization of a conversion function template is not found by
1158 // name lookup. Instead, any conversion function templates visible in the
1159 // context of the use are considered. [...]
1160 const CXXRecordDecl *Record = cast<CXXRecordDecl>(Val: DC);
1161 if (!Record->isCompleteDefinition() && !R.isForRedeclaration())
1162 return Found;
1163
1164 // For conversion operators, 'operator auto' should only match
1165 // 'operator auto'. Since 'auto' is not a type, it shouldn't be considered
1166 // as a candidate for template substitution.
1167 auto *ContainedDeducedType =
1168 R.getLookupName().getCXXNameType()->getContainedDeducedType();
1169 if (R.getLookupName().getNameKind() ==
1170 DeclarationName::CXXConversionFunctionName &&
1171 ContainedDeducedType && ContainedDeducedType->isUndeducedType())
1172 return Found;
1173
1174 for (CXXRecordDecl::conversion_iterator U = Record->conversion_begin(),
1175 UEnd = Record->conversion_end(); U != UEnd; ++U) {
1176 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(Val: *U);
1177 if (!ConvTemplate)
1178 continue;
1179
1180 // When we're performing lookup for the purposes of redeclaration, just
1181 // add the conversion function template. When we deduce template
1182 // arguments for specializations, we'll end up unifying the return
1183 // type of the new declaration with the type of the function template.
1184 if (R.isForRedeclaration()) {
1185 R.addDecl(D: ConvTemplate);
1186 Found = true;
1187 continue;
1188 }
1189
1190 // C++ [temp.mem]p6:
1191 // [...] For each such operator, if argument deduction succeeds
1192 // (14.9.2.3), the resulting specialization is used as if found by
1193 // name lookup.
1194 //
1195 // When referencing a conversion function for any purpose other than
1196 // a redeclaration (such that we'll be building an expression with the
1197 // result), perform template argument deduction and place the
1198 // specialization into the result set. We do this to avoid forcing all
1199 // callers to perform special deduction for conversion functions.
1200 TemplateDeductionInfo Info(R.getNameLoc());
1201 FunctionDecl *Specialization = nullptr;
1202
1203 const FunctionProtoType *ConvProto
1204 = ConvTemplate->getTemplatedDecl()->getType()->getAs<FunctionProtoType>();
1205 assert(ConvProto && "Nonsensical conversion function template type");
1206
1207 // Compute the type of the function that we would expect the conversion
1208 // function to have, if it were to match the name given.
1209 // FIXME: Calling convention!
1210 FunctionProtoType::ExtProtoInfo EPI = ConvProto->getExtProtoInfo();
1211 EPI.ExtInfo = EPI.ExtInfo.withCallingConv(cc: CC_C);
1212 EPI.ExceptionSpec = EST_None;
1213 QualType ExpectedType = R.getSema().Context.getFunctionType(
1214 ResultTy: R.getLookupName().getCXXNameType(), Args: {}, EPI);
1215
1216 // Perform template argument deduction against the type that we would
1217 // expect the function to have.
1218 if (R.getSema().DeduceTemplateArguments(FunctionTemplate: ConvTemplate, ExplicitTemplateArgs: nullptr, ArgFunctionType: ExpectedType,
1219 Specialization, Info) ==
1220 TemplateDeductionResult::Success) {
1221 R.addDecl(D: Specialization);
1222 Found = true;
1223 }
1224 }
1225
1226 return Found;
1227}
1228
1229// Performs C++ unqualified lookup into the given file context.
1230static bool CppNamespaceLookup(Sema &S, LookupResult &R, ASTContext &Context,
1231 const DeclContext *NS,
1232 UnqualUsingDirectiveSet &UDirs) {
1233
1234 assert(NS && NS->isFileContext() && "CppNamespaceLookup() requires namespace!");
1235
1236 // Perform direct name lookup into the LookupCtx.
1237 bool Found = LookupDirect(S, R, DC: NS);
1238
1239 // Perform direct name lookup into the namespaces nominated by the
1240 // using directives whose common ancestor is this namespace.
1241 for (const UnqualUsingEntry &UUE : UDirs.getNamespacesFor(DC: NS))
1242 if (LookupDirect(S, R, DC: UUE.getNominatedNamespace()))
1243 Found = true;
1244
1245 R.resolveKind();
1246
1247 return Found;
1248}
1249
1250static bool isNamespaceOrTranslationUnitScope(Scope *S) {
1251 if (DeclContext *Ctx = S->getEntity())
1252 return Ctx->isFileContext();
1253 return false;
1254}
1255
1256/// Find the outer declaration context from this scope. This indicates the
1257/// context that we should search up to (exclusive) before considering the
1258/// parent of the specified scope.
1259static DeclContext *findOuterContext(Scope *S) {
1260 for (Scope *OuterS = S->getParent(); OuterS; OuterS = OuterS->getParent())
1261 if (DeclContext *DC = OuterS->getLookupEntity())
1262 return DC;
1263 return nullptr;
1264}
1265
1266namespace {
1267/// An RAII object to specify that we want to find block scope extern
1268/// declarations.
1269struct FindLocalExternScope {
1270 FindLocalExternScope(LookupResult &R)
1271 : R(R), OldFindLocalExtern(R.getIdentifierNamespace() &
1272 Decl::IDNS_LocalExtern) {
1273 R.setFindLocalExtern(R.getIdentifierNamespace() &
1274 (Decl::IDNS_Ordinary | Decl::IDNS_NonMemberOperator));
1275 }
1276 void restore() {
1277 R.setFindLocalExtern(OldFindLocalExtern);
1278 }
1279 ~FindLocalExternScope() {
1280 restore();
1281 }
1282 LookupResult &R;
1283 bool OldFindLocalExtern;
1284};
1285} // end anonymous namespace
1286
1287bool Sema::CppLookupName(LookupResult &R, Scope *S) {
1288 assert(getLangOpts().CPlusPlus && "Can perform only C++ lookup");
1289
1290 DeclarationName Name = R.getLookupName();
1291 Sema::LookupNameKind NameKind = R.getLookupKind();
1292
1293 // If this is the name of an implicitly-declared special member function,
1294 // go through the scope stack to implicitly declare
1295 if (isImplicitlyDeclaredMemberFunctionName(Name)) {
1296 for (Scope *PreS = S; PreS; PreS = PreS->getParent())
1297 if (DeclContext *DC = PreS->getEntity())
1298 DeclareImplicitMemberFunctionsWithName(S&: *this, Name, Loc: R.getNameLoc(), DC);
1299 }
1300
1301 // C++23 [temp.dep.general]p2:
1302 // The component name of an unqualified-id is dependent if
1303 // - it is a conversion-function-id whose conversion-type-id
1304 // is dependent, or
1305 // - it is operator= and the current class is a templated entity, or
1306 // - the unqualified-id is the postfix-expression in a dependent call.
1307 if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName &&
1308 Name.getCXXNameType()->isDependentType()) {
1309 R.setNotFoundInCurrentInstantiation();
1310 return false;
1311 }
1312
1313 // Implicitly declare member functions with the name we're looking for, if in
1314 // fact we are in a scope where it matters.
1315
1316 Scope *Initial = S;
1317 IdentifierResolver::iterator
1318 I = IdResolver.begin(Name),
1319 IEnd = IdResolver.end();
1320
1321 // First we lookup local scope.
1322 // We don't consider using-directives, as per 7.3.4.p1 [namespace.udir]
1323 // ...During unqualified name lookup (3.4.1), the names appear as if
1324 // they were declared in the nearest enclosing namespace which contains
1325 // both the using-directive and the nominated namespace.
1326 // [Note: in this context, "contains" means "contains directly or
1327 // indirectly".
1328 //
1329 // For example:
1330 // namespace A { int i; }
1331 // void foo() {
1332 // int i;
1333 // {
1334 // using namespace A;
1335 // ++i; // finds local 'i', A::i appears at global scope
1336 // }
1337 // }
1338 //
1339 UnqualUsingDirectiveSet UDirs(*this);
1340 bool VisitedUsingDirectives = false;
1341 bool LeftStartingScope = false;
1342
1343 // When performing a scope lookup, we want to find local extern decls.
1344 FindLocalExternScope FindLocals(R);
1345
1346 for (; S && !isNamespaceOrTranslationUnitScope(S); S = S->getParent()) {
1347 bool SearchNamespaceScope = true;
1348 // Check whether the IdResolver has anything in this scope.
1349 for (; I != IEnd && S->isDeclScope(D: *I); ++I) {
1350 if (NamedDecl *ND = R.getAcceptableDecl(D: *I)) {
1351 if (NameKind == LookupRedeclarationWithLinkage &&
1352 !(*I)->isTemplateParameter()) {
1353 // If it's a template parameter, we still find it, so we can diagnose
1354 // the invalid redeclaration.
1355
1356 // Determine whether this (or a previous) declaration is
1357 // out-of-scope.
1358 if (!LeftStartingScope && !Initial->isDeclScope(D: *I))
1359 LeftStartingScope = true;
1360
1361 // If we found something outside of our starting scope that
1362 // does not have linkage, skip it.
1363 if (LeftStartingScope && !((*I)->hasLinkage())) {
1364 R.setShadowed();
1365 continue;
1366 }
1367 } else {
1368 // We found something in this scope, we should not look at the
1369 // namespace scope
1370 SearchNamespaceScope = false;
1371 }
1372 R.addDecl(D: ND);
1373 }
1374 }
1375 if (!SearchNamespaceScope) {
1376 R.resolveKind();
1377 if (S->isClassScope())
1378 if (auto *Record = dyn_cast_if_present<CXXRecordDecl>(Val: S->getEntity()))
1379 R.setNamingClass(Record);
1380 return true;
1381 }
1382
1383 if (NameKind == LookupLocalFriendName && !S->isClassScope()) {
1384 // C++11 [class.friend]p11:
1385 // If a friend declaration appears in a local class and the name
1386 // specified is an unqualified name, a prior declaration is
1387 // looked up without considering scopes that are outside the
1388 // innermost enclosing non-class scope.
1389 return false;
1390 }
1391
1392 if (DeclContext *Ctx = S->getLookupEntity()) {
1393 DeclContext *OuterCtx = findOuterContext(S);
1394 for (; Ctx && !Ctx->Equals(DC: OuterCtx); Ctx = Ctx->getLookupParent()) {
1395 // We do not directly look into transparent contexts, since
1396 // those entities will be found in the nearest enclosing
1397 // non-transparent context.
1398 if (Ctx->isTransparentContext())
1399 continue;
1400
1401 // We do not look directly into function or method contexts,
1402 // since all of the local variables and parameters of the
1403 // function/method are present within the Scope.
1404 if (Ctx->isFunctionOrMethod()) {
1405 // If we have an Objective-C instance method, look for ivars
1406 // in the corresponding interface.
1407 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(Val: Ctx)) {
1408 if (Method->isInstanceMethod() && Name.getAsIdentifierInfo())
1409 if (ObjCInterfaceDecl *Class = Method->getClassInterface()) {
1410 ObjCInterfaceDecl *ClassDeclared;
1411 if (ObjCIvarDecl *Ivar = Class->lookupInstanceVariable(
1412 IVarName: Name.getAsIdentifierInfo(),
1413 ClassDeclared)) {
1414 if (NamedDecl *ND = R.getAcceptableDecl(D: Ivar)) {
1415 R.addDecl(D: ND);
1416 R.resolveKind();
1417 return true;
1418 }
1419 }
1420 }
1421 }
1422
1423 continue;
1424 }
1425
1426 // If this is a file context, we need to perform unqualified name
1427 // lookup considering using directives.
1428 if (Ctx->isFileContext()) {
1429 // If we haven't handled using directives yet, do so now.
1430 if (!VisitedUsingDirectives) {
1431 // Add using directives from this context up to the top level.
1432 for (DeclContext *UCtx = Ctx; UCtx; UCtx = UCtx->getParent()) {
1433 if (UCtx->isTransparentContext())
1434 continue;
1435
1436 UDirs.visit(DC: UCtx, EffectiveDC: UCtx);
1437 }
1438
1439 // Find the innermost file scope, so we can add using directives
1440 // from local scopes.
1441 Scope *InnermostFileScope = S;
1442 while (InnermostFileScope &&
1443 !isNamespaceOrTranslationUnitScope(S: InnermostFileScope))
1444 InnermostFileScope = InnermostFileScope->getParent();
1445 UDirs.visitScopeChain(S: Initial, InnermostFileScope);
1446
1447 UDirs.done();
1448
1449 VisitedUsingDirectives = true;
1450 }
1451
1452 if (CppNamespaceLookup(S&: *this, R, Context, NS: Ctx, UDirs)) {
1453 R.resolveKind();
1454 return true;
1455 }
1456
1457 continue;
1458 }
1459
1460 // Perform qualified name lookup into this context.
1461 // FIXME: In some cases, we know that every name that could be found by
1462 // this qualified name lookup will also be on the identifier chain. For
1463 // example, inside a class without any base classes, we never need to
1464 // perform qualified lookup because all of the members are on top of the
1465 // identifier chain.
1466 if (LookupQualifiedName(R, LookupCtx: Ctx, /*InUnqualifiedLookup=*/true))
1467 return true;
1468 }
1469 }
1470 }
1471
1472 // Stop if we ran out of scopes.
1473 // FIXME: This really, really shouldn't be happening.
1474 if (!S) return false;
1475
1476 // If we are looking for members, no need to look into global/namespace scope.
1477 if (NameKind == LookupMemberName)
1478 return false;
1479
1480 // Collect UsingDirectiveDecls in all scopes, and recursively all
1481 // nominated namespaces by those using-directives.
1482 //
1483 // FIXME: Cache this sorted list in Scope structure, and DeclContext, so we
1484 // don't build it for each lookup!
1485 if (!VisitedUsingDirectives) {
1486 UDirs.visitScopeChain(S: Initial, InnermostFileScope: S);
1487 UDirs.done();
1488 }
1489
1490 // If we're not performing redeclaration lookup, do not look for local
1491 // extern declarations outside of a function scope.
1492 if (!R.isForRedeclaration())
1493 FindLocals.restore();
1494
1495 // Lookup namespace scope, and global scope.
1496 // Unqualified name lookup in C++ requires looking into scopes
1497 // that aren't strictly lexical, and therefore we walk through the
1498 // context as well as walking through the scopes.
1499 for (; S; S = S->getParent()) {
1500 // Check whether the IdResolver has anything in this scope.
1501 bool Found = false;
1502 for (; I != IEnd && S->isDeclScope(D: *I); ++I) {
1503 if (NamedDecl *ND = R.getAcceptableDecl(D: *I)) {
1504 // We found something. Look for anything else in our scope
1505 // with this same name and in an acceptable identifier
1506 // namespace, so that we can construct an overload set if we
1507 // need to.
1508 Found = true;
1509 R.addDecl(D: ND);
1510 }
1511 }
1512
1513 if (Found && S->isTemplateParamScope()) {
1514 R.resolveKind();
1515 return true;
1516 }
1517
1518 DeclContext *Ctx = S->getLookupEntity();
1519 if (Ctx) {
1520 DeclContext *OuterCtx = findOuterContext(S);
1521 for (; Ctx && !Ctx->Equals(DC: OuterCtx); Ctx = Ctx->getLookupParent()) {
1522 // We do not directly look into transparent contexts, since
1523 // those entities will be found in the nearest enclosing
1524 // non-transparent context.
1525 if (Ctx->isTransparentContext())
1526 continue;
1527
1528 // If we have a context, and it's not a context stashed in the
1529 // template parameter scope for an out-of-line definition, also
1530 // look into that context.
1531 if (!(Found && S->isTemplateParamScope())) {
1532 assert(Ctx->isFileContext() &&
1533 "We should have been looking only at file context here already.");
1534
1535 // Look into context considering using-directives.
1536 if (CppNamespaceLookup(S&: *this, R, Context, NS: Ctx, UDirs))
1537 Found = true;
1538 }
1539
1540 if (Found) {
1541 R.resolveKind();
1542 return true;
1543 }
1544
1545 if (R.isForRedeclaration() && !Ctx->isTransparentContext())
1546 return false;
1547 }
1548 }
1549
1550 if (R.isForRedeclaration() && Ctx && !Ctx->isTransparentContext())
1551 return false;
1552 }
1553
1554 return !R.empty();
1555}
1556
1557void Sema::makeMergedDefinitionVisible(NamedDecl *ND) {
1558 if (auto *M = getCurrentModule())
1559 Context.mergeDefinitionIntoModule(ND, M);
1560 else
1561 // We're not building a module; just make the definition visible.
1562 ND->setVisibleDespiteOwningModule();
1563
1564 // If ND is a template declaration, make the template parameters
1565 // visible too. They're not (necessarily) within a mergeable DeclContext.
1566 if (auto *TD = dyn_cast<TemplateDecl>(Val: ND))
1567 for (auto *Param : *TD->getTemplateParameters())
1568 makeMergedDefinitionVisible(ND: Param);
1569
1570 // If we import a named module which contains a header, and then we include a
1571 // header which contains a definition of enums, we will skip parsing the enums
1572 // in the current TU. But we need to ensure the visibility of the enum
1573 // contants, since they are able to be found with the parents of their
1574 // parents.
1575 if (auto *ED = dyn_cast<EnumDecl>(Val: ND);
1576 ED && ED->isFromGlobalModule() && !ED->isScoped()) {
1577 for (auto *ECD : ED->enumerators()) {
1578 ECD->setVisiblePromoted();
1579 DeclContext *RedeclCtx = ED->getDeclContext()->getRedeclContext();
1580 if (RedeclCtx->lookup(Name: ECD->getDeclName()).empty())
1581 RedeclCtx->makeDeclVisibleInContext(D: ECD);
1582 }
1583 }
1584}
1585
1586/// Find the module in which the given declaration was defined.
1587static Module *getDefiningModule(Sema &S, Decl *Entity) {
1588 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Val: Entity)) {
1589 // If this function was instantiated from a template, the defining module is
1590 // the module containing the pattern.
1591 if (FunctionDecl *Pattern = FD->getTemplateInstantiationPattern())
1592 Entity = Pattern->getDefinition();
1593 } else if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Val: Entity)) {
1594 if (CXXRecordDecl *Pattern = RD->getTemplateInstantiationPattern())
1595 Entity = Pattern->getDefinition();
1596 } else if (EnumDecl *ED = dyn_cast<EnumDecl>(Val: Entity)) {
1597 if (auto *Pattern = ED->getTemplateInstantiationPattern())
1598 Entity = Pattern->getDefinition();
1599 } else if (VarDecl *VD = dyn_cast<VarDecl>(Val: Entity)) {
1600 if (VarDecl *Pattern = VD->getTemplateInstantiationPattern())
1601 Entity = Pattern->getDefinition();
1602 }
1603 if (!Entity)
1604 return nullptr;
1605
1606 // Walk up to the containing context. That might also have been instantiated
1607 // from a template.
1608 DeclContext *Context = Entity->getLexicalDeclContext();
1609 if (Context->isFileContext())
1610 return S.getOwningModule(Entity);
1611 return getDefiningModule(S, Entity: cast<Decl>(Val: Context));
1612}
1613
1614llvm::DenseSet<Module*> &Sema::getLookupModules() {
1615 unsigned N = CodeSynthesisContexts.size();
1616 for (unsigned I = CodeSynthesisContextLookupModules.size();
1617 I != N; ++I) {
1618 Module *M = CodeSynthesisContexts[I].Entity ?
1619 getDefiningModule(S&: *this, Entity: CodeSynthesisContexts[I].Entity) :
1620 nullptr;
1621 if (M && !LookupModulesCache.insert(V: M).second)
1622 M = nullptr;
1623 CodeSynthesisContextLookupModules.push_back(Elt: M);
1624 }
1625 return LookupModulesCache;
1626}
1627
1628bool Sema::isUsableModule(const Module *M) {
1629 assert(M && "We shouldn't check nullness for module here");
1630 // Return quickly if we cached the result.
1631 if (UsableModuleUnitsCache.count(V: M))
1632 return true;
1633
1634 // If M is the global module fragment of the current translation unit. So it
1635 // should be usable.
1636 // [module.global.frag]p1:
1637 // The global module fragment can be used to provide declarations that are
1638 // attached to the global module and usable within the module unit.
1639 if (M == TheGlobalModuleFragment || M == TheImplicitGlobalModuleFragment) {
1640 UsableModuleUnitsCache.insert(V: M);
1641 return true;
1642 }
1643
1644 // Otherwise, the global module fragment from other translation unit is not
1645 // directly usable.
1646 if (M->isExplicitGlobalModule())
1647 return false;
1648
1649 Module *Current = getCurrentModule();
1650
1651 // If we're not parsing a module, we can't use all the declarations from
1652 // another module easily.
1653 if (!Current)
1654 return false;
1655
1656 // For implicit global module, the decls in the same modules with the parent
1657 // module should be visible to the decls in the implicit global module.
1658 if (Current->isImplicitGlobalModule())
1659 Current = Current->getTopLevelModule();
1660 if (M->isImplicitGlobalModule())
1661 M = M->getTopLevelModule();
1662
1663 // If M is the module we're parsing or M and the current module unit lives in
1664 // the same module, M should be usable.
1665 //
1666 // Note: It should be fine to search the vector `ModuleScopes` linearly since
1667 // it should be generally small enough. There should be rare module fragments
1668 // in a named module unit.
1669 if (llvm::count_if(Range&: ModuleScopes,
1670 P: [&M](const ModuleScope &MS) { return MS.Module == M; }) ||
1671 getASTContext().isInSameModule(M1: M, M2: Current)) {
1672 UsableModuleUnitsCache.insert(V: M);
1673 return true;
1674 }
1675
1676 return false;
1677}
1678
1679bool Sema::hasVisibleMergedDefinition(const NamedDecl *Def) {
1680 for (const Module *Merged : Context.getModulesWithMergedDefinition(Def))
1681 if (isModuleVisible(M: Merged))
1682 return true;
1683 return false;
1684}
1685
1686bool Sema::hasMergedDefinitionInCurrentModule(const NamedDecl *Def) {
1687 for (const Module *Merged : Context.getModulesWithMergedDefinition(Def))
1688 if (isUsableModule(M: Merged))
1689 return true;
1690 return false;
1691}
1692
1693template <typename ParmDecl>
1694static bool
1695hasAcceptableDefaultArgument(Sema &S, const ParmDecl *D,
1696 llvm::SmallVectorImpl<Module *> *Modules,
1697 Sema::AcceptableKind Kind) {
1698 if (!D->hasDefaultArgument())
1699 return false;
1700
1701 llvm::SmallPtrSet<const ParmDecl *, 4> Visited;
1702 while (D && Visited.insert(D).second) {
1703 auto &DefaultArg = D->getDefaultArgStorage();
1704 if (!DefaultArg.isInherited() && S.isAcceptable(D, Kind))
1705 return true;
1706
1707 if (!DefaultArg.isInherited() && Modules) {
1708 auto *NonConstD = const_cast<ParmDecl*>(D);
1709 Modules->push_back(Elt: S.getOwningModule(Entity: NonConstD));
1710 }
1711
1712 // If there was a previous default argument, maybe its parameter is
1713 // acceptable.
1714 D = DefaultArg.getInheritedFrom();
1715 }
1716 return false;
1717}
1718
1719bool Sema::hasAcceptableDefaultArgument(
1720 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules,
1721 Sema::AcceptableKind Kind) {
1722 if (auto *P = dyn_cast<TemplateTypeParmDecl>(Val: D))
1723 return ::hasAcceptableDefaultArgument(S&: *this, D: P, Modules, Kind);
1724
1725 if (auto *P = dyn_cast<NonTypeTemplateParmDecl>(Val: D))
1726 return ::hasAcceptableDefaultArgument(S&: *this, D: P, Modules, Kind);
1727
1728 return ::hasAcceptableDefaultArgument(
1729 S&: *this, D: cast<TemplateTemplateParmDecl>(Val: D), Modules, Kind);
1730}
1731
1732bool Sema::hasVisibleDefaultArgument(const NamedDecl *D,
1733 llvm::SmallVectorImpl<Module *> *Modules) {
1734 return hasAcceptableDefaultArgument(D, Modules,
1735 Kind: Sema::AcceptableKind::Visible);
1736}
1737
1738bool Sema::hasReachableDefaultArgument(
1739 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
1740 return hasAcceptableDefaultArgument(D, Modules,
1741 Kind: Sema::AcceptableKind::Reachable);
1742}
1743
1744template <typename Filter>
1745static bool
1746hasAcceptableDeclarationImpl(Sema &S, const NamedDecl *D,
1747 llvm::SmallVectorImpl<Module *> *Modules, Filter F,
1748 Sema::AcceptableKind Kind) {
1749 bool HasFilteredRedecls = false;
1750
1751 for (auto *Redecl : D->redecls()) {
1752 auto *R = cast<NamedDecl>(Val: Redecl);
1753 if (!F(R))
1754 continue;
1755
1756 if (S.isAcceptable(D: R, Kind))
1757 return true;
1758
1759 HasFilteredRedecls = true;
1760
1761 if (Modules)
1762 Modules->push_back(Elt: R->getOwningModule());
1763 }
1764
1765 // Only return false if there is at least one redecl that is not filtered out.
1766 if (HasFilteredRedecls)
1767 return false;
1768
1769 return true;
1770}
1771
1772static bool
1773hasAcceptableExplicitSpecialization(Sema &S, const NamedDecl *D,
1774 llvm::SmallVectorImpl<Module *> *Modules,
1775 Sema::AcceptableKind Kind) {
1776 return hasAcceptableDeclarationImpl(
1777 S, D, Modules,
1778 F: [](const NamedDecl *D) {
1779 if (auto *RD = dyn_cast<CXXRecordDecl>(Val: D))
1780 return RD->getTemplateSpecializationKind() ==
1781 TSK_ExplicitSpecialization;
1782 if (auto *FD = dyn_cast<FunctionDecl>(Val: D))
1783 return FD->getTemplateSpecializationKind() ==
1784 TSK_ExplicitSpecialization;
1785 if (auto *VD = dyn_cast<VarDecl>(Val: D))
1786 return VD->getTemplateSpecializationKind() ==
1787 TSK_ExplicitSpecialization;
1788 llvm_unreachable("unknown explicit specialization kind");
1789 },
1790 Kind);
1791}
1792
1793bool Sema::hasVisibleExplicitSpecialization(
1794 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
1795 return ::hasAcceptableExplicitSpecialization(S&: *this, D, Modules,
1796 Kind: Sema::AcceptableKind::Visible);
1797}
1798
1799bool Sema::hasReachableExplicitSpecialization(
1800 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
1801 return ::hasAcceptableExplicitSpecialization(S&: *this, D, Modules,
1802 Kind: Sema::AcceptableKind::Reachable);
1803}
1804
1805static bool
1806hasAcceptableMemberSpecialization(Sema &S, const NamedDecl *D,
1807 llvm::SmallVectorImpl<Module *> *Modules,
1808 Sema::AcceptableKind Kind) {
1809 assert(isa<CXXRecordDecl>(D->getDeclContext()) &&
1810 "not a member specialization");
1811 return hasAcceptableDeclarationImpl(
1812 S, D, Modules,
1813 F: [](const NamedDecl *D) {
1814 // If the specialization is declared at namespace scope, then it's a
1815 // member specialization declaration. If it's lexically inside the class
1816 // definition then it was instantiated.
1817 //
1818 // FIXME: This is a hack. There should be a better way to determine
1819 // this.
1820 // FIXME: What about MS-style explicit specializations declared within a
1821 // class definition?
1822 return D->getLexicalDeclContext()->isFileContext();
1823 },
1824 Kind);
1825}
1826
1827bool Sema::hasVisibleMemberSpecialization(
1828 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
1829 return hasAcceptableMemberSpecialization(S&: *this, D, Modules,
1830 Kind: Sema::AcceptableKind::Visible);
1831}
1832
1833bool Sema::hasReachableMemberSpecialization(
1834 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
1835 return hasAcceptableMemberSpecialization(S&: *this, D, Modules,
1836 Kind: Sema::AcceptableKind::Reachable);
1837}
1838
1839/// Determine whether a declaration is acceptable to name lookup.
1840///
1841/// This routine determines whether the declaration D is acceptable in the
1842/// current lookup context, taking into account the current template
1843/// instantiation stack. During template instantiation, a declaration is
1844/// acceptable if it is acceptable from a module containing any entity on the
1845/// template instantiation path (by instantiating a template, you allow it to
1846/// see the declarations that your module can see, including those later on in
1847/// your module).
1848bool LookupResult::isAcceptableSlow(Sema &SemaRef, NamedDecl *D,
1849 Sema::AcceptableKind Kind) {
1850 assert(!D->isUnconditionallyVisible() &&
1851 "should not call this: not in slow case");
1852
1853 Module *DeclModule = SemaRef.getOwningModule(Entity: D);
1854 assert(DeclModule && "hidden decl has no owning module");
1855
1856 // If the owning module is visible, the decl is acceptable.
1857 if (SemaRef.isModuleVisible(M: DeclModule,
1858 ModulePrivate: D->isInvisibleOutsideTheOwningModule()))
1859 return true;
1860
1861 // Determine whether a decl context is a file context for the purpose of
1862 // visibility/reachability. This looks through some (export and linkage spec)
1863 // transparent contexts, but not others (enums).
1864 auto IsEffectivelyFileContext = [](const DeclContext *DC) {
1865 return DC->isFileContext() || isa<LinkageSpecDecl>(Val: DC) ||
1866 isa<ExportDecl>(Val: DC);
1867 };
1868
1869 // If this declaration is not at namespace scope
1870 // then it is acceptable if its lexical parent has a acceptable definition.
1871 DeclContext *DC = D->getLexicalDeclContext();
1872 if (DC && !IsEffectivelyFileContext(DC)) {
1873 // For a parameter, check whether our current template declaration's
1874 // lexical context is acceptable, not whether there's some other acceptable
1875 // definition of it, because parameters aren't "within" the definition.
1876 //
1877 // In C++ we need to check for a acceptable definition due to ODR merging,
1878 // and in C we must not because each declaration of a function gets its own
1879 // set of declarations for tags in prototype scope.
1880 bool AcceptableWithinParent;
1881 if (D->isTemplateParameter()) {
1882 bool SearchDefinitions = true;
1883 if (const auto *DCD = dyn_cast<Decl>(Val: DC)) {
1884 if (const auto *TD = DCD->getDescribedTemplate()) {
1885 TemplateParameterList *TPL = TD->getTemplateParameters();
1886 auto Index = getDepthAndIndex(ND: D).second;
1887 SearchDefinitions = Index >= TPL->size() || TPL->getParam(Idx: Index) != D;
1888 }
1889 }
1890 if (SearchDefinitions)
1891 AcceptableWithinParent =
1892 SemaRef.hasAcceptableDefinition(D: cast<NamedDecl>(Val: DC), Kind);
1893 else
1894 AcceptableWithinParent =
1895 isAcceptable(SemaRef, D: cast<NamedDecl>(Val: DC), Kind);
1896 } else if (isa<ParmVarDecl>(Val: D) ||
1897 (isa<FunctionDecl>(Val: DC) && !SemaRef.getLangOpts().CPlusPlus))
1898 AcceptableWithinParent = isAcceptable(SemaRef, D: cast<NamedDecl>(Val: DC), Kind);
1899 else if (D->isModulePrivate()) {
1900 // A module-private declaration is only acceptable if an enclosing lexical
1901 // parent was merged with another definition in the current module.
1902 AcceptableWithinParent = false;
1903 do {
1904 if (SemaRef.hasMergedDefinitionInCurrentModule(Def: cast<NamedDecl>(Val: DC))) {
1905 AcceptableWithinParent = true;
1906 break;
1907 }
1908 DC = DC->getLexicalParent();
1909 } while (!IsEffectivelyFileContext(DC));
1910 } else if (auto *FD = dyn_cast<FunctionDecl>(Val: DC);
1911 FD && !FD->getDefinition()) {
1912 // This is possible as the definition are removed in reduced BMI.
1913 AcceptableWithinParent = isAcceptable(SemaRef, D: FD, Kind);
1914 } else {
1915 AcceptableWithinParent =
1916 SemaRef.hasAcceptableDefinition(D: cast<NamedDecl>(Val: DC), Kind);
1917 }
1918
1919 if (AcceptableWithinParent && SemaRef.CodeSynthesisContexts.empty() &&
1920 Kind == Sema::AcceptableKind::Visible &&
1921 // FIXME: Do something better in this case.
1922 !SemaRef.getLangOpts().ModulesLocalVisibility) {
1923 // Cache the fact that this declaration is implicitly visible because
1924 // its parent has a visible definition.
1925 D->setVisibleDespiteOwningModule();
1926 }
1927 return AcceptableWithinParent;
1928 }
1929
1930 if (Kind == Sema::AcceptableKind::Visible)
1931 return false;
1932
1933 assert(Kind == Sema::AcceptableKind::Reachable &&
1934 "Additional Sema::AcceptableKind?");
1935 return isReachableSlow(SemaRef, D);
1936}
1937
1938bool Sema::isModuleVisible(const Module *M, bool ModulePrivate) {
1939 // The module might be ordinarily visible. For a module-private query, that
1940 // means it is part of the current module.
1941 if (ModulePrivate && isUsableModule(M))
1942 return true;
1943
1944 // For a query which is not module-private, that means it is in our visible
1945 // module set.
1946 if (!ModulePrivate && VisibleModules.isVisible(M))
1947 return true;
1948
1949 // Otherwise, it might be visible by virtue of the query being within a
1950 // template instantiation or similar that is permitted to look inside M.
1951
1952 // Find the extra places where we need to look.
1953 const auto &LookupModules = getLookupModules();
1954 if (LookupModules.empty())
1955 return false;
1956
1957 // If our lookup set contains the module, it's visible.
1958 if (LookupModules.count(V: M))
1959 return true;
1960
1961 // The global module fragments are visible to its corresponding module unit.
1962 // So the global module fragment should be visible if the its corresponding
1963 // module unit is visible.
1964 if (M->isGlobalModule() && LookupModules.count(V: M->getTopLevelModule()))
1965 return true;
1966
1967 // For a module-private query, that's everywhere we get to look.
1968 if (ModulePrivate)
1969 return false;
1970
1971 // Check whether M is transitively exported to an import of the lookup set.
1972 return llvm::any_of(Range: LookupModules, P: [&](const Module *LookupM) {
1973 return LookupM->isModuleVisible(M);
1974 });
1975}
1976
1977// FIXME: Return false directly if we don't have an interface dependency on the
1978// translation unit containing D.
1979bool LookupResult::isReachableSlow(Sema &SemaRef, NamedDecl *D) {
1980 assert(!isVisible(SemaRef, D) && "Shouldn't call the slow case.\n");
1981
1982 Module *DeclModule = SemaRef.getOwningModule(Entity: D);
1983 assert(DeclModule && "hidden decl has no owning module");
1984
1985 // Entities in header like modules are reachable only if they're visible.
1986 if (DeclModule->isHeaderLikeModule())
1987 return false;
1988
1989 if (!D->isInAnotherModuleUnit())
1990 return true;
1991
1992 // [module.reach]/p3:
1993 // A declaration D is reachable from a point P if:
1994 // ...
1995 // - D is not discarded ([module.global.frag]), appears in a translation unit
1996 // that is reachable from P, and does not appear within a private module
1997 // fragment.
1998 //
1999 // A declaration that's discarded in the GMF should be module-private.
2000 if (D->isModulePrivate())
2001 return false;
2002
2003 Module *DeclTopModule = DeclModule->getTopLevelModule();
2004
2005 // [module.reach]/p1
2006 // A translation unit U is necessarily reachable from a point P if U is a
2007 // module interface unit on which the translation unit containing P has an
2008 // interface dependency, or the translation unit containing P imports U, in
2009 // either case prior to P ([module.import]).
2010 //
2011 // [module.import]/p10
2012 // A translation unit has an interface dependency on a translation unit U if
2013 // it contains a declaration (possibly a module-declaration) that imports U
2014 // or if it has an interface dependency on a translation unit that has an
2015 // interface dependency on U.
2016 //
2017 // So we could conclude the module unit U is necessarily reachable if:
2018 // (1) The module unit U is module interface unit.
2019 // (2) The current unit has an interface dependency on the module unit U.
2020 //
2021 // Here we only check for the first condition. Since we couldn't see
2022 // DeclModule if it isn't (transitively) imported.
2023 if (DeclTopModule->isModuleInterfaceUnit())
2024 return true;
2025
2026 // [module.reach]/p1,2
2027 // A translation unit U is necessarily reachable from a point P if U is a
2028 // module interface unit on which the translation unit containing P has an
2029 // interface dependency, or the translation unit containing P imports U, in
2030 // either case prior to P
2031 //
2032 // Additional translation units on
2033 // which the point within the program has an interface dependency may be
2034 // considered reachable, but it is unspecified which are and under what
2035 // circumstances.
2036 Module *CurrentM = SemaRef.getCurrentModule();
2037
2038 // Directly imported module are necessarily reachable.
2039 // Since we can't export import a module implementation partition unit, we
2040 // don't need to count for Exports here.
2041 if (CurrentM &&
2042 llvm::is_contained(Range&: CurrentM->getTopLevelModule()->Imports, Element: DeclTopModule))
2043 return true;
2044
2045 // Then we treat all module implementation partition unit as unreachable.
2046 return false;
2047}
2048
2049bool Sema::isAcceptableSlow(const NamedDecl *D, Sema::AcceptableKind Kind) {
2050 return LookupResult::isAcceptable(SemaRef&: *this, D: const_cast<NamedDecl *>(D), Kind);
2051}
2052
2053bool Sema::shouldLinkPossiblyHiddenDecl(LookupResult &R, const NamedDecl *New) {
2054 // FIXME: If there are both visible and hidden declarations, we need to take
2055 // into account whether redeclaration is possible. Example:
2056 //
2057 // Non-imported module:
2058 // int f(T); // #1
2059 // Some TU:
2060 // static int f(U); // #2, not a redeclaration of #1
2061 // int f(T); // #3, finds both, should link with #1 if T != U, but
2062 // // with #2 if T == U; neither should be ambiguous.
2063 for (auto *D : R) {
2064 if (isVisible(D))
2065 return true;
2066 assert(D->isExternallyDeclarable() &&
2067 "should not have hidden, non-externally-declarable result here");
2068 }
2069
2070 // This function is called once "New" is essentially complete, but before a
2071 // previous declaration is attached. We can't query the linkage of "New" in
2072 // general, because attaching the previous declaration can change the
2073 // linkage of New to match the previous declaration.
2074 //
2075 // However, because we've just determined that there is no *visible* prior
2076 // declaration, we can compute the linkage here. There are two possibilities:
2077 //
2078 // * This is not a redeclaration; it's safe to compute the linkage now.
2079 //
2080 // * This is a redeclaration of a prior declaration that is externally
2081 // redeclarable. In that case, the linkage of the declaration is not
2082 // changed by attaching the prior declaration, because both are externally
2083 // declarable (and thus ExternalLinkage or VisibleNoLinkage).
2084 //
2085 // FIXME: This is subtle and fragile.
2086 return New->isExternallyDeclarable();
2087}
2088
2089/// Retrieve the visible declaration corresponding to D, if any.
2090///
2091/// This routine determines whether the declaration D is visible in the current
2092/// module, with the current imports. If not, it checks whether any
2093/// redeclaration of D is visible, and if so, returns that declaration.
2094///
2095/// \returns D, or a visible previous declaration of D, whichever is more recent
2096/// and visible. If no declaration of D is visible, returns null.
2097static NamedDecl *findAcceptableDecl(Sema &SemaRef, NamedDecl *D,
2098 unsigned IDNS) {
2099 assert(!LookupResult::isAvailableForLookup(SemaRef, D) && "not in slow case");
2100
2101 for (auto *RD : D->redecls()) {
2102 // Don't bother with extra checks if we already know this one isn't visible.
2103 if (RD == D)
2104 continue;
2105
2106 auto ND = cast<NamedDecl>(Val: RD);
2107 // FIXME: This is wrong in the case where the previous declaration is not
2108 // visible in the same scope as D. This needs to be done much more
2109 // carefully.
2110 if (ND->isInIdentifierNamespace(NS: IDNS) &&
2111 LookupResult::isAvailableForLookup(SemaRef, ND))
2112 return ND;
2113 }
2114
2115 return nullptr;
2116}
2117
2118bool Sema::hasVisibleDeclarationSlow(const NamedDecl *D,
2119 llvm::SmallVectorImpl<Module *> *Modules) {
2120 assert(!isVisible(D) && "not in slow case");
2121 return hasAcceptableDeclarationImpl(
2122 S&: *this, D, Modules, F: [](const NamedDecl *) { return true; },
2123 Kind: Sema::AcceptableKind::Visible);
2124}
2125
2126bool Sema::hasReachableDeclarationSlow(
2127 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
2128 assert(!isReachable(D) && "not in slow case");
2129 return hasAcceptableDeclarationImpl(
2130 S&: *this, D, Modules, F: [](const NamedDecl *) { return true; },
2131 Kind: Sema::AcceptableKind::Reachable);
2132}
2133
2134NamedDecl *LookupResult::getAcceptableDeclSlow(NamedDecl *D) const {
2135 if (auto *ND = dyn_cast<NamespaceDecl>(Val: D)) {
2136 // Namespaces are a bit of a special case: we expect there to be a lot of
2137 // redeclarations of some namespaces, all declarations of a namespace are
2138 // essentially interchangeable, all declarations are found by name lookup
2139 // if any is, and namespaces are never looked up during template
2140 // instantiation. So we benefit from caching the check in this case, and
2141 // it is correct to do so.
2142 auto *Key = ND->getCanonicalDecl();
2143 if (auto *Acceptable = getSema().VisibleNamespaceCache.lookup(Val: Key))
2144 return Acceptable;
2145 auto *Acceptable = isVisible(SemaRef&: getSema(), D: Key)
2146 ? Key
2147 : findAcceptableDecl(SemaRef&: getSema(), D: Key, IDNS);
2148 if (Acceptable)
2149 getSema().VisibleNamespaceCache.insert(KV: std::make_pair(x&: Key, y&: Acceptable));
2150 return Acceptable;
2151 }
2152
2153 return findAcceptableDecl(SemaRef&: getSema(), D, IDNS);
2154}
2155
2156bool LookupResult::isVisible(Sema &SemaRef, NamedDecl *D) {
2157 // If this declaration is already visible, return it directly.
2158 if (D->isUnconditionallyVisible())
2159 return true;
2160
2161 // During template instantiation, we can refer to hidden declarations, if
2162 // they were visible in any module along the path of instantiation.
2163 return isAcceptableSlow(SemaRef, D, Kind: Sema::AcceptableKind::Visible);
2164}
2165
2166bool LookupResult::isReachable(Sema &SemaRef, NamedDecl *D) {
2167 if (D->isUnconditionallyVisible())
2168 return true;
2169
2170 return isAcceptableSlow(SemaRef, D, Kind: Sema::AcceptableKind::Reachable);
2171}
2172
2173bool LookupResult::isAvailableForLookup(Sema &SemaRef, NamedDecl *ND) {
2174 // We should check the visibility at the callsite already.
2175 if (isVisible(SemaRef, D: ND))
2176 return true;
2177
2178 // Deduction guide lives in namespace scope generally, but it is just a
2179 // hint to the compilers. What we actually lookup for is the generated member
2180 // of the corresponding template. So it is sufficient to check the
2181 // reachability of the template decl.
2182 if (auto *DeductionGuide = ND->getDeclName().getCXXDeductionGuideTemplate())
2183 return SemaRef.hasReachableDefinition(D: DeductionGuide);
2184
2185 // FIXME: The lookup for allocation function is a standalone process.
2186 // (We can find the logics in Sema::FindAllocationFunctions)
2187 //
2188 // Such structure makes it a problem when we instantiate a template
2189 // declaration using placement allocation function if the placement
2190 // allocation function is invisible.
2191 // (See https://github.com/llvm/llvm-project/issues/59601)
2192 //
2193 // Here we workaround it by making the placement allocation functions
2194 // always acceptable. The downside is that we can't diagnose the direct
2195 // use of the invisible placement allocation functions. (Although such uses
2196 // should be rare).
2197 if (auto *FD = dyn_cast<FunctionDecl>(Val: ND);
2198 FD && FD->isReservedGlobalPlacementOperator())
2199 return true;
2200
2201 auto *DC = ND->getDeclContext();
2202 // If ND is not visible and it is at namespace scope, it shouldn't be found
2203 // by name lookup.
2204 if (DC->isFileContext())
2205 return false;
2206
2207 // [module.interface]p7
2208 // Class and enumeration member names can be found by name lookup in any
2209 // context in which a definition of the type is reachable.
2210 //
2211 // NOTE: The above wording may be problematic. See
2212 // https://github.com/llvm/llvm-project/issues/131058 But it is much complext
2213 // to adjust it in Sema's lookup process. Now we hacked it in ASTWriter. See
2214 // the comments in ASTDeclContextNameLookupTrait::getLookupVisibility.
2215 if (auto *TD = dyn_cast<TagDecl>(Val: DC))
2216 return SemaRef.hasReachableDefinition(D: TD);
2217
2218 return false;
2219}
2220
2221bool Sema::LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation,
2222 bool ForceNoCPlusPlus) {
2223 DeclarationName Name = R.getLookupName();
2224 if (!Name) return false;
2225
2226 LookupNameKind NameKind = R.getLookupKind();
2227
2228 if (!getLangOpts().CPlusPlus || ForceNoCPlusPlus) {
2229 // Unqualified name lookup in C/Objective-C is purely lexical, so
2230 // search in the declarations attached to the name.
2231 if (NameKind == Sema::LookupRedeclarationWithLinkage) {
2232 // Find the nearest non-transparent declaration scope.
2233 while (!(S->getFlags() & Scope::DeclScope) ||
2234 (S->getEntity() && S->getEntity()->isTransparentContext()))
2235 S = S->getParent();
2236 }
2237
2238 // When performing a scope lookup, we want to find local extern decls.
2239 FindLocalExternScope FindLocals(R);
2240
2241 // Scan up the scope chain looking for a decl that matches this
2242 // identifier that is in the appropriate namespace. This search
2243 // should not take long, as shadowing of names is uncommon, and
2244 // deep shadowing is extremely uncommon.
2245 bool LeftStartingScope = false;
2246
2247 for (IdentifierResolver::iterator I = IdResolver.begin(Name),
2248 IEnd = IdResolver.end();
2249 I != IEnd; ++I)
2250 if (NamedDecl *D = R.getAcceptableDecl(D: *I)) {
2251 if (NameKind == LookupRedeclarationWithLinkage) {
2252 // Determine whether this (or a previous) declaration is
2253 // out-of-scope.
2254 if (!LeftStartingScope && !S->isDeclScope(D: *I))
2255 LeftStartingScope = true;
2256
2257 // If we found something outside of our starting scope that
2258 // does not have linkage, skip it.
2259 if (LeftStartingScope && !((*I)->hasLinkage())) {
2260 R.setShadowed();
2261 continue;
2262 }
2263 }
2264 else if (NameKind == LookupObjCImplicitSelfParam &&
2265 !isa<ImplicitParamDecl>(Val: *I))
2266 continue;
2267
2268 R.addDecl(D);
2269
2270 // Check whether there are any other declarations with the same name
2271 // and in the same scope.
2272 if (I != IEnd) {
2273 // Find the scope in which this declaration was declared (if it
2274 // actually exists in a Scope).
2275 while (S && !S->isDeclScope(D))
2276 S = S->getParent();
2277
2278 // If the scope containing the declaration is the translation unit,
2279 // then we'll need to perform our checks based on the matching
2280 // DeclContexts rather than matching scopes.
2281 if (S && isNamespaceOrTranslationUnitScope(S))
2282 S = nullptr;
2283
2284 // Compute the DeclContext, if we need it.
2285 DeclContext *DC = nullptr;
2286 if (!S)
2287 DC = (*I)->getDeclContext()->getRedeclContext();
2288
2289 IdentifierResolver::iterator LastI = I;
2290 for (++LastI; LastI != IEnd; ++LastI) {
2291 if (S) {
2292 // Match based on scope.
2293 if (!S->isDeclScope(D: *LastI))
2294 break;
2295 } else {
2296 // Match based on DeclContext.
2297 DeclContext *LastDC
2298 = (*LastI)->getDeclContext()->getRedeclContext();
2299 if (!LastDC->Equals(DC))
2300 break;
2301 }
2302
2303 // If the declaration is in the right namespace and visible, add it.
2304 if (NamedDecl *LastD = R.getAcceptableDecl(D: *LastI))
2305 R.addDecl(D: LastD);
2306 }
2307
2308 R.resolveKind();
2309 }
2310
2311 return true;
2312 }
2313 } else {
2314 // Perform C++ unqualified name lookup.
2315 if (CppLookupName(R, S))
2316 return true;
2317 }
2318
2319 // If we didn't find a use of this identifier, and if the identifier
2320 // corresponds to a compiler builtin, create the decl object for the builtin
2321 // now, injecting it into translation unit scope, and return it.
2322 if (AllowBuiltinCreation && LookupBuiltin(R))
2323 return true;
2324
2325 // If we didn't find a use of this identifier, the ExternalSource
2326 // may be able to handle the situation.
2327 // Note: some lookup failures are expected!
2328 // See e.g. R.isForRedeclaration().
2329 return (ExternalSource && ExternalSource->LookupUnqualified(R, S));
2330}
2331
2332/// Perform qualified name lookup in the namespaces nominated by
2333/// using directives by the given context.
2334///
2335/// C++98 [namespace.qual]p2:
2336/// Given X::m (where X is a user-declared namespace), or given \::m
2337/// (where X is the global namespace), let S be the set of all
2338/// declarations of m in X and in the transitive closure of all
2339/// namespaces nominated by using-directives in X and its used
2340/// namespaces, except that using-directives are ignored in any
2341/// namespace, including X, directly containing one or more
2342/// declarations of m. No namespace is searched more than once in
2343/// the lookup of a name. If S is the empty set, the program is
2344/// ill-formed. Otherwise, if S has exactly one member, or if the
2345/// context of the reference is a using-declaration
2346/// (namespace.udecl), S is the required set of declarations of
2347/// m. Otherwise if the use of m is not one that allows a unique
2348/// declaration to be chosen from S, the program is ill-formed.
2349///
2350/// C++98 [namespace.qual]p5:
2351/// During the lookup of a qualified namespace member name, if the
2352/// lookup finds more than one declaration of the member, and if one
2353/// declaration introduces a class name or enumeration name and the
2354/// other declarations either introduce the same object, the same
2355/// enumerator or a set of functions, the non-type name hides the
2356/// class or enumeration name if and only if the declarations are
2357/// from the same namespace; otherwise (the declarations are from
2358/// different namespaces), the program is ill-formed.
2359static bool LookupQualifiedNameInUsingDirectives(Sema &S, LookupResult &R,
2360 DeclContext *StartDC) {
2361 assert(StartDC->isFileContext() && "start context is not a file context");
2362
2363 // We have not yet looked into these namespaces, much less added
2364 // their "using-children" to the queue.
2365 SmallVector<NamespaceDecl*, 8> Queue;
2366
2367 // We have at least added all these contexts to the queue.
2368 llvm::SmallPtrSet<DeclContext*, 8> Visited;
2369 Visited.insert(Ptr: StartDC);
2370
2371 // We have already looked into the initial namespace; seed the queue
2372 // with its using-children.
2373 for (auto *I : StartDC->using_directives()) {
2374 NamespaceDecl *ND = I->getNominatedNamespace()->getFirstDecl();
2375 if (S.isVisible(D: I) && Visited.insert(Ptr: ND).second)
2376 Queue.push_back(Elt: ND);
2377 }
2378
2379 // The easiest way to implement the restriction in [namespace.qual]p5
2380 // is to check whether any of the individual results found a tag
2381 // and, if so, to declare an ambiguity if the final result is not
2382 // a tag.
2383 bool FoundTag = false;
2384 bool FoundNonTag = false;
2385
2386 LookupResult LocalR(LookupResult::Temporary, R);
2387
2388 bool Found = false;
2389 while (!Queue.empty()) {
2390 NamespaceDecl *ND = Queue.pop_back_val();
2391
2392 // We go through some convolutions here to avoid copying results
2393 // between LookupResults.
2394 bool UseLocal = !R.empty();
2395 LookupResult &DirectR = UseLocal ? LocalR : R;
2396 bool FoundDirect = LookupDirect(S, R&: DirectR, DC: ND);
2397
2398 if (FoundDirect) {
2399 // First do any local hiding.
2400 DirectR.resolveKind();
2401
2402 // If the local result is a tag, remember that.
2403 if (DirectR.isSingleTagDecl())
2404 FoundTag = true;
2405 else
2406 FoundNonTag = true;
2407
2408 // Append the local results to the total results if necessary.
2409 if (UseLocal) {
2410 R.addAllDecls(Other: LocalR);
2411 LocalR.clear();
2412 }
2413 }
2414
2415 // If we find names in this namespace, ignore its using directives.
2416 if (FoundDirect) {
2417 Found = true;
2418 continue;
2419 }
2420
2421 for (auto *I : ND->using_directives()) {
2422 NamespaceDecl *Nom = I->getNominatedNamespace();
2423 if (S.isVisible(D: I) && Visited.insert(Ptr: Nom).second)
2424 Queue.push_back(Elt: Nom);
2425 }
2426 }
2427
2428 if (Found) {
2429 if (FoundTag && FoundNonTag)
2430 R.setAmbiguousQualifiedTagHiding();
2431 else
2432 R.resolveKind();
2433 }
2434
2435 return Found;
2436}
2437
2438bool Sema::LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
2439 bool InUnqualifiedLookup) {
2440 assert(LookupCtx && "Sema::LookupQualifiedName requires a lookup context");
2441
2442 if (!R.getLookupName())
2443 return false;
2444
2445#ifndef NDEBUG
2446 // Make sure that the declaration context is complete.
2447 if (const auto *TD = dyn_cast<TagDecl>(LookupCtx);
2448 TD && !TD->isDependentType() && TD->getDefinition() == nullptr)
2449 llvm_unreachable("Declaration context must already be complete!");
2450#endif
2451
2452 // Inform the external source that we're looking for a qualified name.
2453 struct QualifiedLookupInScope {
2454 ExternalSemaSource *Source;
2455 const DeclContext *Context;
2456 QualifiedLookupInScope(ExternalSemaSource *Source, const DeclContext *Ctx)
2457 : Source(Source), Context(Ctx) {
2458 if (Source)
2459 Source->StartedQualifiedLookup(DC: Context);
2460 }
2461 ~QualifiedLookupInScope() {
2462 if (Source)
2463 Source->FinishedQualifiedLookup(DC: Context);
2464 }
2465 } QL(ExternalSource.get(), LookupCtx);
2466
2467 CXXRecordDecl *LookupRec = dyn_cast<CXXRecordDecl>(Val: LookupCtx);
2468 // FIXME: Per [temp.dep.general]p2, an unqualified name is also dependent
2469 // if it's a dependent conversion-function-id or operator= where the current
2470 // class is a templated entity. This should be handled in LookupName.
2471 if (!InUnqualifiedLookup && !R.isForRedeclaration()) {
2472 // C++23 [temp.dep.type]p5:
2473 // A qualified name is dependent if
2474 // - it is a conversion-function-id whose conversion-type-id
2475 // is dependent, or
2476 // - [...]
2477 // - its lookup context is the current instantiation and it
2478 // is operator=, or
2479 // - [...]
2480 if (DeclarationName Name = R.getLookupName();
2481 Name.getNameKind() == DeclarationName::CXXConversionFunctionName &&
2482 Name.getCXXNameType()->isDependentType()) {
2483 R.setNotFoundInCurrentInstantiation();
2484 return false;
2485 }
2486 }
2487
2488 if (LookupDirect(S&: *this, R, DC: LookupCtx)) {
2489 R.resolveKind();
2490 if (LookupRec)
2491 R.setNamingClass(LookupRec);
2492 return true;
2493 }
2494
2495 // Don't descend into implied contexts for redeclarations.
2496 // C++98 [namespace.qual]p6:
2497 // In a declaration for a namespace member in which the
2498 // declarator-id is a qualified-id, given that the qualified-id
2499 // for the namespace member has the form
2500 // nested-name-specifier unqualified-id
2501 // the unqualified-id shall name a member of the namespace
2502 // designated by the nested-name-specifier.
2503 // See also [class.mfct]p5 and [class.static.data]p2.
2504 if (R.isForRedeclaration())
2505 return false;
2506
2507 // If this is a namespace, look it up in the implied namespaces.
2508 if (LookupCtx->isFileContext())
2509 return LookupQualifiedNameInUsingDirectives(S&: *this, R, StartDC: LookupCtx);
2510
2511 // If this isn't a C++ class, we aren't allowed to look into base
2512 // classes, we're done.
2513 if (!LookupRec || !LookupRec->getDefinition())
2514 return false;
2515
2516 // We're done for lookups that can never succeed for C++ classes.
2517 if (R.getLookupKind() == LookupOperatorName ||
2518 R.getLookupKind() == LookupNamespaceName ||
2519 R.getLookupKind() == LookupObjCProtocolName ||
2520 R.getLookupKind() == LookupLabel)
2521 return false;
2522
2523 // If we're performing qualified name lookup into a dependent class,
2524 // then we are actually looking into a current instantiation. If we have any
2525 // dependent base classes, then we either have to delay lookup until
2526 // template instantiation time (at which point all bases will be available)
2527 // or we have to fail.
2528 if (!InUnqualifiedLookup && LookupRec->isDependentContext() &&
2529 LookupRec->hasAnyDependentBases()) {
2530 R.setNotFoundInCurrentInstantiation();
2531 return false;
2532 }
2533
2534 // Perform lookup into our base classes.
2535
2536 DeclarationName Name = R.getLookupName();
2537 unsigned IDNS = R.getIdentifierNamespace();
2538
2539 // Look for this member in our base classes.
2540 auto BaseCallback = [Name, IDNS](const CXXBaseSpecifier *Specifier,
2541 CXXBasePath &Path) -> bool {
2542 CXXRecordDecl *BaseRecord = Specifier->getType()->getAsCXXRecordDecl();
2543 // Drop leading non-matching lookup results from the declaration list so
2544 // we don't need to consider them again below.
2545 for (Path.Decls = BaseRecord->lookup(Name).begin();
2546 Path.Decls != Path.Decls.end(); ++Path.Decls) {
2547 if ((*Path.Decls)->isInIdentifierNamespace(NS: IDNS))
2548 return true;
2549 }
2550 return false;
2551 };
2552
2553 CXXBasePaths Paths;
2554 Paths.setOrigin(LookupRec);
2555 if (!LookupRec->lookupInBases(BaseMatches: BaseCallback, Paths))
2556 return false;
2557
2558 R.setNamingClass(LookupRec);
2559
2560 // C++ [class.member.lookup]p2:
2561 // [...] If the resulting set of declarations are not all from
2562 // sub-objects of the same type, or the set has a nonstatic member
2563 // and includes members from distinct sub-objects, there is an
2564 // ambiguity and the program is ill-formed. Otherwise that set is
2565 // the result of the lookup.
2566 QualType SubobjectType;
2567 int SubobjectNumber = 0;
2568 AccessSpecifier SubobjectAccess = AS_none;
2569
2570 // Check whether the given lookup result contains only static members.
2571 auto HasOnlyStaticMembers = [&](DeclContext::lookup_iterator Result) {
2572 for (DeclContext::lookup_iterator I = Result, E = I.end(); I != E; ++I)
2573 if ((*I)->isInIdentifierNamespace(NS: IDNS) && (*I)->isCXXInstanceMember())
2574 return false;
2575 return true;
2576 };
2577
2578 bool TemplateNameLookup = R.isTemplateNameLookup();
2579
2580 // Determine whether two sets of members contain the same members, as
2581 // required by C++ [class.member.lookup]p6.
2582 auto HasSameDeclarations = [&](DeclContext::lookup_iterator A,
2583 DeclContext::lookup_iterator B) {
2584 using Iterator = DeclContextLookupResult::iterator;
2585 using Result = const void *;
2586
2587 auto Next = [&](Iterator &It, Iterator End) -> Result {
2588 while (It != End) {
2589 NamedDecl *ND = *It++;
2590 if (!ND->isInIdentifierNamespace(NS: IDNS))
2591 continue;
2592
2593 // C++ [temp.local]p3:
2594 // A lookup that finds an injected-class-name (10.2) can result in
2595 // an ambiguity in certain cases (for example, if it is found in
2596 // more than one base class). If all of the injected-class-names
2597 // that are found refer to specializations of the same class
2598 // template, and if the name is used as a template-name, the
2599 // reference refers to the class template itself and not a
2600 // specialization thereof, and is not ambiguous.
2601 if (TemplateNameLookup)
2602 if (auto *TD = getAsTemplateNameDecl(D: ND))
2603 ND = TD;
2604
2605 // C++ [class.member.lookup]p3:
2606 // type declarations (including injected-class-names) are replaced by
2607 // the types they designate
2608 if (const TypeDecl *TD = dyn_cast<TypeDecl>(Val: ND->getUnderlyingDecl()))
2609 return Context.getCanonicalTypeDeclType(TD).getAsOpaquePtr();
2610
2611 return ND->getUnderlyingDecl()->getCanonicalDecl();
2612 }
2613 return nullptr;
2614 };
2615
2616 // We'll often find the declarations are in the same order. Handle this
2617 // case (and the special case of only one declaration) efficiently.
2618 Iterator AIt = A, BIt = B, AEnd, BEnd;
2619 while (true) {
2620 Result AResult = Next(AIt, AEnd);
2621 Result BResult = Next(BIt, BEnd);
2622 if (!AResult && !BResult)
2623 return true;
2624 if (!AResult || !BResult)
2625 return false;
2626 if (AResult != BResult) {
2627 // Found a mismatch; carefully check both lists, accounting for the
2628 // possibility of declarations appearing more than once.
2629 llvm::SmallDenseMap<Result, bool, 32> AResults;
2630 for (; AResult; AResult = Next(AIt, AEnd))
2631 AResults.insert(KV: {AResult, /*FoundInB*/false});
2632 unsigned Found = 0;
2633 for (; BResult; BResult = Next(BIt, BEnd)) {
2634 auto It = AResults.find(Val: BResult);
2635 if (It == AResults.end())
2636 return false;
2637 if (!It->second) {
2638 It->second = true;
2639 ++Found;
2640 }
2641 }
2642 return AResults.size() == Found;
2643 }
2644 }
2645 };
2646
2647 for (CXXBasePaths::paths_iterator Path = Paths.begin(), PathEnd = Paths.end();
2648 Path != PathEnd; ++Path) {
2649 const CXXBasePathElement &PathElement = Path->back();
2650
2651 // Pick the best (i.e. most permissive i.e. numerically lowest) access
2652 // across all paths.
2653 SubobjectAccess = std::min(a: SubobjectAccess, b: Path->Access);
2654
2655 // Determine whether we're looking at a distinct sub-object or not.
2656 if (SubobjectType.isNull()) {
2657 // This is the first subobject we've looked at. Record its type.
2658 SubobjectType = Context.getCanonicalType(T: PathElement.Base->getType());
2659 SubobjectNumber = PathElement.SubobjectNumber;
2660 continue;
2661 }
2662
2663 if (SubobjectType !=
2664 Context.getCanonicalType(T: PathElement.Base->getType())) {
2665 // We found members of the given name in two subobjects of
2666 // different types. If the declaration sets aren't the same, this
2667 // lookup is ambiguous.
2668 //
2669 // FIXME: The language rule says that this applies irrespective of
2670 // whether the sets contain only static members.
2671 if (HasOnlyStaticMembers(Path->Decls) &&
2672 HasSameDeclarations(Paths.begin()->Decls, Path->Decls))
2673 continue;
2674
2675 R.setAmbiguousBaseSubobjectTypes(Paths);
2676 return true;
2677 }
2678
2679 // FIXME: This language rule no longer exists. Checking for ambiguous base
2680 // subobjects should be done as part of formation of a class member access
2681 // expression (when converting the object parameter to the member's type).
2682 if (SubobjectNumber != PathElement.SubobjectNumber) {
2683 // We have a different subobject of the same type.
2684
2685 // C++ [class.member.lookup]p5:
2686 // A static member, a nested type or an enumerator defined in
2687 // a base class T can unambiguously be found even if an object
2688 // has more than one base class subobject of type T.
2689 if (HasOnlyStaticMembers(Path->Decls))
2690 continue;
2691
2692 // We have found a nonstatic member name in multiple, distinct
2693 // subobjects. Name lookup is ambiguous.
2694 R.setAmbiguousBaseSubobjects(Paths);
2695 return true;
2696 }
2697 }
2698
2699 // Lookup in a base class succeeded; return these results.
2700
2701 for (DeclContext::lookup_iterator I = Paths.front().Decls, E = I.end();
2702 I != E; ++I) {
2703 AccessSpecifier AS = CXXRecordDecl::MergeAccess(PathAccess: SubobjectAccess,
2704 DeclAccess: (*I)->getAccess());
2705 if (NamedDecl *ND = R.getAcceptableDecl(D: *I))
2706 R.addDecl(D: ND, AS);
2707 }
2708 R.resolveKind();
2709 return true;
2710}
2711
2712bool Sema::LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
2713 CXXScopeSpec &SS) {
2714 NestedNameSpecifier Qualifier = SS.getScopeRep();
2715 if (Qualifier.getKind() == NestedNameSpecifier::Kind::MicrosoftSuper)
2716 return LookupInSuper(R, Class: Qualifier.getAsMicrosoftSuper());
2717 return LookupQualifiedName(R, LookupCtx);
2718}
2719
2720bool Sema::LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS,
2721 QualType ObjectType, bool AllowBuiltinCreation,
2722 bool EnteringContext) {
2723 // When the scope specifier is invalid, don't even look for anything.
2724 if (SS && SS->isInvalid())
2725 return false;
2726
2727 // Determine where to perform name lookup
2728 DeclContext *DC = nullptr;
2729 bool IsDependent = false;
2730 if (!ObjectType.isNull()) {
2731 // This nested-name-specifier occurs in a member access expression, e.g.,
2732 // x->B::f, and we are looking into the type of the object.
2733 assert((!SS || SS->isEmpty()) &&
2734 "ObjectType and scope specifier cannot coexist");
2735 DC = computeDeclContext(T: ObjectType);
2736 IsDependent = !DC && ObjectType->isDependentType();
2737 assert(((!DC && ObjectType->isDependentType()) ||
2738 !ObjectType->isIncompleteType() || !ObjectType->getAs<TagType>() ||
2739 ObjectType->castAs<TagType>()->getDecl()->isEntityBeingDefined()) &&
2740 "Caller should have completed object type");
2741 } else if (SS && SS->isNotEmpty()) {
2742 // This nested-name-specifier occurs after another nested-name-specifier,
2743 // so long into the context associated with the prior nested-name-specifier.
2744 if ((DC = computeDeclContext(SS: *SS, EnteringContext))) {
2745 // The declaration context must be complete.
2746 if (!DC->isDependentContext() && RequireCompleteDeclContext(SS&: *SS, DC))
2747 return false;
2748 R.setContextRange(SS->getRange());
2749 // FIXME: '__super' lookup semantics could be implemented by a
2750 // LookupResult::isSuperLookup flag which skips the initial search of
2751 // the lookup context in LookupQualified.
2752 if (NestedNameSpecifier Qualifier = SS->getScopeRep();
2753 Qualifier.getKind() == NestedNameSpecifier::Kind::MicrosoftSuper)
2754 return LookupInSuper(R, Class: Qualifier.getAsMicrosoftSuper());
2755 }
2756 IsDependent = !DC && isDependentScopeSpecifier(SS: *SS);
2757 } else {
2758 // Perform unqualified name lookup starting in the given scope.
2759 return LookupName(R, S, AllowBuiltinCreation);
2760 }
2761
2762 // If we were able to compute a declaration context, perform qualified name
2763 // lookup in that context.
2764 if (DC)
2765 return LookupQualifiedName(R, LookupCtx: DC);
2766 else if (IsDependent)
2767 // We could not resolve the scope specified to a specific declaration
2768 // context, which means that SS refers to an unknown specialization.
2769 // Name lookup can't find anything in this case.
2770 R.setNotFoundInCurrentInstantiation();
2771 return false;
2772}
2773
2774bool Sema::LookupInSuper(LookupResult &R, CXXRecordDecl *Class) {
2775 // The access-control rules we use here are essentially the rules for
2776 // doing a lookup in Class that just magically skipped the direct
2777 // members of Class itself. That is, the naming class is Class, and the
2778 // access includes the access of the base.
2779 for (const auto &BaseSpec : Class->bases()) {
2780 auto *RD = BaseSpec.getType()->castAsCXXRecordDecl();
2781 LookupResult Result(*this, R.getLookupNameInfo(), R.getLookupKind());
2782 Result.setBaseObjectType(Context.getCanonicalTagType(TD: Class));
2783 LookupQualifiedName(R&: Result, LookupCtx: RD);
2784
2785 // Copy the lookup results into the target, merging the base's access into
2786 // the path access.
2787 for (auto I = Result.begin(), E = Result.end(); I != E; ++I) {
2788 R.addDecl(D: I.getDecl(),
2789 AS: CXXRecordDecl::MergeAccess(PathAccess: BaseSpec.getAccessSpecifier(),
2790 DeclAccess: I.getAccess()));
2791 }
2792
2793 Result.suppressDiagnostics();
2794 }
2795
2796 R.resolveKind();
2797 R.setNamingClass(Class);
2798
2799 return !R.empty();
2800}
2801
2802void Sema::DiagnoseAmbiguousLookup(LookupResult &Result) {
2803 assert(Result.isAmbiguous() && "Lookup result must be ambiguous");
2804
2805 DeclarationName Name = Result.getLookupName();
2806 SourceLocation NameLoc = Result.getNameLoc();
2807 SourceRange LookupRange = Result.getContextRange();
2808
2809 switch (Result.getAmbiguityKind()) {
2810 case LookupAmbiguityKind::AmbiguousBaseSubobjects: {
2811 CXXBasePaths *Paths = Result.getBasePaths();
2812 QualType SubobjectType = Paths->front().back().Base->getType();
2813 Diag(Loc: NameLoc, DiagID: diag::err_ambiguous_member_multiple_subobjects)
2814 << Name << SubobjectType << getAmbiguousPathsDisplayString(Paths&: *Paths)
2815 << LookupRange;
2816
2817 DeclContext::lookup_iterator Found = Paths->front().Decls;
2818 while (isa<CXXMethodDecl>(Val: *Found) &&
2819 cast<CXXMethodDecl>(Val: *Found)->isStatic())
2820 ++Found;
2821
2822 Diag(Loc: (*Found)->getLocation(), DiagID: diag::note_ambiguous_member_found);
2823 break;
2824 }
2825
2826 case LookupAmbiguityKind::AmbiguousBaseSubobjectTypes: {
2827 Diag(Loc: NameLoc, DiagID: diag::err_ambiguous_member_multiple_subobject_types)
2828 << Name << LookupRange;
2829
2830 CXXBasePaths *Paths = Result.getBasePaths();
2831 std::set<const NamedDecl *> DeclsPrinted;
2832 for (CXXBasePaths::paths_iterator Path = Paths->begin(),
2833 PathEnd = Paths->end();
2834 Path != PathEnd; ++Path) {
2835 const NamedDecl *D = *Path->Decls;
2836 if (!D->isInIdentifierNamespace(NS: Result.getIdentifierNamespace()))
2837 continue;
2838 if (DeclsPrinted.insert(x: D).second) {
2839 if (const auto *TD = dyn_cast<TypedefNameDecl>(Val: D->getUnderlyingDecl()))
2840 Diag(Loc: D->getLocation(), DiagID: diag::note_ambiguous_member_type_found)
2841 << TD->getUnderlyingType();
2842 else if (const auto *TD = dyn_cast<TypeDecl>(Val: D->getUnderlyingDecl()))
2843 Diag(Loc: D->getLocation(), DiagID: diag::note_ambiguous_member_type_found)
2844 << Context.getTypeDeclType(Decl: TD);
2845 else
2846 Diag(Loc: D->getLocation(), DiagID: diag::note_ambiguous_member_found);
2847 }
2848 }
2849 break;
2850 }
2851
2852 case LookupAmbiguityKind::AmbiguousTagHiding: {
2853 Diag(Loc: NameLoc, DiagID: diag::err_ambiguous_tag_hiding) << Name << LookupRange;
2854
2855 llvm::SmallPtrSet<NamedDecl*, 8> TagDecls;
2856
2857 for (auto *D : Result)
2858 if (TagDecl *TD = dyn_cast<TagDecl>(Val: D)) {
2859 TagDecls.insert(Ptr: TD);
2860 Diag(Loc: TD->getLocation(), DiagID: diag::note_hidden_tag);
2861 }
2862
2863 for (auto *D : Result)
2864 if (!isa<TagDecl>(Val: D))
2865 Diag(Loc: D->getLocation(), DiagID: diag::note_hiding_object);
2866
2867 // For recovery purposes, go ahead and implement the hiding.
2868 LookupResult::Filter F = Result.makeFilter();
2869 while (F.hasNext()) {
2870 if (TagDecls.count(Ptr: F.next()))
2871 F.erase();
2872 }
2873 F.done();
2874 break;
2875 }
2876
2877 case LookupAmbiguityKind::AmbiguousReferenceToPlaceholderVariable: {
2878 Diag(Loc: NameLoc, DiagID: diag::err_using_placeholder_variable) << Name << LookupRange;
2879 DeclContext *DC = nullptr;
2880 for (auto *D : Result) {
2881 Diag(Loc: D->getLocation(), DiagID: diag::note_reference_placeholder) << D;
2882 if (DC != nullptr && DC != D->getDeclContext())
2883 break;
2884 DC = D->getDeclContext();
2885 }
2886 break;
2887 }
2888
2889 case LookupAmbiguityKind::AmbiguousReference: {
2890 Diag(Loc: NameLoc, DiagID: diag::err_ambiguous_reference) << Name << LookupRange;
2891
2892 for (auto *D : Result)
2893 Diag(Loc: D->getLocation(), DiagID: diag::note_ambiguous_candidate) << D;
2894 break;
2895 }
2896 }
2897}
2898
2899namespace {
2900 struct AssociatedLookup {
2901 AssociatedLookup(Sema &S, SourceLocation InstantiationLoc,
2902 Sema::AssociatedNamespaceSet &Namespaces,
2903 Sema::AssociatedClassSet &Classes)
2904 : S(S), Namespaces(Namespaces), Classes(Classes),
2905 InstantiationLoc(InstantiationLoc) {
2906 }
2907
2908 bool addClassTransitive(CXXRecordDecl *RD) {
2909 Classes.insert(X: RD);
2910 return ClassesTransitive.insert(X: RD);
2911 }
2912
2913 // Save that `RD` is being processed, so that we don't attempt to re-visit
2914 // this multiple times. Returns 'false' if we've already visited this, and
2915 // shouldn't do so again.
2916 bool addClassVisited(CXXRecordDecl *RD) {
2917 return ClassesVisited.insert(Ptr: RD).second;
2918 }
2919
2920 // Save that `FnType` is being processed, so that we don't attempt to
2921 // re-visit this multiple times. Returns 'false' if we've already visited
2922 // this, and shouldn't do so again.
2923 bool addFunctionTypeVisited(const Type *FnType) {
2924 return FunctionTypesVisited.insert(Ptr: FnType).second;
2925 }
2926
2927 Sema &S;
2928 Sema::AssociatedNamespaceSet &Namespaces;
2929 Sema::AssociatedClassSet &Classes;
2930 SourceLocation InstantiationLoc;
2931
2932 private:
2933 Sema::AssociatedClassSet ClassesTransitive;
2934 llvm::SmallPtrSet<CXXRecordDecl *, 16> ClassesVisited;
2935 llvm::SmallPtrSet<const Type *, 16> FunctionTypesVisited;
2936 };
2937} // end anonymous namespace
2938
2939static void
2940addAssociatedClassesAndNamespaces(AssociatedLookup &Result, QualType T);
2941
2942// Given the declaration context \param Ctx of a class, class template or
2943// enumeration, add the associated namespaces to \param Namespaces as described
2944// in [basic.lookup.argdep]p2.
2945static void CollectEnclosingNamespace(Sema::AssociatedNamespaceSet &Namespaces,
2946 DeclContext *Ctx) {
2947 // The exact wording has been changed in C++14 as a result of
2948 // CWG 1691 (see also CWG 1690 and CWG 1692). We apply it unconditionally
2949 // to all language versions since it is possible to return a local type
2950 // from a lambda in C++11.
2951 //
2952 // C++14 [basic.lookup.argdep]p2:
2953 // If T is a class type [...]. Its associated namespaces are the innermost
2954 // enclosing namespaces of its associated classes. [...]
2955 //
2956 // If T is an enumeration type, its associated namespace is the innermost
2957 // enclosing namespace of its declaration. [...]
2958
2959 // We additionally skip inline namespaces. The innermost non-inline namespace
2960 // contains all names of all its nested inline namespaces anyway, so we can
2961 // replace the entire inline namespace tree with its root.
2962 while (!Ctx->isFileContext() || Ctx->isInlineNamespace())
2963 Ctx = Ctx->getParent();
2964
2965 // Actually it is fine to always do `Namespaces.insert(Ctx);` simply. But it
2966 // may cause more allocations in Namespaces and more unnecessary lookups. So
2967 // we'd like to insert the representative namespace only.
2968 DeclContext *PrimaryCtx = Ctx->getPrimaryContext();
2969 Decl *PrimaryD = cast<Decl>(Val: PrimaryCtx);
2970 Decl *D = cast<Decl>(Val: Ctx);
2971 ASTContext &AST = D->getASTContext();
2972
2973 // TODO: Technically it is better to insert one namespace per module. e.g.,
2974 //
2975 // ```
2976 // //--- first.cppm
2977 // export module first;
2978 // namespace ns { ... } // first namespace
2979 //
2980 // //--- m-partA.cppm
2981 // export module m:partA;
2982 // import first;
2983 //
2984 // namespace ns { ... }
2985 // namespace ns { ... }
2986 //
2987 // //--- m-partB.cppm
2988 // export module m:partB;
2989 // import first;
2990 // import :partA;
2991 //
2992 // namespace ns { ... }
2993 // namespace ns { ... }
2994 //
2995 // ...
2996 //
2997 // //--- m-partN.cppm
2998 // export module m:partN;
2999 // import first;
3000 // import :partA;
3001 // ...
3002 // import :part$(N-1);
3003 //
3004 // namespace ns { ... }
3005 // namespace ns { ... }
3006 //
3007 // consume(ns::any_decl); // the lookup
3008 // ```
3009 //
3010 // We should only insert once for all namespaces in module m.
3011 if (D->isInNamedModule() &&
3012 !AST.isInSameModule(M1: D->getOwningModule(), M2: PrimaryD->getOwningModule()))
3013 Namespaces.insert(X: Ctx);
3014 else
3015 Namespaces.insert(X: PrimaryCtx);
3016}
3017
3018// Add the associated classes and namespaces for argument-dependent
3019// lookup that involves a template argument (C++ [basic.lookup.argdep]p2).
3020static void
3021addAssociatedClassesAndNamespaces(AssociatedLookup &Result,
3022 const TemplateArgument &Arg) {
3023 // C++ [basic.lookup.argdep]p2, last bullet:
3024 // -- [...] ;
3025 switch (Arg.getKind()) {
3026 case TemplateArgument::Null:
3027 break;
3028
3029 case TemplateArgument::Type:
3030 // [...] the namespaces and classes associated with the types of the
3031 // template arguments provided for template type parameters (excluding
3032 // template template parameters)
3033 addAssociatedClassesAndNamespaces(Result, T: Arg.getAsType());
3034 break;
3035
3036 case TemplateArgument::Template:
3037 case TemplateArgument::TemplateExpansion: {
3038 // [...] the namespaces in which any template template arguments are
3039 // defined; and the classes in which any member templates used as
3040 // template template arguments are defined.
3041 TemplateName Template = Arg.getAsTemplateOrTemplatePattern();
3042 if (ClassTemplateDecl *ClassTemplate
3043 = dyn_cast<ClassTemplateDecl>(Val: Template.getAsTemplateDecl())) {
3044 DeclContext *Ctx = ClassTemplate->getDeclContext();
3045 if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Val: Ctx))
3046 Result.Classes.insert(X: EnclosingClass);
3047 // Add the associated namespace for this class.
3048 CollectEnclosingNamespace(Namespaces&: Result.Namespaces, Ctx);
3049 }
3050 break;
3051 }
3052
3053 case TemplateArgument::Declaration:
3054 case TemplateArgument::Integral:
3055 case TemplateArgument::Expression:
3056 case TemplateArgument::NullPtr:
3057 case TemplateArgument::StructuralValue:
3058 // [Note: non-type template arguments do not contribute to the set of
3059 // associated namespaces. ]
3060 break;
3061
3062 case TemplateArgument::Pack:
3063 for (const auto &P : Arg.pack_elements())
3064 addAssociatedClassesAndNamespaces(Result, Arg: P);
3065 break;
3066 }
3067}
3068
3069// Add the associated classes and namespaces for argument-dependent lookup
3070// with an argument of class type (C++ [basic.lookup.argdep]p2).
3071static void
3072addAssociatedClassesAndNamespaces(AssociatedLookup &Result,
3073 CXXRecordDecl *Class) {
3074
3075 // Just silently ignore anything whose name is __va_list_tag.
3076 if (Class->getDeclName() == Result.S.VAListTagName)
3077 return;
3078
3079 // Don't revisit a type if we've already seen it.
3080 if (!Result.addClassVisited(RD: Class))
3081 return;
3082
3083 // C++ [basic.lookup.argdep]p2:
3084 // [...]
3085 // -- If T is a class type (including unions), its associated
3086 // classes are: the class itself; the class of which it is a
3087 // member, if any; and its direct and indirect base classes.
3088 // Its associated namespaces are the innermost enclosing
3089 // namespaces of its associated classes.
3090
3091 // Add the class of which it is a member, if any.
3092 DeclContext *Ctx = Class->getDeclContext();
3093 if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Val: Ctx))
3094 Result.Classes.insert(X: EnclosingClass);
3095
3096 // Add the associated namespace for this class.
3097 CollectEnclosingNamespace(Namespaces&: Result.Namespaces, Ctx);
3098
3099 // -- If T is a template-id, its associated namespaces and classes are
3100 // the namespace in which the template is defined; for member
3101 // templates, the member template's class; the namespaces and classes
3102 // associated with the types of the template arguments provided for
3103 // template type parameters (excluding template template parameters); the
3104 // namespaces in which any template template arguments are defined; and
3105 // the classes in which any member templates used as template template
3106 // arguments are defined. [Note: non-type template arguments do not
3107 // contribute to the set of associated namespaces. ]
3108 if (ClassTemplateSpecializationDecl *Spec
3109 = dyn_cast<ClassTemplateSpecializationDecl>(Val: Class)) {
3110 DeclContext *Ctx = Spec->getSpecializedTemplate()->getDeclContext();
3111 if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Val: Ctx))
3112 Result.Classes.insert(X: EnclosingClass);
3113 // Add the associated namespace for this class.
3114 CollectEnclosingNamespace(Namespaces&: Result.Namespaces, Ctx);
3115
3116 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
3117 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
3118 addAssociatedClassesAndNamespaces(Result, Arg: TemplateArgs[I]);
3119 }
3120
3121 // Add the class itself. If we've already transitively visited this class,
3122 // we don't need to visit base classes.
3123 if (!Result.addClassTransitive(RD: Class))
3124 return;
3125
3126 // Only recurse into base classes for complete types.
3127 if (!Result.S.isCompleteType(Loc: Result.InstantiationLoc,
3128 T: Result.S.Context.getCanonicalTagType(TD: Class)))
3129 return;
3130
3131 // Add direct and indirect base classes along with their associated
3132 // namespaces.
3133 SmallVector<CXXRecordDecl *, 32> Bases;
3134 Bases.push_back(Elt: Class);
3135 while (!Bases.empty()) {
3136 // Pop this class off the stack.
3137 Class = Bases.pop_back_val();
3138
3139 // Visit the base classes.
3140 for (const auto &Base : Class->bases()) {
3141 CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
3142 // In dependent contexts, we do ADL twice, and the first time around,
3143 // the base type might be a dependent TemplateSpecializationType, or a
3144 // TemplateTypeParmType. If that happens, simply ignore it.
3145 // FIXME: If we want to support export, we probably need to add the
3146 // namespace of the template in a TemplateSpecializationType, or even
3147 // the classes and namespaces of known non-dependent arguments.
3148 if (!BaseDecl)
3149 continue;
3150 if (Result.addClassTransitive(RD: BaseDecl)) {
3151 // Find the associated namespace for this base class.
3152 DeclContext *BaseCtx = BaseDecl->getDeclContext();
3153 CollectEnclosingNamespace(Namespaces&: Result.Namespaces, Ctx: BaseCtx);
3154
3155 // Make sure we visit the bases of this base class.
3156 if (!BaseDecl->bases().empty())
3157 Bases.push_back(Elt: BaseDecl);
3158 }
3159 }
3160 }
3161}
3162
3163// Add the associated classes and namespaces for
3164// argument-dependent lookup with an argument of type T
3165// (C++ [basic.lookup.koenig]p2).
3166static void
3167addAssociatedClassesAndNamespaces(AssociatedLookup &Result, QualType Ty) {
3168 // C++ [basic.lookup.koenig]p2:
3169 //
3170 // For each argument type T in the function call, there is a set
3171 // of zero or more associated namespaces and a set of zero or more
3172 // associated classes to be considered. The sets of namespaces and
3173 // classes is determined entirely by the types of the function
3174 // arguments (and the namespace of any template template
3175 // argument). Typedef names and using-declarations used to specify
3176 // the types do not contribute to this set. The sets of namespaces
3177 // and classes are determined in the following way:
3178
3179 SmallVector<const Type *, 16> Queue;
3180 const Type *T = Ty->getCanonicalTypeInternal().getTypePtr();
3181
3182 while (true) {
3183 switch (T->getTypeClass()) {
3184
3185#define TYPE(Class, Base)
3186#define DEPENDENT_TYPE(Class, Base) case Type::Class:
3187#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3188#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
3189#define ABSTRACT_TYPE(Class, Base)
3190#include "clang/AST/TypeNodes.inc"
3191 // T is canonical. We can also ignore dependent types because
3192 // we don't need to do ADL at the definition point, but if we
3193 // wanted to implement template export (or if we find some other
3194 // use for associated classes and namespaces...) this would be
3195 // wrong.
3196 break;
3197
3198 // -- If T is a pointer to U or an array of U, its associated
3199 // namespaces and classes are those associated with U.
3200 case Type::Pointer:
3201 T = cast<PointerType>(Val: T)->getPointeeType().getTypePtr();
3202 continue;
3203 case Type::ConstantArray:
3204 case Type::IncompleteArray:
3205 case Type::VariableArray:
3206 T = cast<ArrayType>(Val: T)->getElementType().getTypePtr();
3207 continue;
3208
3209 // -- If T is a fundamental type, its associated sets of
3210 // namespaces and classes are both empty.
3211 case Type::Builtin:
3212 break;
3213
3214 // -- If T is a class type (including unions), its associated
3215 // classes are: the class itself; the class of which it is
3216 // a member, if any; and its direct and indirect base classes.
3217 // Its associated namespaces are the innermost enclosing
3218 // namespaces of its associated classes.
3219 case Type::Record: {
3220 // FIXME: This should use the original decl.
3221 auto *Class = cast<CXXRecordDecl>(Val: cast<RecordType>(Val: T)->getDecl())
3222 ->getDefinitionOrSelf();
3223 addAssociatedClassesAndNamespaces(Result, Class);
3224 break;
3225 }
3226
3227 // -- If T is an enumeration type, its associated namespace
3228 // is the innermost enclosing namespace of its declaration.
3229 // If it is a class member, its associated class is the
3230 // member’s class; else it has no associated class.
3231 case Type::Enum: {
3232 // FIXME: This should use the original decl.
3233 auto *Enum = T->castAsEnumDecl();
3234
3235 DeclContext *Ctx = Enum->getDeclContext();
3236 if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Val: Ctx))
3237 Result.Classes.insert(X: EnclosingClass);
3238
3239 // Add the associated namespace for this enumeration.
3240 CollectEnclosingNamespace(Namespaces&: Result.Namespaces, Ctx);
3241
3242 break;
3243 }
3244
3245 // -- If T is a function type, its associated namespaces and
3246 // classes are those associated with the function parameter
3247 // types and those associated with the return type.
3248 case Type::FunctionProto: {
3249 // Don't revisit a type if we've already seen it.
3250 if (!Result.addFunctionTypeVisited(FnType: T))
3251 break;
3252 const FunctionProtoType *Proto = cast<FunctionProtoType>(Val: T);
3253 for (const auto &Arg : Proto->param_types())
3254 Queue.push_back(Elt: Arg.getTypePtr());
3255 // fallthrough
3256 [[fallthrough]];
3257 }
3258 case Type::FunctionNoProto: {
3259 const FunctionType *FnType = cast<FunctionType>(Val: T);
3260 T = FnType->getReturnType().getTypePtr();
3261 continue;
3262 }
3263
3264 // -- If T is a pointer to a member function of a class X, its
3265 // associated namespaces and classes are those associated
3266 // with the function parameter types and return type,
3267 // together with those associated with X.
3268 //
3269 // -- If T is a pointer to a data member of class X, its
3270 // associated namespaces and classes are those associated
3271 // with the member type together with those associated with
3272 // X.
3273 case Type::MemberPointer: {
3274 const MemberPointerType *MemberPtr = cast<MemberPointerType>(Val: T);
3275 if (CXXRecordDecl *Class = MemberPtr->getMostRecentCXXRecordDecl())
3276 addAssociatedClassesAndNamespaces(Result, Class);
3277 T = MemberPtr->getPointeeType().getTypePtr();
3278 continue;
3279 }
3280
3281 // As an extension, treat this like a normal pointer.
3282 case Type::BlockPointer:
3283 T = cast<BlockPointerType>(Val: T)->getPointeeType().getTypePtr();
3284 continue;
3285
3286 // References aren't covered by the standard, but that's such an
3287 // obvious defect that we cover them anyway.
3288 case Type::LValueReference:
3289 case Type::RValueReference:
3290 T = cast<ReferenceType>(Val: T)->getPointeeType().getTypePtr();
3291 continue;
3292
3293 // These are fundamental types.
3294 case Type::Vector:
3295 case Type::ExtVector:
3296 case Type::ConstantMatrix:
3297 case Type::Complex:
3298 case Type::BitInt:
3299 break;
3300
3301 // Non-deduced auto types only get here for error cases.
3302 case Type::Auto:
3303 case Type::DeducedTemplateSpecialization:
3304 break;
3305
3306 // If T is an Objective-C object or interface type, or a pointer to an
3307 // object or interface type, the associated namespace is the global
3308 // namespace.
3309 case Type::ObjCObject:
3310 case Type::ObjCInterface:
3311 case Type::ObjCObjectPointer:
3312 Result.Namespaces.insert(X: Result.S.Context.getTranslationUnitDecl());
3313 break;
3314
3315 // Atomic types are just wrappers; use the associations of the
3316 // contained type.
3317 case Type::Atomic:
3318 T = cast<AtomicType>(Val: T)->getValueType().getTypePtr();
3319 continue;
3320 case Type::Pipe:
3321 T = cast<PipeType>(Val: T)->getElementType().getTypePtr();
3322 continue;
3323
3324 // Array parameter types are treated as fundamental types.
3325 case Type::ArrayParameter:
3326 break;
3327
3328 case Type::HLSLAttributedResource:
3329 T = cast<HLSLAttributedResourceType>(Val: T)->getWrappedType().getTypePtr();
3330 break;
3331
3332 // Inline SPIR-V types are treated as fundamental types.
3333 case Type::HLSLInlineSpirv:
3334 break;
3335 case Type::OverflowBehavior:
3336 T = cast<OverflowBehaviorType>(Val: T)->getUnderlyingType().getTypePtr();
3337 }
3338
3339 if (Queue.empty())
3340 break;
3341 T = Queue.pop_back_val();
3342 }
3343}
3344
3345void Sema::FindAssociatedClassesAndNamespaces(
3346 SourceLocation InstantiationLoc, ArrayRef<Expr *> Args,
3347 AssociatedNamespaceSet &AssociatedNamespaces,
3348 AssociatedClassSet &AssociatedClasses) {
3349 AssociatedNamespaces.clear();
3350 AssociatedClasses.clear();
3351
3352 AssociatedLookup Result(*this, InstantiationLoc,
3353 AssociatedNamespaces, AssociatedClasses);
3354
3355 // C++ [basic.lookup.koenig]p2:
3356 // For each argument type T in the function call, there is a set
3357 // of zero or more associated namespaces and a set of zero or more
3358 // associated classes to be considered. The sets of namespaces and
3359 // classes is determined entirely by the types of the function
3360 // arguments (and the namespace of any template template
3361 // argument).
3362 for (unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {
3363 Expr *Arg = Args[ArgIdx];
3364
3365 if (Arg->getType() != Context.OverloadTy) {
3366 addAssociatedClassesAndNamespaces(Result, Ty: Arg->getType());
3367 continue;
3368 }
3369
3370 // [...] In addition, if the argument is the name or address of a
3371 // set of overloaded functions and/or function templates, its
3372 // associated classes and namespaces are the union of those
3373 // associated with each of the members of the set: the namespace
3374 // in which the function or function template is defined and the
3375 // classes and namespaces associated with its (non-dependent)
3376 // parameter types and return type.
3377 OverloadExpr *OE = OverloadExpr::find(E: Arg).Expression;
3378
3379 for (const NamedDecl *D : OE->decls()) {
3380 // Look through any using declarations to find the underlying function.
3381 const FunctionDecl *FDecl = D->getUnderlyingDecl()->getAsFunction();
3382
3383 // Add the classes and namespaces associated with the parameter
3384 // types and return type of this function.
3385 addAssociatedClassesAndNamespaces(Result, Ty: FDecl->getType());
3386 }
3387 }
3388}
3389
3390NamedDecl *Sema::LookupSingleName(Scope *S, DeclarationName Name,
3391 SourceLocation Loc,
3392 LookupNameKind NameKind,
3393 RedeclarationKind Redecl) {
3394 LookupResult R(*this, Name, Loc, NameKind, Redecl);
3395 LookupName(R, S);
3396 return R.getAsSingle<NamedDecl>();
3397}
3398
3399void Sema::LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
3400 UnresolvedSetImpl &Functions) {
3401 // C++ [over.match.oper]p3:
3402 // -- The set of non-member candidates is the result of the
3403 // unqualified lookup of operator@ in the context of the
3404 // expression according to the usual rules for name lookup in
3405 // unqualified function calls (3.4.2) except that all member
3406 // functions are ignored.
3407 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
3408 LookupResult Operators(*this, OpName, SourceLocation(), LookupOperatorName);
3409 LookupName(R&: Operators, S);
3410
3411 assert(!Operators.isAmbiguous() && "Operator lookup cannot be ambiguous");
3412 Functions.append(I: Operators.begin(), E: Operators.end());
3413}
3414
3415static Sema::SpecialMemberCacheKey
3416makeSpecialMemberCacheKey(const CXXRecordDecl *RD, CXXSpecialMemberKind SM,
3417 bool ConstArg, bool VolatileArg, bool RValueThis,
3418 bool ConstThis, bool VolatileThis) {
3419 unsigned Flags = llvm::to_underlying(E: SM) << 5;
3420 Flags |= ConstArg << 4;
3421 Flags |= VolatileArg << 3;
3422 Flags |= RValueThis << 2;
3423 Flags |= ConstThis << 1;
3424 Flags |= VolatileThis;
3425 return {RD, Flags};
3426}
3427
3428Sema::SpecialMemberOverloadResult
3429Sema::LookupSpecialMember(CXXRecordDecl *RD, CXXSpecialMemberKind SM,
3430 bool ConstArg, bool VolatileArg, bool RValueThis,
3431 bool ConstThis, bool VolatileThis) {
3432 assert(CanDeclareSpecialMemberFunction(RD) &&
3433 "doing special member lookup into record that isn't fully complete");
3434 RD = RD->getDefinition();
3435 if (RValueThis || ConstThis || VolatileThis)
3436 assert((SM == CXXSpecialMemberKind::CopyAssignment ||
3437 SM == CXXSpecialMemberKind::MoveAssignment) &&
3438 "constructors and destructors always have unqualified lvalue this");
3439 if (ConstArg || VolatileArg)
3440 assert((SM != CXXSpecialMemberKind::DefaultConstructor &&
3441 SM != CXXSpecialMemberKind::Destructor) &&
3442 "parameter-less special members can't have qualified arguments");
3443
3444 // FIXME: Get the caller to pass in a location for the lookup.
3445 SourceLocation LookupLoc = RD->getLocation();
3446
3447 SpecialMemberCacheKey Key = makeSpecialMemberCacheKey(
3448 RD, SM, ConstArg, VolatileArg, RValueThis, ConstThis, VolatileThis);
3449
3450 auto [It, Inserted] = SpecialMemberCache.try_emplace(Key);
3451 if (!Inserted)
3452 return It->second;
3453
3454 SpecialMemberOverloadResult Result;
3455 if (SM == CXXSpecialMemberKind::Destructor) {
3456 if (RD->needsImplicitDestructor()) {
3457 runWithSufficientStackSpace(Loc: RD->getLocation(), Fn: [&] {
3458 DeclareImplicitDestructor(ClassDecl: RD);
3459 });
3460 }
3461 CXXDestructorDecl *DD = RD->getDestructor();
3462 Result.setMethod(DD);
3463 Result.setKind(DD && !DD->isDeleted()
3464 ? SpecialMemberOverloadResult::Success
3465 : SpecialMemberOverloadResult::NoMemberOrDeleted);
3466 return SpecialMemberCache[Key] = Result;
3467 }
3468
3469 // Prepare for overload resolution. Here we construct a synthetic argument
3470 // if necessary and make sure that implicit functions are declared.
3471 CanQualType CanTy = Context.getCanonicalTagType(TD: RD);
3472 DeclarationName Name;
3473 Expr *Arg = nullptr;
3474 unsigned NumArgs;
3475
3476 QualType ArgType = CanTy;
3477 ExprValueKind VK = VK_LValue;
3478
3479 if (SM == CXXSpecialMemberKind::DefaultConstructor) {
3480 Name = Context.DeclarationNames.getCXXConstructorName(Ty: CanTy);
3481 NumArgs = 0;
3482 if (RD->needsImplicitDefaultConstructor()) {
3483 runWithSufficientStackSpace(Loc: RD->getLocation(), Fn: [&] {
3484 DeclareImplicitDefaultConstructor(ClassDecl: RD);
3485 });
3486 }
3487 } else {
3488 if (SM == CXXSpecialMemberKind::CopyConstructor ||
3489 SM == CXXSpecialMemberKind::MoveConstructor) {
3490 Name = Context.DeclarationNames.getCXXConstructorName(Ty: CanTy);
3491 if (RD->needsImplicitCopyConstructor()) {
3492 runWithSufficientStackSpace(Loc: RD->getLocation(), Fn: [&] {
3493 DeclareImplicitCopyConstructor(ClassDecl: RD);
3494 });
3495 }
3496 if (getLangOpts().CPlusPlus11 && RD->needsImplicitMoveConstructor()) {
3497 runWithSufficientStackSpace(Loc: RD->getLocation(), Fn: [&] {
3498 DeclareImplicitMoveConstructor(ClassDecl: RD);
3499 });
3500 }
3501 } else {
3502 Name = Context.DeclarationNames.getCXXOperatorName(Op: OO_Equal);
3503 if (RD->needsImplicitCopyAssignment()) {
3504 runWithSufficientStackSpace(Loc: RD->getLocation(), Fn: [&] {
3505 DeclareImplicitCopyAssignment(ClassDecl: RD);
3506 });
3507 }
3508 if (getLangOpts().CPlusPlus11 && RD->needsImplicitMoveAssignment()) {
3509 runWithSufficientStackSpace(Loc: RD->getLocation(), Fn: [&] {
3510 DeclareImplicitMoveAssignment(ClassDecl: RD);
3511 });
3512 }
3513 }
3514
3515 if (ConstArg)
3516 ArgType.addConst();
3517 if (VolatileArg)
3518 ArgType.addVolatile();
3519
3520 // This isn't /really/ specified by the standard, but it's implied
3521 // we should be working from a PRValue in the case of move to ensure
3522 // that we prefer to bind to rvalue references, and an LValue in the
3523 // case of copy to ensure we don't bind to rvalue references.
3524 // Possibly an XValue is actually correct in the case of move, but
3525 // there is no semantic difference for class types in this restricted
3526 // case.
3527 if (SM == CXXSpecialMemberKind::CopyConstructor ||
3528 SM == CXXSpecialMemberKind::CopyAssignment)
3529 VK = VK_LValue;
3530 else
3531 VK = VK_PRValue;
3532 }
3533
3534 OpaqueValueExpr FakeArg(LookupLoc, ArgType, VK);
3535
3536 if (SM != CXXSpecialMemberKind::DefaultConstructor) {
3537 NumArgs = 1;
3538 Arg = &FakeArg;
3539 }
3540
3541 // Create the object argument
3542 QualType ThisTy = CanTy;
3543 if (ConstThis)
3544 ThisTy.addConst();
3545 if (VolatileThis)
3546 ThisTy.addVolatile();
3547 Expr::Classification Classification =
3548 OpaqueValueExpr(LookupLoc, ThisTy, RValueThis ? VK_PRValue : VK_LValue)
3549 .Classify(Ctx&: Context);
3550
3551 // Now we perform lookup on the name we computed earlier and do overload
3552 // resolution. Lookup is only performed directly into the class since there
3553 // will always be a (possibly implicit) declaration to shadow any others.
3554 OverloadCandidateSet OCS(LookupLoc, OverloadCandidateSet::CSK_Normal);
3555 DeclContext::lookup_result R = RD->lookup(Name);
3556
3557 if (R.empty()) {
3558 // We might have no default constructor because we have a lambda's closure
3559 // type, rather than because there's some other declared constructor.
3560 // Every class has a copy/move constructor, copy/move assignment, and
3561 // destructor.
3562 assert(SM == CXXSpecialMemberKind::DefaultConstructor &&
3563 "lookup for a constructor or assignment operator was empty");
3564 Result.setMethod(nullptr);
3565 Result.setKind(SpecialMemberOverloadResult::NoMemberOrDeleted);
3566 return SpecialMemberCache[Key] = Result;
3567 }
3568
3569 // Copy the candidates as our processing of them may load new declarations
3570 // from an external source and invalidate lookup_result.
3571 SmallVector<NamedDecl *, 8> Candidates(R.begin(), R.end());
3572
3573 for (NamedDecl *CandDecl : Candidates) {
3574 if (CandDecl->isInvalidDecl())
3575 continue;
3576
3577 DeclAccessPair Cand = DeclAccessPair::make(D: CandDecl, AS: AS_public);
3578 auto CtorInfo = getConstructorInfo(ND: Cand);
3579 if (CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(Val: Cand->getUnderlyingDecl())) {
3580 if (SM == CXXSpecialMemberKind::CopyAssignment ||
3581 SM == CXXSpecialMemberKind::MoveAssignment)
3582 AddMethodCandidate(Method: M, FoundDecl: Cand, ActingContext: RD, ObjectType: ThisTy, ObjectClassification: Classification,
3583 Args: llvm::ArrayRef(&Arg, NumArgs), CandidateSet&: OCS, SuppressUserConversions: true);
3584 else if (CtorInfo)
3585 AddOverloadCandidate(Function: CtorInfo.Constructor, FoundDecl: CtorInfo.FoundDecl,
3586 Args: llvm::ArrayRef(&Arg, NumArgs), CandidateSet&: OCS,
3587 /*SuppressUserConversions*/ true);
3588 else
3589 AddOverloadCandidate(Function: M, FoundDecl: Cand, Args: llvm::ArrayRef(&Arg, NumArgs), CandidateSet&: OCS,
3590 /*SuppressUserConversions*/ true);
3591 } else if (FunctionTemplateDecl *Tmpl =
3592 dyn_cast<FunctionTemplateDecl>(Val: Cand->getUnderlyingDecl())) {
3593 if (SM == CXXSpecialMemberKind::CopyAssignment ||
3594 SM == CXXSpecialMemberKind::MoveAssignment)
3595 AddMethodTemplateCandidate(MethodTmpl: Tmpl, FoundDecl: Cand, ActingContext: RD, ExplicitTemplateArgs: nullptr, ObjectType: ThisTy,
3596 ObjectClassification: Classification,
3597 Args: llvm::ArrayRef(&Arg, NumArgs), CandidateSet&: OCS, SuppressUserConversions: true);
3598 else if (CtorInfo)
3599 AddTemplateOverloadCandidate(FunctionTemplate: CtorInfo.ConstructorTmpl,
3600 FoundDecl: CtorInfo.FoundDecl, ExplicitTemplateArgs: nullptr,
3601 Args: llvm::ArrayRef(&Arg, NumArgs), CandidateSet&: OCS, SuppressUserConversions: true);
3602 else
3603 AddTemplateOverloadCandidate(FunctionTemplate: Tmpl, FoundDecl: Cand, ExplicitTemplateArgs: nullptr,
3604 Args: llvm::ArrayRef(&Arg, NumArgs), CandidateSet&: OCS, SuppressUserConversions: true);
3605 } else {
3606 assert(isa<UsingDecl>(Cand.getDecl()) &&
3607 "illegal Kind of operator = Decl");
3608 }
3609 }
3610
3611 OverloadCandidateSet::iterator Best;
3612 switch (OCS.BestViableFunction(S&: *this, Loc: LookupLoc, Best)) {
3613 case OR_Success:
3614 Result.setMethod(cast<CXXMethodDecl>(Val: Best->Function));
3615 Result.setKind(SpecialMemberOverloadResult::Success);
3616 break;
3617
3618 case OR_Deleted:
3619 Result.setMethod(cast<CXXMethodDecl>(Val: Best->Function));
3620 Result.setKind(SpecialMemberOverloadResult::NoMemberOrDeleted);
3621 break;
3622
3623 case OR_Ambiguous:
3624 Result.setMethod(nullptr);
3625 Result.setKind(SpecialMemberOverloadResult::Ambiguous);
3626 break;
3627
3628 case OR_No_Viable_Function:
3629 Result.setMethod(nullptr);
3630 Result.setKind(SpecialMemberOverloadResult::NoMemberOrDeleted);
3631 break;
3632 }
3633
3634 return SpecialMemberCache[Key] = Result;
3635}
3636
3637CXXConstructorDecl *Sema::LookupDefaultConstructor(CXXRecordDecl *Class) {
3638 SpecialMemberOverloadResult Result =
3639 LookupSpecialMember(RD: Class, SM: CXXSpecialMemberKind::DefaultConstructor,
3640 ConstArg: false, VolatileArg: false, RValueThis: false, ConstThis: false, VolatileThis: false);
3641
3642 return cast_or_null<CXXConstructorDecl>(Val: Result.getMethod());
3643}
3644
3645CXXConstructorDecl *Sema::LookupCopyingConstructor(CXXRecordDecl *Class,
3646 unsigned Quals) {
3647 assert(!(Quals & ~(Qualifiers::Const | Qualifiers::Volatile)) &&
3648 "non-const, non-volatile qualifiers for copy ctor arg");
3649 SpecialMemberOverloadResult Result = LookupSpecialMember(
3650 RD: Class, SM: CXXSpecialMemberKind::CopyConstructor, ConstArg: Quals & Qualifiers::Const,
3651 VolatileArg: Quals & Qualifiers::Volatile, RValueThis: false, ConstThis: false, VolatileThis: false);
3652
3653 return cast_or_null<CXXConstructorDecl>(Val: Result.getMethod());
3654}
3655
3656CXXConstructorDecl *Sema::LookupMovingConstructor(CXXRecordDecl *Class,
3657 unsigned Quals) {
3658 SpecialMemberOverloadResult Result = LookupSpecialMember(
3659 RD: Class, SM: CXXSpecialMemberKind::MoveConstructor, ConstArg: Quals & Qualifiers::Const,
3660 VolatileArg: Quals & Qualifiers::Volatile, RValueThis: false, ConstThis: false, VolatileThis: false);
3661
3662 return cast_or_null<CXXConstructorDecl>(Val: Result.getMethod());
3663}
3664
3665DeclContext::lookup_result Sema::LookupConstructors(CXXRecordDecl *Class) {
3666 // If the implicit constructors have not yet been declared, do so now.
3667 if (CanDeclareSpecialMemberFunction(Class)) {
3668 runWithSufficientStackSpace(Loc: Class->getLocation(), Fn: [&] {
3669 if (Class->needsImplicitDefaultConstructor())
3670 DeclareImplicitDefaultConstructor(ClassDecl: Class);
3671 if (Class->needsImplicitCopyConstructor())
3672 DeclareImplicitCopyConstructor(ClassDecl: Class);
3673 if (getLangOpts().CPlusPlus11 && Class->needsImplicitMoveConstructor())
3674 DeclareImplicitMoveConstructor(ClassDecl: Class);
3675 });
3676 }
3677
3678 CanQualType T = Context.getCanonicalTagType(TD: Class);
3679 DeclarationName Name = Context.DeclarationNames.getCXXConstructorName(Ty: T);
3680 return Class->lookup(Name);
3681}
3682
3683CXXMethodDecl *Sema::LookupCopyingAssignment(CXXRecordDecl *Class,
3684 unsigned Quals, bool RValueThis,
3685 unsigned ThisQuals) {
3686 assert(!(Quals & ~(Qualifiers::Const | Qualifiers::Volatile)) &&
3687 "non-const, non-volatile qualifiers for copy assignment arg");
3688 assert(!(ThisQuals & ~(Qualifiers::Const | Qualifiers::Volatile)) &&
3689 "non-const, non-volatile qualifiers for copy assignment this");
3690 SpecialMemberOverloadResult Result = LookupSpecialMember(
3691 RD: Class, SM: CXXSpecialMemberKind::CopyAssignment, ConstArg: Quals & Qualifiers::Const,
3692 VolatileArg: Quals & Qualifiers::Volatile, RValueThis, ConstThis: ThisQuals & Qualifiers::Const,
3693 VolatileThis: ThisQuals & Qualifiers::Volatile);
3694
3695 return Result.getMethod();
3696}
3697
3698CXXMethodDecl *Sema::LookupMovingAssignment(CXXRecordDecl *Class,
3699 unsigned Quals,
3700 bool RValueThis,
3701 unsigned ThisQuals) {
3702 assert(!(ThisQuals & ~(Qualifiers::Const | Qualifiers::Volatile)) &&
3703 "non-const, non-volatile qualifiers for copy assignment this");
3704 SpecialMemberOverloadResult Result = LookupSpecialMember(
3705 RD: Class, SM: CXXSpecialMemberKind::MoveAssignment, ConstArg: Quals & Qualifiers::Const,
3706 VolatileArg: Quals & Qualifiers::Volatile, RValueThis, ConstThis: ThisQuals & Qualifiers::Const,
3707 VolatileThis: ThisQuals & Qualifiers::Volatile);
3708
3709 return Result.getMethod();
3710}
3711
3712CXXDestructorDecl *Sema::LookupDestructor(CXXRecordDecl *Class) {
3713 return cast_or_null<CXXDestructorDecl>(
3714 Val: LookupSpecialMember(RD: Class, SM: CXXSpecialMemberKind::Destructor, ConstArg: false, VolatileArg: false,
3715 RValueThis: false, ConstThis: false, VolatileThis: false)
3716 .getMethod());
3717}
3718
3719Sema::LiteralOperatorLookupResult
3720Sema::LookupLiteralOperator(Scope *S, LookupResult &R,
3721 ArrayRef<QualType> ArgTys, bool AllowRaw,
3722 bool AllowTemplate, bool AllowStringTemplatePack,
3723 bool DiagnoseMissing, StringLiteral *StringLit) {
3724 LookupName(R, S);
3725 assert(R.getResultKind() != LookupResultKind::Ambiguous &&
3726 "literal operator lookup can't be ambiguous");
3727
3728 // Filter the lookup results appropriately.
3729 LookupResult::Filter F = R.makeFilter();
3730
3731 bool AllowCooked = true;
3732 bool FoundRaw = false;
3733 bool FoundTemplate = false;
3734 bool FoundStringTemplatePack = false;
3735 bool FoundCooked = false;
3736
3737 while (F.hasNext()) {
3738 Decl *D = F.next();
3739 if (UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(Val: D))
3740 D = USD->getTargetDecl();
3741
3742 // If the declaration we found is invalid, skip it.
3743 if (D->isInvalidDecl()) {
3744 F.erase();
3745 continue;
3746 }
3747
3748 bool IsRaw = false;
3749 bool IsTemplate = false;
3750 bool IsStringTemplatePack = false;
3751 bool IsCooked = false;
3752
3753 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Val: D)) {
3754 if (FD->getNumParams() == 1 &&
3755 FD->getParamDecl(i: 0)->getType()->getAs<PointerType>())
3756 IsRaw = true;
3757 else if (FD->getNumParams() == ArgTys.size()) {
3758 IsCooked = true;
3759 for (unsigned ArgIdx = 0; ArgIdx != ArgTys.size(); ++ArgIdx) {
3760 QualType ParamTy = FD->getParamDecl(i: ArgIdx)->getType();
3761 if (!Context.hasSameUnqualifiedType(T1: ArgTys[ArgIdx], T2: ParamTy)) {
3762 IsCooked = false;
3763 break;
3764 }
3765 }
3766 }
3767 }
3768 if (FunctionTemplateDecl *FD = dyn_cast<FunctionTemplateDecl>(Val: D)) {
3769 TemplateParameterList *Params = FD->getTemplateParameters();
3770 if (Params->size() == 1) {
3771 IsTemplate = true;
3772 if (!Params->getParam(Idx: 0)->isTemplateParameterPack() && !StringLit) {
3773 // Implied but not stated: user-defined integer and floating literals
3774 // only ever use numeric literal operator templates, not templates
3775 // taking a parameter of class type.
3776 F.erase();
3777 continue;
3778 }
3779
3780 // A string literal template is only considered if the string literal
3781 // is a well-formed template argument for the template parameter.
3782 if (StringLit) {
3783 SFINAETrap Trap(*this);
3784 CheckTemplateArgumentInfo CTAI;
3785 TemplateArgumentLoc Arg(
3786 TemplateArgument(StringLit, /*IsCanonical=*/false), StringLit);
3787 if (CheckTemplateArgument(
3788 Param: Params->getParam(Idx: 0), Arg, Template: FD, TemplateLoc: R.getNameLoc(), RAngleLoc: R.getNameLoc(),
3789 /*ArgumentPackIndex=*/0, CTAI, CTAK: CTAK_Specified) ||
3790 Trap.hasErrorOccurred())
3791 IsTemplate = false;
3792 }
3793 } else {
3794 IsStringTemplatePack = true;
3795 }
3796 }
3797
3798 if (AllowTemplate && StringLit && IsTemplate) {
3799 FoundTemplate = true;
3800 AllowRaw = false;
3801 AllowCooked = false;
3802 AllowStringTemplatePack = false;
3803 if (FoundRaw || FoundCooked || FoundStringTemplatePack) {
3804 F.restart();
3805 FoundRaw = FoundCooked = FoundStringTemplatePack = false;
3806 }
3807 } else if (AllowCooked && IsCooked) {
3808 FoundCooked = true;
3809 AllowRaw = false;
3810 AllowTemplate = StringLit;
3811 AllowStringTemplatePack = false;
3812 if (FoundRaw || FoundTemplate || FoundStringTemplatePack) {
3813 // Go through again and remove the raw and template decls we've
3814 // already found.
3815 F.restart();
3816 FoundRaw = FoundTemplate = FoundStringTemplatePack = false;
3817 }
3818 } else if (AllowRaw && IsRaw) {
3819 FoundRaw = true;
3820 } else if (AllowTemplate && IsTemplate) {
3821 FoundTemplate = true;
3822 } else if (AllowStringTemplatePack && IsStringTemplatePack) {
3823 FoundStringTemplatePack = true;
3824 } else {
3825 F.erase();
3826 }
3827 }
3828
3829 F.done();
3830
3831 // Per C++20 [lex.ext]p5, we prefer the template form over the non-template
3832 // form for string literal operator templates.
3833 if (StringLit && FoundTemplate)
3834 return LOLR_Template;
3835
3836 // C++11 [lex.ext]p3, p4: If S contains a literal operator with a matching
3837 // parameter type, that is used in preference to a raw literal operator
3838 // or literal operator template.
3839 if (FoundCooked)
3840 return LOLR_Cooked;
3841
3842 // C++11 [lex.ext]p3, p4: S shall contain a raw literal operator or a literal
3843 // operator template, but not both.
3844 if (FoundRaw && FoundTemplate) {
3845 Diag(Loc: R.getNameLoc(), DiagID: diag::err_ovl_ambiguous_call) << R.getLookupName();
3846 for (const NamedDecl *D : R)
3847 NoteOverloadCandidate(Found: D, Fn: D->getUnderlyingDecl()->getAsFunction());
3848 return LOLR_Error;
3849 }
3850
3851 if (FoundRaw)
3852 return LOLR_Raw;
3853
3854 if (FoundTemplate)
3855 return LOLR_Template;
3856
3857 if (FoundStringTemplatePack)
3858 return LOLR_StringTemplatePack;
3859
3860 // Didn't find anything we could use.
3861 if (DiagnoseMissing) {
3862 Diag(Loc: R.getNameLoc(), DiagID: diag::err_ovl_no_viable_literal_operator)
3863 << R.getLookupName() << (int)ArgTys.size() << ArgTys[0]
3864 << (ArgTys.size() == 2 ? ArgTys[1] : QualType()) << AllowRaw
3865 << (AllowTemplate || AllowStringTemplatePack);
3866 return LOLR_Error;
3867 }
3868
3869 return LOLR_ErrorNoDiagnostic;
3870}
3871
3872void ADLResult::insert(NamedDecl *New) {
3873 NamedDecl *&Old = Decls[cast<NamedDecl>(Val: New->getCanonicalDecl())];
3874
3875 // If we haven't yet seen a decl for this key, or the last decl
3876 // was exactly this one, we're done.
3877 if (Old == nullptr || Old == New) {
3878 Old = New;
3879 return;
3880 }
3881
3882 // Otherwise, decide which is a more recent redeclaration.
3883 FunctionDecl *OldFD = Old->getAsFunction();
3884 FunctionDecl *NewFD = New->getAsFunction();
3885
3886 FunctionDecl *Cursor = NewFD;
3887 while (true) {
3888 Cursor = Cursor->getPreviousDecl();
3889
3890 // If we got to the end without finding OldFD, OldFD is the newer
3891 // declaration; leave things as they are.
3892 if (!Cursor) return;
3893
3894 // If we do find OldFD, then NewFD is newer.
3895 if (Cursor == OldFD) break;
3896
3897 // Otherwise, keep looking.
3898 }
3899
3900 Old = New;
3901}
3902
3903void Sema::ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc,
3904 ArrayRef<Expr *> Args, ADLResult &Result) {
3905 // Find all of the associated namespaces and classes based on the
3906 // arguments we have.
3907 AssociatedNamespaceSet AssociatedNamespaces;
3908 AssociatedClassSet AssociatedClasses;
3909 FindAssociatedClassesAndNamespaces(InstantiationLoc: Loc, Args,
3910 AssociatedNamespaces,
3911 AssociatedClasses);
3912
3913 // Load the friend classes in case there are unloaded decls.
3914 //
3915 // FIXME: Currently this is inefficient if there are a lot of friends
3916 // in the classes. We just expect the number of friends are limited
3917 // in real world. In case we meet the case that the loading friends
3918 // became a threshold, we can change the structure of friends from
3919 // a list to a name lookup table.
3920 for (CXXRecordDecl *Class : AssociatedClasses)
3921 if (Class->hasDefinition() && Class->hasLazyFriends())
3922 Class->loadLazyFriends();
3923
3924 // C++ [basic.lookup.argdep]p3:
3925 // Let X be the lookup set produced by unqualified lookup (3.4.1)
3926 // and let Y be the lookup set produced by argument dependent
3927 // lookup (defined as follows). If X contains [...] then Y is
3928 // empty. Otherwise Y is the set of declarations found in the
3929 // namespaces associated with the argument types as described
3930 // below. The set of declarations found by the lookup of the name
3931 // is the union of X and Y.
3932 //
3933 // Here, we compute Y and add its members to the overloaded
3934 // candidate set.
3935 for (auto *NS : AssociatedNamespaces) {
3936 // When considering an associated namespace, the lookup is the
3937 // same as the lookup performed when the associated namespace is
3938 // used as a qualifier (3.4.3.2) except that:
3939 //
3940 // -- Any using-directives in the associated namespace are
3941 // ignored.
3942 //
3943 // -- Any namespace-scope friend functions declared in
3944 // associated classes are visible within their respective
3945 // namespaces even if they are not visible during an ordinary
3946 // lookup (11.4).
3947 //
3948 // C++20 [basic.lookup.argdep] p4.3
3949 // -- are exported, are attached to a named module M, do not appear
3950 // in the translation unit containing the point of the lookup, and
3951 // have the same innermost enclosing non-inline namespace scope as
3952 // a declaration of an associated entity attached to M.
3953 DeclContext::lookup_result R = NS->lookup(Name);
3954 for (auto *D : R) {
3955 auto *Underlying = D;
3956 if (auto *USD = dyn_cast<UsingShadowDecl>(Val: D))
3957 Underlying = USD->getTargetDecl();
3958
3959 if (!isa<FunctionDecl>(Val: Underlying) &&
3960 !isa<FunctionTemplateDecl>(Val: Underlying))
3961 continue;
3962
3963 // The declaration is visible to argument-dependent lookup if either
3964 // it's ordinarily visible or declared as a friend in an associated
3965 // class.
3966 bool Visible = false;
3967 for (D = D->getMostRecentDecl(); D;
3968 D = cast_or_null<NamedDecl>(Val: D->getPreviousDecl())) {
3969 if (D->getIdentifierNamespace() & Decl::IDNS_Ordinary) {
3970 if (isVisible(D)) {
3971 Visible = true;
3972 break;
3973 }
3974
3975 if (!D->getOwningModule() ||
3976 !D->getOwningModule()->getTopLevelModule()->isNamedModule())
3977 continue;
3978
3979 if (D->isInExportDeclContext()) {
3980 Module *FM = D->getOwningModule();
3981 // C++20 [basic.lookup.argdep] p4.3 .. are exported ...
3982 // exports are only valid in module purview and outside of any
3983 // PMF (although a PMF should not even be present in a module
3984 // with an import).
3985 assert(FM &&
3986 (FM->isNamedModule() || FM->isImplicitGlobalModule()) &&
3987 !FM->isPrivateModule() && "bad export context");
3988 // .. are attached to a named module M, do not appear in the
3989 // translation unit containing the point of the lookup..
3990 if (D->isInAnotherModuleUnit() &&
3991 llvm::any_of(Range&: AssociatedClasses, P: [&](auto *E) {
3992 // ... and have the same innermost enclosing non-inline
3993 // namespace scope as a declaration of an associated entity
3994 // attached to M
3995 if (E->getOwningModule() != FM)
3996 return false;
3997 // TODO: maybe this could be cached when generating the
3998 // associated namespaces / entities.
3999 DeclContext *Ctx = E->getDeclContext();
4000 while (!Ctx->isFileContext() || Ctx->isInlineNamespace())
4001 Ctx = Ctx->getParent();
4002 return Ctx == NS;
4003 })) {
4004 Visible = true;
4005 break;
4006 }
4007 }
4008 }
4009
4010 if (D->getFriendObjectKind()) {
4011 auto *RD = cast<CXXRecordDecl>(Val: D->getLexicalDeclContext());
4012 // [basic.lookup.argdep]p4:
4013 // Argument-dependent lookup finds all declarations of functions and
4014 // function templates that
4015 // - ...
4016 // - are declared as a friend ([class.friend]) of any class with a
4017 // reachable definition in the set of associated entities,
4018 //
4019 // FIXME: If there's a merged definition of D that is reachable, then
4020 // the friend declaration should be considered.
4021 if (AssociatedClasses.count(key: RD) && isReachable(D)) {
4022 Visible = true;
4023 break;
4024 }
4025 }
4026 }
4027
4028 // FIXME: Preserve D as the FoundDecl.
4029 if (Visible)
4030 Result.insert(New: Underlying);
4031 }
4032 }
4033}
4034
4035//----------------------------------------------------------------------------
4036// Search for all visible declarations.
4037//----------------------------------------------------------------------------
4038VisibleDeclConsumer::~VisibleDeclConsumer() { }
4039
4040bool VisibleDeclConsumer::includeHiddenDecls() const { return false; }
4041
4042namespace {
4043
4044class ShadowContextRAII;
4045
4046class VisibleDeclsRecord {
4047public:
4048 /// An entry in the shadow map, which is optimized to store a
4049 /// single declaration (the common case) but can also store a list
4050 /// of declarations.
4051 typedef llvm::TinyPtrVector<NamedDecl*> ShadowMapEntry;
4052
4053private:
4054 /// A mapping from declaration names to the declarations that have
4055 /// this name within a particular scope.
4056 typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
4057
4058 /// A list of shadow maps, which is used to model name hiding.
4059 std::list<ShadowMap> ShadowMaps;
4060
4061 /// The declaration contexts we have already visited.
4062 llvm::SmallPtrSet<DeclContext *, 8> VisitedContexts;
4063
4064 friend class ShadowContextRAII;
4065
4066public:
4067 /// Determine whether we have already visited this context
4068 /// (and, if not, note that we are going to visit that context now).
4069 bool visitedContext(DeclContext *Ctx) {
4070 return !VisitedContexts.insert(Ptr: Ctx).second;
4071 }
4072
4073 bool alreadyVisitedContext(DeclContext *Ctx) {
4074 return VisitedContexts.count(Ptr: Ctx);
4075 }
4076
4077 /// Determine whether the given declaration is hidden in the
4078 /// current scope.
4079 ///
4080 /// \returns the declaration that hides the given declaration, or
4081 /// NULL if no such declaration exists.
4082 NamedDecl *checkHidden(NamedDecl *ND);
4083
4084 /// Add a declaration to the current shadow map.
4085 void add(NamedDecl *ND) {
4086 ShadowMaps.back()[ND->getDeclName()].push_back(NewVal: ND);
4087 }
4088};
4089
4090/// RAII object that records when we've entered a shadow context.
4091class ShadowContextRAII {
4092 VisibleDeclsRecord &Visible;
4093
4094 typedef VisibleDeclsRecord::ShadowMap ShadowMap;
4095
4096public:
4097 ShadowContextRAII(VisibleDeclsRecord &Visible) : Visible(Visible) {
4098 Visible.ShadowMaps.emplace_back();
4099 }
4100
4101 ~ShadowContextRAII() {
4102 Visible.ShadowMaps.pop_back();
4103 }
4104};
4105
4106} // end anonymous namespace
4107
4108NamedDecl *VisibleDeclsRecord::checkHidden(NamedDecl *ND) {
4109 unsigned IDNS = ND->getIdentifierNamespace();
4110 std::list<ShadowMap>::reverse_iterator SM = ShadowMaps.rbegin();
4111 for (std::list<ShadowMap>::reverse_iterator SMEnd = ShadowMaps.rend();
4112 SM != SMEnd; ++SM) {
4113 ShadowMap::iterator Pos = SM->find(Val: ND->getDeclName());
4114 if (Pos == SM->end())
4115 continue;
4116
4117 for (auto *D : Pos->second) {
4118 // A tag declaration does not hide a non-tag declaration.
4119 if (D->hasTagIdentifierNamespace() &&
4120 (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary |
4121 Decl::IDNS_ObjCProtocol)))
4122 continue;
4123
4124 // Protocols are in distinct namespaces from everything else.
4125 if (((D->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol)
4126 || (IDNS & Decl::IDNS_ObjCProtocol)) &&
4127 D->getIdentifierNamespace() != IDNS)
4128 continue;
4129
4130 // Functions and function templates in the same scope overload
4131 // rather than hide. FIXME: Look for hiding based on function
4132 // signatures!
4133 if (D->getUnderlyingDecl()->isFunctionOrFunctionTemplate() &&
4134 ND->getUnderlyingDecl()->isFunctionOrFunctionTemplate() &&
4135 SM == ShadowMaps.rbegin())
4136 continue;
4137
4138 // A shadow declaration that's created by a resolved using declaration
4139 // is not hidden by the same using declaration.
4140 if (isa<UsingShadowDecl>(Val: ND) && isa<UsingDecl>(Val: D) &&
4141 cast<UsingShadowDecl>(Val: ND)->getIntroducer() == D)
4142 continue;
4143
4144 // We've found a declaration that hides this one.
4145 return D;
4146 }
4147 }
4148
4149 return nullptr;
4150}
4151
4152namespace {
4153class LookupVisibleHelper {
4154public:
4155 LookupVisibleHelper(VisibleDeclConsumer &Consumer, bool IncludeDependentBases,
4156 bool LoadExternal)
4157 : Consumer(Consumer), IncludeDependentBases(IncludeDependentBases),
4158 LoadExternal(LoadExternal) {}
4159
4160 void lookupVisibleDecls(Sema &SemaRef, Scope *S, Sema::LookupNameKind Kind,
4161 bool IncludeGlobalScope) {
4162 // Determine the set of using directives available during
4163 // unqualified name lookup.
4164 Scope *Initial = S;
4165 UnqualUsingDirectiveSet UDirs(SemaRef);
4166 if (SemaRef.getLangOpts().CPlusPlus) {
4167 // Find the first namespace or translation-unit scope.
4168 while (S && !isNamespaceOrTranslationUnitScope(S))
4169 S = S->getParent();
4170
4171 UDirs.visitScopeChain(S: Initial, InnermostFileScope: S);
4172 }
4173 UDirs.done();
4174
4175 // Look for visible declarations.
4176 LookupResult Result(SemaRef, DeclarationName(), SourceLocation(), Kind);
4177 Result.setAllowHidden(Consumer.includeHiddenDecls());
4178 if (!IncludeGlobalScope)
4179 Visited.visitedContext(Ctx: SemaRef.getASTContext().getTranslationUnitDecl());
4180 ShadowContextRAII Shadow(Visited);
4181 lookupInScope(S: Initial, Result, UDirs);
4182 }
4183
4184 void lookupVisibleDecls(Sema &SemaRef, DeclContext *Ctx,
4185 Sema::LookupNameKind Kind, bool IncludeGlobalScope) {
4186 LookupResult Result(SemaRef, DeclarationName(), SourceLocation(), Kind);
4187 Result.setAllowHidden(Consumer.includeHiddenDecls());
4188 if (!IncludeGlobalScope)
4189 Visited.visitedContext(Ctx: SemaRef.getASTContext().getTranslationUnitDecl());
4190
4191 ShadowContextRAII Shadow(Visited);
4192 lookupInDeclContext(Ctx, Result, /*QualifiedNameLookup=*/true,
4193 /*InBaseClass=*/false);
4194 }
4195
4196private:
4197 void lookupInDeclContext(DeclContext *Ctx, LookupResult &Result,
4198 bool QualifiedNameLookup, bool InBaseClass) {
4199 if (!Ctx)
4200 return;
4201
4202 // Make sure we don't visit the same context twice.
4203 if (Visited.visitedContext(Ctx: Ctx->getPrimaryContext()))
4204 return;
4205
4206 Consumer.EnteredContext(Ctx);
4207
4208 // Outside C++, lookup results for the TU live on identifiers.
4209 if (isa<TranslationUnitDecl>(Val: Ctx) &&
4210 !Result.getSema().getLangOpts().CPlusPlus) {
4211 auto &S = Result.getSema();
4212 auto &Idents = S.Context.Idents;
4213
4214 // Ensure all external identifiers are in the identifier table.
4215 if (LoadExternal)
4216 if (IdentifierInfoLookup *External =
4217 Idents.getExternalIdentifierLookup()) {
4218 std::unique_ptr<IdentifierIterator> Iter(External->getIdentifiers());
4219 for (StringRef Name = Iter->Next(); !Name.empty();
4220 Name = Iter->Next())
4221 Idents.get(Name);
4222 }
4223
4224 // Walk all lookup results in the TU for each identifier.
4225 for (const auto &Ident : Idents) {
4226 for (auto I = S.IdResolver.begin(Name: Ident.getValue()),
4227 E = S.IdResolver.end();
4228 I != E; ++I) {
4229 if (S.IdResolver.isDeclInScope(D: *I, Ctx)) {
4230 if (NamedDecl *ND = Result.getAcceptableDecl(D: *I)) {
4231 Consumer.FoundDecl(ND, Hiding: Visited.checkHidden(ND), Ctx, InBaseClass);
4232 Visited.add(ND);
4233 }
4234 }
4235 }
4236 }
4237
4238 return;
4239 }
4240
4241 if (CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(Val: Ctx))
4242 Result.getSema().ForceDeclarationOfImplicitMembers(Class);
4243
4244 llvm::SmallVector<NamedDecl *, 4> DeclsToVisit;
4245 // We sometimes skip loading namespace-level results (they tend to be huge).
4246 bool Load = LoadExternal ||
4247 !(isa<TranslationUnitDecl>(Val: Ctx) || isa<NamespaceDecl>(Val: Ctx));
4248 // Enumerate all of the results in this context.
4249 for (DeclContextLookupResult R :
4250 Load ? Ctx->lookups()
4251 : Ctx->noload_lookups(/*PreserveInternalState=*/false))
4252 for (auto *D : R)
4253 // Rather than visit immediately, we put ND into a vector and visit
4254 // all decls, in order, outside of this loop. The reason is that
4255 // Consumer.FoundDecl() and LookupResult::getAcceptableDecl(D)
4256 // may invalidate the iterators used in the two
4257 // loops above.
4258 DeclsToVisit.push_back(Elt: D);
4259
4260 for (auto *D : DeclsToVisit)
4261 if (auto *ND = Result.getAcceptableDecl(D)) {
4262 Consumer.FoundDecl(ND, Hiding: Visited.checkHidden(ND), Ctx, InBaseClass);
4263 Visited.add(ND);
4264 }
4265
4266 DeclsToVisit.clear();
4267
4268 // Traverse using directives for qualified name lookup.
4269 if (QualifiedNameLookup) {
4270 ShadowContextRAII Shadow(Visited);
4271 for (auto *I : Ctx->using_directives()) {
4272 if (!Result.getSema().isVisible(D: I))
4273 continue;
4274 lookupInDeclContext(Ctx: I->getNominatedNamespace(), Result,
4275 QualifiedNameLookup, InBaseClass);
4276 }
4277 }
4278
4279 // Traverse the contexts of inherited C++ classes.
4280 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Val: Ctx)) {
4281 if (!Record->hasDefinition())
4282 return;
4283
4284 for (const auto &B : Record->bases()) {
4285 QualType BaseType = B.getType();
4286
4287 RecordDecl *RD;
4288 if (BaseType->isDependentType()) {
4289 if (!IncludeDependentBases) {
4290 // Don't look into dependent bases, because name lookup can't look
4291 // there anyway.
4292 continue;
4293 }
4294 // Look through an alias template, whose TemplateName is a
4295 // TypeAliasTemplateDecl rather than the ClassTemplateDecl we are
4296 // after; otherwise the base is skipped entirely.
4297 const auto *TST = BaseType->getAsNonAliasTemplateSpecializationType();
4298 if (!TST)
4299 continue;
4300 TemplateName TN = TST->getTemplateName();
4301 const auto *TD =
4302 dyn_cast_or_null<ClassTemplateDecl>(Val: TN.getAsTemplateDecl());
4303 if (!TD)
4304 continue;
4305 RD = TD->getTemplatedDecl();
4306 } else {
4307 RD = BaseType->getAsCXXRecordDecl();
4308 if (!RD)
4309 continue;
4310 }
4311
4312 // FIXME: It would be nice to be able to determine whether referencing
4313 // a particular member would be ambiguous. For example, given
4314 //
4315 // struct A { int member; };
4316 // struct B { int member; };
4317 // struct C : A, B { };
4318 //
4319 // void f(C *c) { c->### }
4320 //
4321 // accessing 'member' would result in an ambiguity. However, we
4322 // could be smart enough to qualify the member with the base
4323 // class, e.g.,
4324 //
4325 // c->B::member
4326 //
4327 // or
4328 //
4329 // c->A::member
4330
4331 // Find results in this base class (and its bases).
4332 ShadowContextRAII Shadow(Visited);
4333 lookupInDeclContext(Ctx: RD, Result, QualifiedNameLookup,
4334 /*InBaseClass=*/true);
4335 }
4336 }
4337
4338 // Traverse the contexts of Objective-C classes.
4339 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Val: Ctx)) {
4340 // Traverse categories.
4341 for (auto *Cat : IFace->visible_categories()) {
4342 ShadowContextRAII Shadow(Visited);
4343 lookupInDeclContext(Ctx: Cat, Result, QualifiedNameLookup,
4344 /*InBaseClass=*/false);
4345 }
4346
4347 // Traverse protocols.
4348 for (auto *I : IFace->all_referenced_protocols()) {
4349 ShadowContextRAII Shadow(Visited);
4350 lookupInDeclContext(Ctx: I, Result, QualifiedNameLookup,
4351 /*InBaseClass=*/false);
4352 }
4353
4354 // Traverse the superclass.
4355 if (IFace->getSuperClass()) {
4356 ShadowContextRAII Shadow(Visited);
4357 lookupInDeclContext(Ctx: IFace->getSuperClass(), Result, QualifiedNameLookup,
4358 /*InBaseClass=*/true);
4359 }
4360
4361 // If there is an implementation, traverse it. We do this to find
4362 // synthesized ivars.
4363 if (IFace->getImplementation()) {
4364 ShadowContextRAII Shadow(Visited);
4365 lookupInDeclContext(Ctx: IFace->getImplementation(), Result,
4366 QualifiedNameLookup, InBaseClass);
4367 }
4368 } else if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Val: Ctx)) {
4369 for (auto *I : Protocol->protocols()) {
4370 ShadowContextRAII Shadow(Visited);
4371 lookupInDeclContext(Ctx: I, Result, QualifiedNameLookup,
4372 /*InBaseClass=*/false);
4373 }
4374 } else if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Val: Ctx)) {
4375 for (auto *I : Category->protocols()) {
4376 ShadowContextRAII Shadow(Visited);
4377 lookupInDeclContext(Ctx: I, Result, QualifiedNameLookup,
4378 /*InBaseClass=*/false);
4379 }
4380
4381 // If there is an implementation, traverse it.
4382 if (Category->getImplementation()) {
4383 ShadowContextRAII Shadow(Visited);
4384 lookupInDeclContext(Ctx: Category->getImplementation(), Result,
4385 QualifiedNameLookup, /*InBaseClass=*/true);
4386 }
4387 }
4388 }
4389
4390 void lookupInScope(Scope *S, LookupResult &Result,
4391 UnqualUsingDirectiveSet &UDirs) {
4392 // No clients run in this mode and it's not supported. Please add tests and
4393 // remove the assertion if you start relying on it.
4394 assert(!IncludeDependentBases && "Unsupported flag for lookupInScope");
4395
4396 if (!S)
4397 return;
4398
4399 if (!S->getEntity() ||
4400 (!S->getParent() && !Visited.alreadyVisitedContext(Ctx: S->getEntity())) ||
4401 (S->getEntity())->isFunctionOrMethod()) {
4402 FindLocalExternScope FindLocals(Result);
4403 // Walk through the declarations in this Scope. The consumer might add new
4404 // decls to the scope as part of deserialization, so make a copy first.
4405 SmallVector<Decl *, 8> ScopeDecls(S->decls().begin(), S->decls().end());
4406 for (Decl *D : ScopeDecls) {
4407 if (NamedDecl *ND = dyn_cast<NamedDecl>(Val: D))
4408 if ((ND = Result.getAcceptableDecl(D: ND))) {
4409 Consumer.FoundDecl(ND, Hiding: Visited.checkHidden(ND), Ctx: nullptr, InBaseClass: false);
4410 Visited.add(ND);
4411 }
4412 }
4413 }
4414
4415 DeclContext *Entity = S->getLookupEntity();
4416 if (Entity) {
4417 // Look into this scope's declaration context, along with any of its
4418 // parent lookup contexts (e.g., enclosing classes), up to the point
4419 // where we hit the context stored in the next outer scope.
4420 DeclContext *OuterCtx = findOuterContext(S);
4421
4422 for (DeclContext *Ctx = Entity; Ctx && !Ctx->Equals(DC: OuterCtx);
4423 Ctx = Ctx->getLookupParent()) {
4424 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(Val: Ctx)) {
4425 if (Method->isInstanceMethod()) {
4426 // For instance methods, look for ivars in the method's interface.
4427 LookupResult IvarResult(Result.getSema(), Result.getLookupName(),
4428 Result.getNameLoc(),
4429 Sema::LookupMemberName);
4430 if (ObjCInterfaceDecl *IFace = Method->getClassInterface()) {
4431 lookupInDeclContext(Ctx: IFace, Result&: IvarResult,
4432 /*QualifiedNameLookup=*/false,
4433 /*InBaseClass=*/false);
4434 }
4435 }
4436
4437 // We've already performed all of the name lookup that we need
4438 // to for Objective-C methods; the next context will be the
4439 // outer scope.
4440 break;
4441 }
4442
4443 if (Ctx->isFunctionOrMethod())
4444 continue;
4445
4446 lookupInDeclContext(Ctx, Result, /*QualifiedNameLookup=*/false,
4447 /*InBaseClass=*/false);
4448 }
4449 } else if (!S->getParent()) {
4450 // Look into the translation unit scope. We walk through the translation
4451 // unit's declaration context, because the Scope itself won't have all of
4452 // the declarations if we loaded a precompiled header.
4453 // FIXME: We would like the translation unit's Scope object to point to
4454 // the translation unit, so we don't need this special "if" branch.
4455 // However, doing so would force the normal C++ name-lookup code to look
4456 // into the translation unit decl when the IdentifierInfo chains would
4457 // suffice. Once we fix that problem (which is part of a more general
4458 // "don't look in DeclContexts unless we have to" optimization), we can
4459 // eliminate this.
4460 Entity = Result.getSema().Context.getTranslationUnitDecl();
4461 lookupInDeclContext(Ctx: Entity, Result, /*QualifiedNameLookup=*/false,
4462 /*InBaseClass=*/false);
4463 }
4464
4465 if (Entity) {
4466 // Lookup visible declarations in any namespaces found by using
4467 // directives.
4468 for (const UnqualUsingEntry &UUE : UDirs.getNamespacesFor(DC: Entity))
4469 lookupInDeclContext(
4470 Ctx: const_cast<DeclContext *>(UUE.getNominatedNamespace()), Result,
4471 /*QualifiedNameLookup=*/false,
4472 /*InBaseClass=*/false);
4473 }
4474
4475 // Lookup names in the parent scope.
4476 ShadowContextRAII Shadow(Visited);
4477 lookupInScope(S: S->getParent(), Result, UDirs);
4478 }
4479
4480private:
4481 VisibleDeclsRecord Visited;
4482 VisibleDeclConsumer &Consumer;
4483 bool IncludeDependentBases;
4484 bool LoadExternal;
4485};
4486} // namespace
4487
4488void Sema::LookupVisibleDecls(Scope *S, LookupNameKind Kind,
4489 VisibleDeclConsumer &Consumer,
4490 bool IncludeGlobalScope, bool LoadExternal) {
4491 LookupVisibleHelper H(Consumer, /*IncludeDependentBases=*/false,
4492 LoadExternal);
4493 H.lookupVisibleDecls(SemaRef&: *this, S, Kind, IncludeGlobalScope);
4494}
4495
4496void Sema::LookupVisibleDecls(DeclContext *Ctx, LookupNameKind Kind,
4497 VisibleDeclConsumer &Consumer,
4498 bool IncludeGlobalScope,
4499 bool IncludeDependentBases, bool LoadExternal) {
4500 LookupVisibleHelper H(Consumer, IncludeDependentBases, LoadExternal);
4501 H.lookupVisibleDecls(SemaRef&: *this, Ctx, Kind, IncludeGlobalScope);
4502}
4503
4504LabelDecl *Sema::LookupExistingLabel(IdentifierInfo *II, SourceLocation Loc) {
4505 NamedDecl *Res = LookupSingleName(S: CurScope, Name: II, Loc, NameKind: LookupLabel,
4506 Redecl: RedeclarationKind::NotForRedeclaration);
4507 // If we found a label, check to see if it is in the same context as us.
4508 // When in a Block, we don't want to reuse a label in an enclosing function.
4509 if (!Res ||
4510 Res->getDeclContext()->getEnclosingNonExpansionStatementContext() !=
4511 CurContext->getEnclosingNonExpansionStatementContext())
4512 return nullptr;
4513 return cast<LabelDecl>(Val: Res);
4514}
4515
4516LabelDecl *Sema::LookupOrCreateLabel(IdentifierInfo *II, SourceLocation Loc,
4517 SourceLocation GnuLabelLoc,
4518 bool IsLabelStmt) {
4519 if (GnuLabelLoc.isValid()) {
4520 // Local label definitions always shadow existing labels.
4521 auto *Res = LabelDecl::Create(C&: Context, DC: CurContext, IdentL: Loc, II, GnuLabelL: GnuLabelLoc);
4522 Scope *S = CurScope;
4523 PushOnScopeChains(D: Res, S, AddToContext: true);
4524 return cast<LabelDecl>(Val: Res);
4525 }
4526
4527 LabelDecl *Existing = LookupExistingLabel(II, Loc);
4528
4529 // C++26 [stmt.label]p4 An identifier label shall not be enclosed by an
4530 // expansion-statement.
4531 //
4532 // As an extension, we allow GNU local labels since they are logically
4533 // scoped to the containing block, which prevents us from ending up with
4534 // multiple copies of the same label in a function after instantiation.
4535 //
4536 // While allowing this is slightly more complicated, it also has the nice
4537 // side-effect of avoiding otherwise rather horrible diagnostics you'd get
4538 // when trying to use '__label__' if we didn't support this.
4539 if (IsLabelStmt && CurContext->isExpansionStmt()) {
4540 if (Existing && Existing->isGnuLocal())
4541 return Existing;
4542
4543 // Drop the label from the AST as creating it anyway would cause us to
4544 // either issue various unhelpful diagnostics (if we were to declare
4545 // it in the function decl context) or shadow a valid label with the
4546 // same name outside the expansion statement.
4547 Diag(Loc, DiagID: diag::err_expansion_stmt_label);
4548 return nullptr;
4549 }
4550
4551 if (Existing)
4552 return Existing;
4553
4554 // Declare non-local labels outside any expansion statements; this is required
4555 // to support jumping out of an expansion statement.
4556 ContextRAII Ctx{*this, CurContext->getEnclosingNonExpansionStatementContext(),
4557 /*NewThisContext=*/false};
4558
4559 // Not a GNU local label. Create the backing decl.
4560 auto *Res = LabelDecl::Create(C&: Context, DC: CurContext, IdentL: Loc, II);
4561 Scope *S = CurScope->getFnParent();
4562 assert(S && "Not in a function?");
4563 PushOnScopeChains(D: Res, S, AddToContext: true);
4564 return Res;
4565}
4566
4567//===----------------------------------------------------------------------===//
4568// Typo correction
4569//===----------------------------------------------------------------------===//
4570
4571static bool isCandidateViable(CorrectionCandidateCallback &CCC,
4572 TypoCorrection &Candidate) {
4573 Candidate.setCallbackDistance(CCC.RankCandidate(candidate: Candidate));
4574 return Candidate.getEditDistance(Normalized: false) != TypoCorrection::InvalidDistance;
4575}
4576
4577static void LookupPotentialTypoResult(Sema &SemaRef,
4578 LookupResult &Res,
4579 IdentifierInfo *Name,
4580 Scope *S, CXXScopeSpec *SS,
4581 DeclContext *MemberContext,
4582 bool EnteringContext,
4583 bool isObjCIvarLookup,
4584 bool FindHidden);
4585
4586/// Check whether the declarations found for a typo correction are
4587/// visible. Set the correction's RequiresImport flag to true if none of the
4588/// declarations are visible, false otherwise.
4589static void checkCorrectionVisibility(Sema &SemaRef, TypoCorrection &TC) {
4590 TypoCorrection::decl_iterator DI = TC.begin(), DE = TC.end();
4591
4592 for (/**/; DI != DE; ++DI)
4593 if (!LookupResult::isVisible(SemaRef, D: *DI))
4594 break;
4595 // No filtering needed if all decls are visible.
4596 if (DI == DE) {
4597 TC.setRequiresImport(false);
4598 return;
4599 }
4600
4601 llvm::SmallVector<NamedDecl*, 4> NewDecls(TC.begin(), DI);
4602 bool AnyVisibleDecls = !NewDecls.empty();
4603
4604 for (/**/; DI != DE; ++DI) {
4605 if (LookupResult::isVisible(SemaRef, D: *DI)) {
4606 if (!AnyVisibleDecls) {
4607 // Found a visible decl, discard all hidden ones.
4608 AnyVisibleDecls = true;
4609 NewDecls.clear();
4610 }
4611 NewDecls.push_back(Elt: *DI);
4612 } else if (!AnyVisibleDecls && !(*DI)->isModulePrivate())
4613 NewDecls.push_back(Elt: *DI);
4614 }
4615
4616 if (NewDecls.empty())
4617 TC = TypoCorrection();
4618 else {
4619 TC.setCorrectionDecls(NewDecls);
4620 TC.setRequiresImport(!AnyVisibleDecls);
4621 }
4622}
4623
4624// Fill the supplied vector with the IdentifierInfo pointers for each piece of
4625// the given NestedNameSpecifier (i.e. given a NestedNameSpecifier "foo::bar::",
4626// fill the vector with the IdentifierInfo pointers for "foo" and "bar").
4627static void getNestedNameSpecifierIdentifiers(
4628 NestedNameSpecifier NNS,
4629 SmallVectorImpl<const IdentifierInfo *> &Identifiers) {
4630 switch (NNS.getKind()) {
4631 case NestedNameSpecifier::Kind::Null:
4632 Identifiers.clear();
4633 return;
4634
4635 case NestedNameSpecifier::Kind::Namespace: {
4636 auto [Namespace, Prefix] = NNS.getAsNamespaceAndPrefix();
4637 getNestedNameSpecifierIdentifiers(NNS: Prefix, Identifiers);
4638 if (const auto *NS = dyn_cast<NamespaceDecl>(Val: Namespace);
4639 NS && NS->isAnonymousNamespace())
4640 return;
4641 Identifiers.push_back(Elt: Namespace->getIdentifier());
4642 return;
4643 }
4644
4645 case NestedNameSpecifier::Kind::Type: {
4646 for (const Type *T = NNS.getAsType(); /**/; /**/) {
4647 switch (T->getTypeClass()) {
4648 case Type::DependentName: {
4649 auto *DT = cast<DependentNameType>(Val: T);
4650 getNestedNameSpecifierIdentifiers(NNS: DT->getQualifier(), Identifiers);
4651 Identifiers.push_back(Elt: DT->getIdentifier());
4652 return;
4653 }
4654 case Type::TemplateSpecialization: {
4655 TemplateName Name =
4656 cast<TemplateSpecializationType>(Val: T)->getTemplateName();
4657 if (const DependentTemplateName *DTN =
4658 Name.getAsDependentTemplateName()) {
4659 getNestedNameSpecifierIdentifiers(NNS: DTN->getQualifier(), Identifiers);
4660 if (const auto *II = DTN->getName().getIdentifier())
4661 Identifiers.push_back(Elt: II);
4662 return;
4663 }
4664 if (const QualifiedTemplateName *QTN =
4665 Name.getAsQualifiedTemplateName()) {
4666 getNestedNameSpecifierIdentifiers(NNS: QTN->getQualifier(), Identifiers);
4667 Name = QTN->getUnderlyingTemplate();
4668 }
4669 if (const auto *TD = Name.getAsTemplateDecl(/*IgnoreDeduced=*/true))
4670 Identifiers.push_back(Elt: TD->getIdentifier());
4671 return;
4672 }
4673 case Type::SubstTemplateTypeParm:
4674 T = cast<SubstTemplateTypeParmType>(Val: T)
4675 ->getReplacementType()
4676 .getTypePtr();
4677 continue;
4678 case Type::TemplateTypeParm:
4679 Identifiers.push_back(Elt: cast<TemplateTypeParmType>(Val: T)->getIdentifier());
4680 return;
4681 case Type::Decltype:
4682 return;
4683 case Type::Enum:
4684 case Type::Record:
4685 case Type::InjectedClassName: {
4686 auto *TT = cast<TagType>(Val: T);
4687 getNestedNameSpecifierIdentifiers(NNS: TT->getQualifier(), Identifiers);
4688 Identifiers.push_back(Elt: TT->getDecl()->getIdentifier());
4689 return;
4690 }
4691 case Type::Typedef: {
4692 auto *TT = cast<TypedefType>(Val: T);
4693 getNestedNameSpecifierIdentifiers(NNS: TT->getQualifier(), Identifiers);
4694 Identifiers.push_back(Elt: TT->getDecl()->getIdentifier());
4695 return;
4696 }
4697 case Type::Using: {
4698 auto *TT = cast<UsingType>(Val: T);
4699 getNestedNameSpecifierIdentifiers(NNS: TT->getQualifier(), Identifiers);
4700 Identifiers.push_back(Elt: TT->getDecl()->getIdentifier());
4701 return;
4702 }
4703 case Type::UnresolvedUsing: {
4704 auto *TT = cast<UnresolvedUsingType>(Val: T);
4705 getNestedNameSpecifierIdentifiers(NNS: TT->getQualifier(), Identifiers);
4706 Identifiers.push_back(Elt: TT->getDecl()->getIdentifier());
4707 return;
4708 }
4709 default:
4710 Identifiers.push_back(Elt: QualType(T, 0).getBaseTypeIdentifier());
4711 return;
4712 }
4713 }
4714 break;
4715 }
4716
4717 case NestedNameSpecifier::Kind::Global:
4718 case NestedNameSpecifier::Kind::MicrosoftSuper:
4719 return;
4720 }
4721}
4722
4723void TypoCorrectionConsumer::FoundDecl(NamedDecl *ND, NamedDecl *Hiding,
4724 DeclContext *Ctx, bool InBaseClass) {
4725 // Don't consider hidden names for typo correction.
4726 if (Hiding)
4727 return;
4728
4729 // Only consider entities with identifiers for names, ignoring
4730 // special names (constructors, overloaded operators, selectors,
4731 // etc.).
4732 IdentifierInfo *Name = ND->getIdentifier();
4733 if (!Name)
4734 return;
4735
4736 // Only consider visible declarations and declarations from modules with
4737 // names that exactly match.
4738 if (!LookupResult::isVisible(SemaRef, D: ND) && Name != Typo)
4739 return;
4740
4741 FoundName(Name: Name->getName());
4742}
4743
4744void TypoCorrectionConsumer::FoundName(StringRef Name) {
4745 // Compute the edit distance between the typo and the name of this
4746 // entity, and add the identifier to the list of results.
4747 addName(Name, ND: nullptr);
4748}
4749
4750void TypoCorrectionConsumer::addKeywordResult(StringRef Keyword) {
4751 // Compute the edit distance between the typo and this keyword,
4752 // and add the keyword to the list of results.
4753 addName(Name: Keyword, /*ND=*/nullptr, /*NNS=*/std::nullopt, /*isKeyword=*/true);
4754}
4755
4756void TypoCorrectionConsumer::addName(StringRef Name, NamedDecl *ND,
4757 NestedNameSpecifier NNS, bool isKeyword) {
4758 // Use a simple length-based heuristic to determine the minimum possible
4759 // edit distance. If the minimum isn't good enough, bail out early.
4760 StringRef TypoStr = Typo->getName();
4761 unsigned MinED = abs(x: (int)Name.size() - (int)TypoStr.size());
4762 if (MinED && TypoStr.size() / MinED < 3)
4763 return;
4764
4765 // Compute an upper bound on the allowable edit distance, so that the
4766 // edit-distance algorithm can short-circuit.
4767 unsigned UpperBound = (TypoStr.size() + 2) / 3;
4768 unsigned ED = TypoStr.edit_distance(Other: Name, AllowReplacements: true, MaxEditDistance: UpperBound);
4769 if (ED > UpperBound) return;
4770
4771 TypoCorrection TC(&SemaRef.Context.Idents.get(Name), ND, NNS, ED);
4772 if (isKeyword) TC.makeKeyword();
4773 TC.setCorrectionRange(SS: nullptr, TypoName: Result.getLookupNameInfo());
4774 addCorrection(Correction: TC);
4775}
4776
4777static const unsigned MaxTypoDistanceResultSets = 5;
4778
4779void TypoCorrectionConsumer::addCorrection(TypoCorrection Correction) {
4780 StringRef TypoStr = Typo->getName();
4781 StringRef Name = Correction.getCorrectionAsIdentifierInfo()->getName();
4782
4783 // For very short typos, ignore potential corrections that have a different
4784 // base identifier from the typo or which have a normalized edit distance
4785 // longer than the typo itself.
4786 if (TypoStr.size() < 3 &&
4787 (Name != TypoStr || Correction.getEditDistance(Normalized: true) > TypoStr.size()))
4788 return;
4789
4790 // If the correction is resolved but is not viable, ignore it.
4791 if (Correction.isResolved()) {
4792 checkCorrectionVisibility(SemaRef, TC&: Correction);
4793 if (!Correction || !isCandidateViable(CCC&: *CorrectionValidator, Candidate&: Correction))
4794 return;
4795 }
4796
4797 TypoResultList &CList =
4798 CorrectionResults[Correction.getEditDistance(Normalized: false)][Name];
4799
4800 if (!CList.empty() && !CList.back().isResolved())
4801 CList.pop_back();
4802 if (NamedDecl *NewND = Correction.getCorrectionDecl()) {
4803 auto RI = llvm::find_if(Range&: CList, P: [NewND](const TypoCorrection &TypoCorr) {
4804 return TypoCorr.getCorrectionDecl() == NewND;
4805 });
4806 if (RI != CList.end()) {
4807 // The Correction refers to a decl already in the list. No insertion is
4808 // necessary and all further cases will return.
4809
4810 auto IsDeprecated = [](Decl *D) {
4811 while (D) {
4812 if (D->isDeprecated())
4813 return true;
4814 D = llvm::dyn_cast_or_null<NamespaceDecl>(Val: D->getDeclContext());
4815 }
4816 return false;
4817 };
4818
4819 // Prefer non deprecated Corrections over deprecated and only then
4820 // sort using an alphabetical order.
4821 std::pair<bool, std::string> NewKey = {
4822 IsDeprecated(Correction.getFoundDecl()),
4823 Correction.getAsString(LO: SemaRef.getLangOpts())};
4824
4825 std::pair<bool, std::string> PrevKey = {
4826 IsDeprecated(RI->getFoundDecl()),
4827 RI->getAsString(LO: SemaRef.getLangOpts())};
4828
4829 if (NewKey < PrevKey)
4830 *RI = std::move(Correction);
4831 return;
4832 }
4833 }
4834 if (CList.empty() || Correction.isResolved())
4835 CList.push_back(Elt: Correction);
4836
4837 while (CorrectionResults.size() > MaxTypoDistanceResultSets)
4838 CorrectionResults.erase(position: std::prev(x: CorrectionResults.end()));
4839}
4840
4841void TypoCorrectionConsumer::addNamespaces(
4842 const llvm::MapVector<NamespaceDecl *, bool> &KnownNamespaces) {
4843 SearchNamespaces = true;
4844
4845 for (auto KNPair : KnownNamespaces)
4846 Namespaces.addNameSpecifier(Ctx: KNPair.first);
4847
4848 bool SSIsTemplate = false;
4849 if (NestedNameSpecifier NNS = (SS ? SS->getScopeRep() : std::nullopt)) {
4850 if (NNS.getKind() == NestedNameSpecifier::Kind::Type)
4851 SSIsTemplate =
4852 NNS.getAsType()->getTypeClass() == Type::TemplateSpecialization;
4853 }
4854 // Do not transform this into an iterator-based loop. The loop body can
4855 // trigger the creation of further types (through lazy deserialization) and
4856 // invalid iterators into this list.
4857 auto &Types = SemaRef.getASTContext().getTypes();
4858 for (unsigned I = 0; I != Types.size(); ++I) {
4859 const auto *TI = Types[I];
4860 if (CXXRecordDecl *CD = TI->getAsCXXRecordDecl()) {
4861 CD = CD->getCanonicalDecl();
4862 if (!CD->isDependentType() && !CD->isAnonymousStructOrUnion() &&
4863 !CD->isUnion() && CD->getIdentifier() &&
4864 (SSIsTemplate || !isa<ClassTemplateSpecializationDecl>(Val: CD)) &&
4865 (CD->isBeingDefined() || CD->isCompleteDefinition()))
4866 Namespaces.addNameSpecifier(Ctx: CD);
4867 }
4868 }
4869}
4870
4871const TypoCorrection &TypoCorrectionConsumer::getNextCorrection() {
4872 if (++CurrentTCIndex < ValidatedCorrections.size())
4873 return ValidatedCorrections[CurrentTCIndex];
4874
4875 CurrentTCIndex = ValidatedCorrections.size();
4876 while (!CorrectionResults.empty()) {
4877 auto DI = CorrectionResults.begin();
4878 if (DI->second.empty()) {
4879 CorrectionResults.erase(position: DI);
4880 continue;
4881 }
4882
4883 auto RI = DI->second.begin();
4884 if (RI->second.empty()) {
4885 DI->second.erase(I: RI);
4886 performQualifiedLookups();
4887 continue;
4888 }
4889
4890 TypoCorrection TC = RI->second.pop_back_val();
4891 if (TC.isResolved() || TC.requiresImport() || resolveCorrection(Candidate&: TC)) {
4892 ValidatedCorrections.push_back(Elt: TC);
4893 return ValidatedCorrections[CurrentTCIndex];
4894 }
4895 }
4896 return ValidatedCorrections[0]; // The empty correction.
4897}
4898
4899bool TypoCorrectionConsumer::resolveCorrection(TypoCorrection &Candidate) {
4900 IdentifierInfo *Name = Candidate.getCorrectionAsIdentifierInfo();
4901 DeclContext *TempMemberContext = MemberContext;
4902 CXXScopeSpec *TempSS = SS.get();
4903retry_lookup:
4904 LookupPotentialTypoResult(SemaRef, Res&: Result, Name, S, SS: TempSS, MemberContext: TempMemberContext,
4905 EnteringContext,
4906 isObjCIvarLookup: CorrectionValidator->IsObjCIvarLookup,
4907 FindHidden: Name == Typo && !Candidate.WillReplaceSpecifier());
4908 switch (Result.getResultKind()) {
4909 case LookupResultKind::NotFound:
4910 case LookupResultKind::NotFoundInCurrentInstantiation:
4911 case LookupResultKind::FoundUnresolvedValue:
4912 if (TempSS) {
4913 // Immediately retry the lookup without the given CXXScopeSpec
4914 TempSS = nullptr;
4915 Candidate.WillReplaceSpecifier(ForceReplacement: true);
4916 goto retry_lookup;
4917 }
4918 if (TempMemberContext) {
4919 if (SS && !TempSS)
4920 TempSS = SS.get();
4921 TempMemberContext = nullptr;
4922 goto retry_lookup;
4923 }
4924 if (SearchNamespaces)
4925 QualifiedResults.push_back(Elt: Candidate);
4926 break;
4927
4928 case LookupResultKind::Ambiguous:
4929 // We don't deal with ambiguities.
4930 break;
4931
4932 case LookupResultKind::Found:
4933 case LookupResultKind::FoundOverloaded:
4934 // Store all of the Decls for overloaded symbols
4935 for (auto *TRD : Result)
4936 Candidate.addCorrectionDecl(CDecl: TRD);
4937 checkCorrectionVisibility(SemaRef, TC&: Candidate);
4938 if (!isCandidateViable(CCC&: *CorrectionValidator, Candidate)) {
4939 if (SearchNamespaces)
4940 QualifiedResults.push_back(Elt: Candidate);
4941 break;
4942 }
4943 Candidate.setCorrectionRange(SS: SS.get(), TypoName: Result.getLookupNameInfo());
4944 return true;
4945 }
4946 return false;
4947}
4948
4949void TypoCorrectionConsumer::performQualifiedLookups() {
4950 unsigned TypoLen = Typo->getName().size();
4951 for (const TypoCorrection &QR : QualifiedResults) {
4952 for (const auto &NSI : Namespaces) {
4953 DeclContext *Ctx = NSI.DeclCtx;
4954 CXXRecordDecl *NamingClass = NSI.NameSpecifier.getAsRecordDecl();
4955
4956 // If the current NestedNameSpecifier refers to a class and the
4957 // current correction candidate is the name of that class, then skip
4958 // it as it is unlikely a qualified version of the class' constructor
4959 // is an appropriate correction.
4960 if (NamingClass &&
4961 NamingClass->getIdentifier() == QR.getCorrectionAsIdentifierInfo())
4962 continue;
4963
4964 TypoCorrection TC(QR);
4965 TC.ClearCorrectionDecls();
4966 TC.setCorrectionSpecifier(NSI.NameSpecifier);
4967 TC.setQualifierDistance(NSI.EditDistance);
4968 TC.setCallbackDistance(0); // Reset the callback distance
4969
4970 // If the current correction candidate and namespace combination are
4971 // too far away from the original typo based on the normalized edit
4972 // distance, then skip performing a qualified name lookup.
4973 unsigned TmpED = TC.getEditDistance(Normalized: true);
4974 if (QR.getCorrectionAsIdentifierInfo() != Typo && TmpED &&
4975 TypoLen / TmpED < 3)
4976 continue;
4977
4978 Result.clear();
4979 Result.setLookupName(QR.getCorrectionAsIdentifierInfo());
4980 if (!SemaRef.LookupQualifiedName(R&: Result, LookupCtx: Ctx))
4981 continue;
4982
4983 // Any corrections added below will be validated in subsequent
4984 // iterations of the main while() loop over the Consumer's contents.
4985 switch (Result.getResultKind()) {
4986 case LookupResultKind::Found:
4987 case LookupResultKind::FoundOverloaded: {
4988 if (SS && SS->isValid()) {
4989 std::string NewQualified = TC.getAsString(LO: SemaRef.getLangOpts());
4990 std::string OldQualified;
4991 llvm::raw_string_ostream OldOStream(OldQualified);
4992 SS->getScopeRep().print(OS&: OldOStream, Policy: SemaRef.getPrintingPolicy());
4993 OldOStream << Typo->getName();
4994 // If correction candidate would be an identical written qualified
4995 // identifier, then the existing CXXScopeSpec probably included a
4996 // typedef that didn't get accounted for properly.
4997 if (OldOStream.str() == NewQualified)
4998 break;
4999 }
5000 for (LookupResult::iterator TRD = Result.begin(), TRDEnd = Result.end();
5001 TRD != TRDEnd; ++TRD) {
5002 if (SemaRef.CheckMemberAccess(UseLoc: TC.getCorrectionRange().getBegin(),
5003 NamingClass,
5004 Found: TRD.getPair()) == Sema::AR_accessible)
5005 TC.addCorrectionDecl(CDecl: *TRD);
5006 }
5007 if (TC.isResolved()) {
5008 TC.setCorrectionRange(SS: SS.get(), TypoName: Result.getLookupNameInfo());
5009 addCorrection(Correction: TC);
5010 }
5011 break;
5012 }
5013 case LookupResultKind::NotFound:
5014 case LookupResultKind::NotFoundInCurrentInstantiation:
5015 case LookupResultKind::Ambiguous:
5016 case LookupResultKind::FoundUnresolvedValue:
5017 break;
5018 }
5019 }
5020 }
5021 QualifiedResults.clear();
5022}
5023
5024TypoCorrectionConsumer::NamespaceSpecifierSet::NamespaceSpecifierSet(
5025 ASTContext &Context, DeclContext *CurContext, CXXScopeSpec *CurScopeSpec)
5026 : Context(Context), CurContextChain(buildContextChain(Start: CurContext)) {
5027 if (NestedNameSpecifier NNS =
5028 CurScopeSpec ? CurScopeSpec->getScopeRep() : std::nullopt) {
5029 llvm::raw_string_ostream SpecifierOStream(CurNameSpecifier);
5030 NNS.print(OS&: SpecifierOStream, Policy: Context.getPrintingPolicy());
5031
5032 getNestedNameSpecifierIdentifiers(NNS, Identifiers&: CurNameSpecifierIdentifiers);
5033 }
5034 // Build the list of identifiers that would be used for an absolute
5035 // (from the global context) NestedNameSpecifier referring to the current
5036 // context.
5037 for (DeclContext *C : llvm::reverse(C&: CurContextChain)) {
5038 if (auto *ND = dyn_cast_or_null<NamespaceDecl>(Val: C))
5039 CurContextIdentifiers.push_back(Elt: ND->getIdentifier());
5040 }
5041
5042 // Add the global context as a NestedNameSpecifier
5043 SpecifierInfo SI = {.DeclCtx: cast<DeclContext>(Val: Context.getTranslationUnitDecl()),
5044 .NameSpecifier: NestedNameSpecifier::getGlobal(), .EditDistance: 1};
5045 DistanceMap[1].push_back(Elt: SI);
5046}
5047
5048auto TypoCorrectionConsumer::NamespaceSpecifierSet::buildContextChain(
5049 DeclContext *Start) -> DeclContextList {
5050 assert(Start && "Building a context chain from a null context");
5051 DeclContextList Chain;
5052 for (DeclContext *DC = Start->getPrimaryContext(); DC != nullptr;
5053 DC = DC->getLookupParent()) {
5054 NamespaceDecl *ND = dyn_cast_or_null<NamespaceDecl>(Val: DC);
5055 if (!DC->isInlineNamespace() && !DC->isTransparentContext() &&
5056 !(ND && ND->isAnonymousNamespace()))
5057 Chain.push_back(Elt: DC->getPrimaryContext());
5058 }
5059 return Chain;
5060}
5061
5062unsigned
5063TypoCorrectionConsumer::NamespaceSpecifierSet::buildNestedNameSpecifier(
5064 DeclContextList &DeclChain, NestedNameSpecifier &NNS) {
5065 unsigned NumSpecifiers = 0;
5066 for (DeclContext *C : llvm::reverse(C&: DeclChain)) {
5067 if (auto *ND = dyn_cast_or_null<NamespaceDecl>(Val: C)) {
5068 NNS = NestedNameSpecifier(Context, ND, NNS);
5069 ++NumSpecifiers;
5070 } else if (auto *RD = dyn_cast_or_null<RecordDecl>(Val: C)) {
5071 QualType T = Context.getTagType(Keyword: ElaboratedTypeKeyword::None, Qualifier: NNS, TD: RD,
5072 /*OwnsTag=*/false);
5073 NNS = NestedNameSpecifier(T.getTypePtr());
5074 ++NumSpecifiers;
5075 }
5076 }
5077 return NumSpecifiers;
5078}
5079
5080void TypoCorrectionConsumer::NamespaceSpecifierSet::addNameSpecifier(
5081 DeclContext *Ctx) {
5082 NestedNameSpecifier NNS = std::nullopt;
5083 unsigned NumSpecifiers = 0;
5084 DeclContextList NamespaceDeclChain(buildContextChain(Start: Ctx));
5085 DeclContextList FullNamespaceDeclChain(NamespaceDeclChain);
5086
5087 // Eliminate common elements from the two DeclContext chains.
5088 for (DeclContext *C : llvm::reverse(C&: CurContextChain)) {
5089 if (NamespaceDeclChain.empty() || NamespaceDeclChain.back() != C)
5090 break;
5091 NamespaceDeclChain.pop_back();
5092 }
5093
5094 // Build the NestedNameSpecifier from what is left of the NamespaceDeclChain
5095 NumSpecifiers = buildNestedNameSpecifier(DeclChain&: NamespaceDeclChain, NNS);
5096
5097 // Add an explicit leading '::' specifier if needed.
5098 if (NamespaceDeclChain.empty()) {
5099 // Rebuild the NestedNameSpecifier as a globally-qualified specifier.
5100 NNS = NestedNameSpecifier::getGlobal();
5101 NumSpecifiers =
5102 buildNestedNameSpecifier(DeclChain&: FullNamespaceDeclChain, NNS);
5103 } else if (NamedDecl *ND =
5104 dyn_cast_or_null<NamedDecl>(Val: NamespaceDeclChain.back())) {
5105 IdentifierInfo *Name = ND->getIdentifier();
5106 bool SameNameSpecifier = false;
5107 if (llvm::is_contained(Range&: CurNameSpecifierIdentifiers, Element: Name)) {
5108 std::string NewNameSpecifier;
5109 llvm::raw_string_ostream SpecifierOStream(NewNameSpecifier);
5110 SmallVector<const IdentifierInfo *, 4> NewNameSpecifierIdentifiers;
5111 getNestedNameSpecifierIdentifiers(NNS, Identifiers&: NewNameSpecifierIdentifiers);
5112 NNS.print(OS&: SpecifierOStream, Policy: Context.getPrintingPolicy());
5113 SameNameSpecifier = NewNameSpecifier == CurNameSpecifier;
5114 }
5115 if (SameNameSpecifier || llvm::is_contained(Range&: CurContextIdentifiers, Element: Name)) {
5116 // Rebuild the NestedNameSpecifier as a globally-qualified specifier.
5117 NNS = NestedNameSpecifier::getGlobal();
5118 NumSpecifiers =
5119 buildNestedNameSpecifier(DeclChain&: FullNamespaceDeclChain, NNS);
5120 }
5121 }
5122
5123 // If the built NestedNameSpecifier would be replacing an existing
5124 // NestedNameSpecifier, use the number of component identifiers that
5125 // would need to be changed as the edit distance instead of the number
5126 // of components in the built NestedNameSpecifier.
5127 if (NNS && !CurNameSpecifierIdentifiers.empty()) {
5128 SmallVector<const IdentifierInfo*, 4> NewNameSpecifierIdentifiers;
5129 getNestedNameSpecifierIdentifiers(NNS, Identifiers&: NewNameSpecifierIdentifiers);
5130 NumSpecifiers =
5131 llvm::ComputeEditDistance(FromArray: llvm::ArrayRef(CurNameSpecifierIdentifiers),
5132 ToArray: llvm::ArrayRef(NewNameSpecifierIdentifiers));
5133 }
5134
5135 SpecifierInfo SI = {.DeclCtx: Ctx, .NameSpecifier: NNS, .EditDistance: NumSpecifiers};
5136 DistanceMap[NumSpecifiers].push_back(Elt: SI);
5137}
5138
5139/// Perform name lookup for a possible result for typo correction.
5140static void LookupPotentialTypoResult(Sema &SemaRef,
5141 LookupResult &Res,
5142 IdentifierInfo *Name,
5143 Scope *S, CXXScopeSpec *SS,
5144 DeclContext *MemberContext,
5145 bool EnteringContext,
5146 bool isObjCIvarLookup,
5147 bool FindHidden) {
5148 Res.suppressDiagnostics();
5149 Res.clear();
5150 Res.setLookupName(Name);
5151 Res.setAllowHidden(FindHidden);
5152 if (MemberContext) {
5153 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(Val: MemberContext)) {
5154 if (isObjCIvarLookup) {
5155 if (ObjCIvarDecl *Ivar = Class->lookupInstanceVariable(IVarName: Name)) {
5156 Res.addDecl(D: Ivar);
5157 Res.resolveKind();
5158 return;
5159 }
5160 }
5161
5162 if (ObjCPropertyDecl *Prop = Class->FindPropertyDeclaration(
5163 PropertyId: Name, QueryKind: ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
5164 Res.addDecl(D: Prop);
5165 Res.resolveKind();
5166 return;
5167 }
5168 }
5169
5170 SemaRef.LookupQualifiedName(R&: Res, LookupCtx: MemberContext);
5171 return;
5172 }
5173
5174 SemaRef.LookupParsedName(R&: Res, S, SS,
5175 /*ObjectType=*/QualType(),
5176 /*AllowBuiltinCreation=*/false, EnteringContext);
5177
5178 // Fake ivar lookup; this should really be part of
5179 // LookupParsedName.
5180 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
5181 if (Method->isInstanceMethod() && Method->getClassInterface() &&
5182 (Res.empty() ||
5183 (Res.isSingleResult() &&
5184 Res.getFoundDecl()->isDefinedOutsideFunctionOrMethod()))) {
5185 if (ObjCIvarDecl *IV
5186 = Method->getClassInterface()->lookupInstanceVariable(IVarName: Name)) {
5187 Res.addDecl(D: IV);
5188 Res.resolveKind();
5189 }
5190 }
5191 }
5192}
5193
5194/// Add keywords to the consumer as possible typo corrections.
5195static void AddKeywordsToConsumer(Sema &SemaRef,
5196 TypoCorrectionConsumer &Consumer,
5197 Scope *S, CorrectionCandidateCallback &CCC,
5198 bool AfterNestedNameSpecifier) {
5199 if (AfterNestedNameSpecifier) {
5200 // For 'X::', we know exactly which keywords can appear next.
5201 Consumer.addKeywordResult(Keyword: "template");
5202 if (CCC.WantExpressionKeywords)
5203 Consumer.addKeywordResult(Keyword: "operator");
5204 return;
5205 }
5206
5207 if (CCC.WantObjCSuper)
5208 Consumer.addKeywordResult(Keyword: "super");
5209
5210 if (CCC.WantTypeSpecifiers) {
5211 // Add type-specifier keywords to the set of results.
5212 static const char *const CTypeSpecs[] = {
5213 "char", "const", "double", "enum", "float", "int", "long", "short",
5214 "signed", "struct", "union", "unsigned", "void", "volatile",
5215 "_Complex",
5216 // storage-specifiers as well
5217 "extern", "inline", "static", "typedef"
5218 };
5219
5220 for (const auto *CTS : CTypeSpecs)
5221 Consumer.addKeywordResult(Keyword: CTS);
5222
5223 if (SemaRef.getLangOpts().C99 && !SemaRef.getLangOpts().C2y)
5224 Consumer.addKeywordResult(Keyword: "_Imaginary");
5225
5226 if (SemaRef.getLangOpts().C99)
5227 Consumer.addKeywordResult(Keyword: "restrict");
5228 if (SemaRef.getLangOpts().Bool || SemaRef.getLangOpts().CPlusPlus)
5229 Consumer.addKeywordResult(Keyword: "bool");
5230 else if (SemaRef.getLangOpts().C99)
5231 Consumer.addKeywordResult(Keyword: "_Bool");
5232
5233 if (SemaRef.getLangOpts().CPlusPlus) {
5234 Consumer.addKeywordResult(Keyword: "class");
5235 Consumer.addKeywordResult(Keyword: "typename");
5236 Consumer.addKeywordResult(Keyword: "wchar_t");
5237
5238 if (SemaRef.getLangOpts().CPlusPlus11) {
5239 Consumer.addKeywordResult(Keyword: "char16_t");
5240 Consumer.addKeywordResult(Keyword: "char32_t");
5241 Consumer.addKeywordResult(Keyword: "constexpr");
5242 Consumer.addKeywordResult(Keyword: "decltype");
5243 Consumer.addKeywordResult(Keyword: "thread_local");
5244 }
5245 }
5246
5247 if (SemaRef.getLangOpts().GNUKeywords)
5248 Consumer.addKeywordResult(Keyword: "typeof");
5249 } else if (CCC.WantFunctionLikeCasts) {
5250 static const char *const CastableTypeSpecs[] = {
5251 "char", "double", "float", "int", "long", "short",
5252 "signed", "unsigned", "void"
5253 };
5254 for (auto *kw : CastableTypeSpecs)
5255 Consumer.addKeywordResult(Keyword: kw);
5256 }
5257
5258 if (CCC.WantCXXNamedCasts && SemaRef.getLangOpts().CPlusPlus) {
5259 Consumer.addKeywordResult(Keyword: "const_cast");
5260 Consumer.addKeywordResult(Keyword: "dynamic_cast");
5261 Consumer.addKeywordResult(Keyword: "reinterpret_cast");
5262 Consumer.addKeywordResult(Keyword: "static_cast");
5263 }
5264
5265 if (CCC.WantExpressionKeywords) {
5266 Consumer.addKeywordResult(Keyword: "sizeof");
5267 if (SemaRef.getLangOpts().Bool || SemaRef.getLangOpts().CPlusPlus) {
5268 Consumer.addKeywordResult(Keyword: "false");
5269 Consumer.addKeywordResult(Keyword: "true");
5270 }
5271
5272 if (SemaRef.getLangOpts().CPlusPlus) {
5273 static const char *const CXXExprs[] = {
5274 "delete", "new", "operator", "throw", "typeid"
5275 };
5276 for (const auto *CE : CXXExprs)
5277 Consumer.addKeywordResult(Keyword: CE);
5278
5279 if (isa<CXXMethodDecl>(Val: SemaRef.CurContext) &&
5280 cast<CXXMethodDecl>(Val: SemaRef.CurContext)->isInstance())
5281 Consumer.addKeywordResult(Keyword: "this");
5282
5283 if (SemaRef.getLangOpts().CPlusPlus11) {
5284 Consumer.addKeywordResult(Keyword: "alignof");
5285 Consumer.addKeywordResult(Keyword: "nullptr");
5286 }
5287 }
5288
5289 if (SemaRef.getLangOpts().C11) {
5290 // FIXME: We should not suggest _Alignof if the alignof macro
5291 // is present.
5292 Consumer.addKeywordResult(Keyword: "_Alignof");
5293 }
5294 }
5295
5296 if (CCC.WantRemainingKeywords) {
5297 if (SemaRef.getCurFunctionOrMethodDecl() || SemaRef.getCurBlock()) {
5298 // Statements.
5299 static const char *const CStmts[] = {
5300 "do", "else", "for", "goto", "if", "return", "switch", "while" };
5301 for (const auto *CS : CStmts)
5302 Consumer.addKeywordResult(Keyword: CS);
5303
5304 if (SemaRef.getLangOpts().CPlusPlus) {
5305 Consumer.addKeywordResult(Keyword: "catch");
5306 Consumer.addKeywordResult(Keyword: "try");
5307 }
5308
5309 if (S && S->getBreakParent())
5310 Consumer.addKeywordResult(Keyword: "break");
5311
5312 if (S && S->getContinueParent())
5313 Consumer.addKeywordResult(Keyword: "continue");
5314
5315 if (SemaRef.getCurFunction() &&
5316 !SemaRef.getCurFunction()->SwitchStack.empty()) {
5317 Consumer.addKeywordResult(Keyword: "case");
5318 Consumer.addKeywordResult(Keyword: "default");
5319 }
5320 } else {
5321 if (SemaRef.getLangOpts().CPlusPlus) {
5322 Consumer.addKeywordResult(Keyword: "namespace");
5323 Consumer.addKeywordResult(Keyword: "template");
5324 }
5325
5326 if (S && S->isClassScope()) {
5327 Consumer.addKeywordResult(Keyword: "explicit");
5328 Consumer.addKeywordResult(Keyword: "friend");
5329 Consumer.addKeywordResult(Keyword: "mutable");
5330 Consumer.addKeywordResult(Keyword: "private");
5331 Consumer.addKeywordResult(Keyword: "protected");
5332 Consumer.addKeywordResult(Keyword: "public");
5333 Consumer.addKeywordResult(Keyword: "virtual");
5334 }
5335 }
5336
5337 if (SemaRef.getLangOpts().CPlusPlus) {
5338 Consumer.addKeywordResult(Keyword: "using");
5339
5340 if (SemaRef.getLangOpts().CPlusPlus11)
5341 Consumer.addKeywordResult(Keyword: "static_assert");
5342 }
5343 }
5344}
5345
5346std::unique_ptr<TypoCorrectionConsumer> Sema::makeTypoCorrectionConsumer(
5347 const DeclarationNameInfo &TypoName, Sema::LookupNameKind LookupKind,
5348 Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC,
5349 DeclContext *MemberContext, bool EnteringContext,
5350 const ObjCObjectPointerType *OPT, bool ErrorRecovery) {
5351
5352 if (Diags.hasFatalErrorOccurred() || !getLangOpts().SpellChecking ||
5353 DisableTypoCorrection)
5354 return nullptr;
5355
5356 // In Microsoft mode, don't perform typo correction in a template member
5357 // function dependent context because it interferes with the "lookup into
5358 // dependent bases of class templates" feature.
5359 if (getLangOpts().MSVCCompat && CurContext->isDependentContext() &&
5360 isa<CXXMethodDecl>(Val: CurContext))
5361 return nullptr;
5362
5363 // We only attempt to correct typos for identifiers.
5364 IdentifierInfo *Typo = TypoName.getName().getAsIdentifierInfo();
5365 if (!Typo)
5366 return nullptr;
5367
5368 // If the scope specifier itself was invalid, don't try to correct
5369 // typos.
5370 if (SS && SS->isInvalid())
5371 return nullptr;
5372
5373 // Never try to correct typos during any kind of code synthesis.
5374 if (!CodeSynthesisContexts.empty())
5375 return nullptr;
5376
5377 // Don't try to correct 'super'.
5378 if (S && S->isInObjcMethodScope() && Typo == getSuperIdentifier())
5379 return nullptr;
5380
5381 // Abort if typo correction already failed for this specific typo.
5382 IdentifierSourceLocations::iterator locs = TypoCorrectionFailures.find(Val: Typo);
5383 if (locs != TypoCorrectionFailures.end() &&
5384 locs->second.count(V: TypoName.getLoc()))
5385 return nullptr;
5386
5387 // Don't try to correct the identifier "vector" when in AltiVec mode.
5388 // TODO: Figure out why typo correction misbehaves in this case, fix it, and
5389 // remove this workaround.
5390 if ((getLangOpts().AltiVec || getLangOpts().ZVector) && Typo->isStr(Str: "vector"))
5391 return nullptr;
5392
5393 // Provide a stop gap for files that are just seriously broken. Trying
5394 // to correct all typos can turn into a HUGE performance penalty, causing
5395 // some files to take minutes to get rejected by the parser.
5396 unsigned Limit = getDiagnostics().getDiagnosticOptions().SpellCheckingLimit;
5397 if (Limit && TyposCorrected >= Limit)
5398 return nullptr;
5399 ++TyposCorrected;
5400
5401 // If we're handling a missing symbol error, using modules, and the
5402 // special search all modules option is used, look for a missing import.
5403 if (ErrorRecovery && getLangOpts().Modules &&
5404 getLangOpts().ModulesSearchAll) {
5405 // The following has the side effect of loading the missing module.
5406 getModuleLoader().lookupMissingImports(Name: Typo->getName(),
5407 TriggerLoc: TypoName.getBeginLoc());
5408 }
5409
5410 // Extend the lifetime of the callback. We delayed this until here
5411 // to avoid allocations in the hot path (which is where no typo correction
5412 // occurs). Note that CorrectionCandidateCallback is polymorphic and
5413 // initially stack-allocated.
5414 std::unique_ptr<CorrectionCandidateCallback> ClonedCCC = CCC.clone();
5415 auto Consumer = std::make_unique<TypoCorrectionConsumer>(
5416 args&: *this, args: TypoName, args&: LookupKind, args&: S, args&: SS, args: std::move(ClonedCCC), args&: MemberContext,
5417 args&: EnteringContext);
5418
5419 // Perform name lookup to find visible, similarly-named entities.
5420 bool IsUnqualifiedLookup = false;
5421 DeclContext *QualifiedDC = MemberContext;
5422 if (MemberContext) {
5423 LookupVisibleDecls(Ctx: MemberContext, Kind: LookupKind, Consumer&: *Consumer);
5424
5425 // Look in qualified interfaces.
5426 if (OPT) {
5427 for (auto *I : OPT->quals())
5428 LookupVisibleDecls(Ctx: I, Kind: LookupKind, Consumer&: *Consumer);
5429 }
5430 } else if (SS && SS->isSet()) {
5431 QualifiedDC = computeDeclContext(SS: *SS, EnteringContext);
5432 if (!QualifiedDC)
5433 return nullptr;
5434
5435 LookupVisibleDecls(Ctx: QualifiedDC, Kind: LookupKind, Consumer&: *Consumer);
5436 } else {
5437 IsUnqualifiedLookup = true;
5438 }
5439
5440 // Determine whether we are going to search in the various namespaces for
5441 // corrections.
5442 bool SearchNamespaces
5443 = getLangOpts().CPlusPlus &&
5444 (IsUnqualifiedLookup || (SS && SS->isSet()));
5445
5446 if (IsUnqualifiedLookup || SearchNamespaces) {
5447 // For unqualified lookup, look through all of the names that we have
5448 // seen in this translation unit.
5449 // FIXME: Re-add the ability to skip very unlikely potential corrections.
5450 for (const auto &I : Context.Idents)
5451 Consumer->FoundName(Name: I.getKey());
5452
5453 // Walk through identifiers in external identifier sources.
5454 // FIXME: Re-add the ability to skip very unlikely potential corrections.
5455 if (IdentifierInfoLookup *External
5456 = Context.Idents.getExternalIdentifierLookup()) {
5457 std::unique_ptr<IdentifierIterator> Iter(External->getIdentifiers());
5458 do {
5459 StringRef Name = Iter->Next();
5460 if (Name.empty())
5461 break;
5462
5463 Consumer->FoundName(Name);
5464 } while (true);
5465 }
5466 }
5467
5468 AddKeywordsToConsumer(SemaRef&: *this, Consumer&: *Consumer, S,
5469 CCC&: *Consumer->getCorrectionValidator(),
5470 AfterNestedNameSpecifier: SS && SS->isNotEmpty());
5471
5472 // Build the NestedNameSpecifiers for the KnownNamespaces, if we're going
5473 // to search those namespaces.
5474 if (SearchNamespaces) {
5475 // Load any externally-known namespaces.
5476 if (ExternalSource && !LoadedExternalKnownNamespaces) {
5477 SmallVector<NamespaceDecl *, 4> ExternalKnownNamespaces;
5478 LoadedExternalKnownNamespaces = true;
5479 ExternalSource->ReadKnownNamespaces(Namespaces&: ExternalKnownNamespaces);
5480 for (auto *N : ExternalKnownNamespaces)
5481 KnownNamespaces[N] = true;
5482 }
5483
5484 Consumer->addNamespaces(KnownNamespaces);
5485 }
5486
5487 return Consumer;
5488}
5489
5490TypoCorrection Sema::CorrectTypo(const DeclarationNameInfo &TypoName,
5491 Sema::LookupNameKind LookupKind,
5492 Scope *S, CXXScopeSpec *SS,
5493 CorrectionCandidateCallback &CCC,
5494 CorrectTypoKind Mode,
5495 DeclContext *MemberContext,
5496 bool EnteringContext,
5497 const ObjCObjectPointerType *OPT,
5498 bool RecordFailure) {
5499 // Always let the ExternalSource have the first chance at correction, even
5500 // if we would otherwise have given up.
5501 if (ExternalSource) {
5502 if (TypoCorrection Correction =
5503 ExternalSource->CorrectTypo(Typo: TypoName, LookupKind, S, SS, CCC,
5504 MemberContext, EnteringContext, OPT))
5505 return Correction;
5506 }
5507
5508 // Ugly hack equivalent to CTC == CTC_ObjCMessageReceiver;
5509 // WantObjCSuper is only true for CTC_ObjCMessageReceiver and for
5510 // some instances of CTC_Unknown, while WantRemainingKeywords is true
5511 // for CTC_Unknown but not for CTC_ObjCMessageReceiver.
5512 bool ObjCMessageReceiver = CCC.WantObjCSuper && !CCC.WantRemainingKeywords;
5513
5514 IdentifierInfo *Typo = TypoName.getName().getAsIdentifierInfo();
5515 auto Consumer = makeTypoCorrectionConsumer(
5516 TypoName, LookupKind, S, SS, CCC, MemberContext, EnteringContext, OPT,
5517 ErrorRecovery: Mode == CorrectTypoKind::ErrorRecovery);
5518
5519 if (!Consumer)
5520 return TypoCorrection();
5521
5522 // If we haven't found anything, we're done.
5523 if (Consumer->empty())
5524 return FailedCorrection(Typo, TypoLoc: TypoName.getLoc(), RecordFailure);
5525
5526 // Make sure the best edit distance (prior to adding any namespace qualifiers)
5527 // is not more that about a third of the length of the typo's identifier.
5528 unsigned ED = Consumer->getBestEditDistance(Normalized: true);
5529 unsigned TypoLen = Typo->getName().size();
5530 if (ED > 0 && TypoLen / ED < 3)
5531 return FailedCorrection(Typo, TypoLoc: TypoName.getLoc(), RecordFailure);
5532
5533 TypoCorrection BestTC = Consumer->getNextCorrection();
5534 TypoCorrection SecondBestTC = Consumer->getNextCorrection();
5535 if (!BestTC)
5536 return FailedCorrection(Typo, TypoLoc: TypoName.getLoc(), RecordFailure);
5537
5538 ED = BestTC.getEditDistance();
5539
5540 if (TypoLen >= 3 && ED > 0 && TypoLen / ED < 3) {
5541 // If this was an unqualified lookup and we believe the callback
5542 // object wouldn't have filtered out possible corrections, note
5543 // that no correction was found.
5544 return FailedCorrection(Typo, TypoLoc: TypoName.getLoc(), RecordFailure);
5545 }
5546
5547 // If only a single name remains, return that result.
5548 if (!SecondBestTC ||
5549 SecondBestTC.getEditDistance(Normalized: false) > BestTC.getEditDistance(Normalized: false)) {
5550 const TypoCorrection &Result = BestTC;
5551
5552 // Don't correct to a keyword that's the same as the typo; the keyword
5553 // wasn't actually in scope.
5554 if (ED == 0 && Result.isKeyword())
5555 return FailedCorrection(Typo, TypoLoc: TypoName.getLoc(), RecordFailure);
5556
5557 TypoCorrection TC = Result;
5558 TC.setCorrectionRange(SS, TypoName);
5559 checkCorrectionVisibility(SemaRef&: *this, TC);
5560 return TC;
5561 } else if (SecondBestTC && ObjCMessageReceiver) {
5562 // Prefer 'super' when we're completing in a message-receiver
5563 // context.
5564
5565 if (BestTC.getCorrection().getAsString() != "super") {
5566 if (SecondBestTC.getCorrection().getAsString() == "super")
5567 BestTC = std::move(SecondBestTC);
5568 else if ((*Consumer)["super"].front().isKeyword())
5569 BestTC = (*Consumer)["super"].front();
5570 }
5571 // Don't correct to a keyword that's the same as the typo; the keyword
5572 // wasn't actually in scope.
5573 if (BestTC.getEditDistance() == 0 ||
5574 BestTC.getCorrection().getAsString() != "super")
5575 return FailedCorrection(Typo, TypoLoc: TypoName.getLoc(), RecordFailure);
5576
5577 BestTC.setCorrectionRange(SS, TypoName);
5578 return BestTC;
5579 }
5580
5581 // Record the failure's location if needed and return an empty correction. If
5582 // this was an unqualified lookup and we believe the callback object did not
5583 // filter out possible corrections, also cache the failure for the typo.
5584 return FailedCorrection(Typo, TypoLoc: TypoName.getLoc(), RecordFailure: RecordFailure && !SecondBestTC);
5585}
5586
5587void TypoCorrection::addCorrectionDecl(NamedDecl *CDecl) {
5588 if (!CDecl) return;
5589
5590 if (isKeyword())
5591 CorrectionDecls.clear();
5592
5593 CorrectionDecls.push_back(Elt: CDecl);
5594
5595 if (!CorrectionName)
5596 CorrectionName = CDecl->getDeclName();
5597}
5598
5599std::string TypoCorrection::getAsString(const LangOptions &LO) const {
5600 if (CorrectionNameSpec) {
5601 std::string tmpBuffer;
5602 llvm::raw_string_ostream PrefixOStream(tmpBuffer);
5603 CorrectionNameSpec.print(OS&: PrefixOStream, Policy: PrintingPolicy(LO));
5604 PrefixOStream << CorrectionName;
5605 return PrefixOStream.str();
5606 }
5607
5608 return CorrectionName.getAsString();
5609}
5610
5611bool CorrectionCandidateCallback::ValidateCandidate(
5612 const TypoCorrection &candidate) {
5613 if (!candidate.isResolved())
5614 return true;
5615
5616 if (candidate.isKeyword())
5617 return WantTypeSpecifiers || WantExpressionKeywords || WantCXXNamedCasts ||
5618 WantRemainingKeywords || WantObjCSuper;
5619
5620 bool HasNonType = false;
5621 bool HasStaticMethod = false;
5622 bool HasNonStaticMethod = false;
5623 for (Decl *D : candidate) {
5624 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(Val: D))
5625 D = FTD->getTemplatedDecl();
5626 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Val: D)) {
5627 if (Method->isStatic())
5628 HasStaticMethod = true;
5629 else
5630 HasNonStaticMethod = true;
5631 }
5632 if (!isa<TypeDecl>(Val: D))
5633 HasNonType = true;
5634 }
5635
5636 if (IsAddressOfOperand && HasNonStaticMethod && !HasStaticMethod &&
5637 !candidate.getCorrectionSpecifier())
5638 return false;
5639
5640 return WantTypeSpecifiers || HasNonType;
5641}
5642
5643FunctionCallFilterCCC::FunctionCallFilterCCC(Sema &SemaRef, unsigned NumArgs,
5644 bool HasExplicitTemplateArgs,
5645 MemberExpr *ME)
5646 : NumArgs(NumArgs), HasExplicitTemplateArgs(HasExplicitTemplateArgs),
5647 CurContext(SemaRef.CurContext), MemberFn(ME) {
5648 WantTypeSpecifiers = false;
5649 WantFunctionLikeCasts = SemaRef.getLangOpts().CPlusPlus &&
5650 !HasExplicitTemplateArgs && NumArgs == 1;
5651 WantCXXNamedCasts = HasExplicitTemplateArgs && NumArgs == 1;
5652 WantRemainingKeywords = false;
5653}
5654
5655bool FunctionCallFilterCCC::ValidateCandidate(const TypoCorrection &candidate) {
5656 if (!candidate.getCorrectionDecl())
5657 return candidate.isKeyword();
5658
5659 for (auto *C : candidate) {
5660 FunctionDecl *FD = nullptr;
5661 NamedDecl *ND = C->getUnderlyingDecl();
5662 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(Val: ND))
5663 FD = FTD->getTemplatedDecl();
5664 if (!HasExplicitTemplateArgs && !FD) {
5665 if (!(FD = dyn_cast<FunctionDecl>(Val: ND)) && isa<ValueDecl>(Val: ND)) {
5666 // If the Decl is neither a function nor a template function,
5667 // determine if it is a pointer or reference to a function. If so,
5668 // check against the number of arguments expected for the pointee.
5669 QualType ValType = cast<ValueDecl>(Val: ND)->getType();
5670 if (ValType.isNull())
5671 continue;
5672 if (ValType->isAnyPointerType() || ValType->isReferenceType())
5673 ValType = ValType->getPointeeType();
5674 if (const FunctionProtoType *FPT = ValType->getAs<FunctionProtoType>())
5675 if (FPT->getNumParams() == NumArgs)
5676 return true;
5677 }
5678 }
5679
5680 // A typo for a function-style cast can look like a function call in C++.
5681 if ((HasExplicitTemplateArgs ? getAsTypeTemplateDecl(D: ND) != nullptr
5682 : isa<TypeDecl>(Val: ND)) &&
5683 CurContext->getParentASTContext().getLangOpts().CPlusPlus)
5684 // Only a class or class template can take two or more arguments.
5685 return NumArgs <= 1 || HasExplicitTemplateArgs || isa<CXXRecordDecl>(Val: ND);
5686
5687 // Skip the current candidate if it is not a FunctionDecl or does not accept
5688 // the current number of arguments.
5689 if (!FD || !(FD->getNumParams() >= NumArgs &&
5690 FD->getMinRequiredArguments() <= NumArgs))
5691 continue;
5692
5693 // If the current candidate is a non-static C++ method, skip the candidate
5694 // unless the method being corrected--or the current DeclContext, if the
5695 // function being corrected is not a method--is a method in the same class
5696 // or a descendent class of the candidate's parent class.
5697 if (const auto *MD = dyn_cast<CXXMethodDecl>(Val: FD)) {
5698 if (MemberFn || !MD->isStatic()) {
5699 const auto *CurMD =
5700 MemberFn
5701 ? dyn_cast_if_present<CXXMethodDecl>(Val: MemberFn->getMemberDecl())
5702 : dyn_cast_if_present<CXXMethodDecl>(Val: CurContext);
5703 const CXXRecordDecl *CurRD =
5704 CurMD ? CurMD->getParent()->getCanonicalDecl() : nullptr;
5705 const CXXRecordDecl *RD = MD->getParent()->getCanonicalDecl();
5706 if (!CurRD || (CurRD != RD && !CurRD->isDerivedFrom(Base: RD)))
5707 continue;
5708 }
5709 }
5710 return true;
5711 }
5712 return false;
5713}
5714
5715void Sema::diagnoseTypo(const TypoCorrection &Correction,
5716 const PartialDiagnostic &TypoDiag,
5717 bool ErrorRecovery) {
5718 diagnoseTypo(Correction, TypoDiag, PrevNote: PDiag(DiagID: diag::note_previous_decl),
5719 ErrorRecovery);
5720}
5721
5722/// Find which declaration we should import to provide the definition of
5723/// the given declaration.
5724static const NamedDecl *getDefinitionToImport(const NamedDecl *D) {
5725 if (const auto *VD = dyn_cast<VarDecl>(Val: D))
5726 return VD->getDefinition();
5727 if (const auto *FD = dyn_cast<FunctionDecl>(Val: D))
5728 return FD->getDefinition();
5729 if (const auto *TD = dyn_cast<TagDecl>(Val: D))
5730 return TD->getDefinition();
5731 if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(Val: D))
5732 return ID->getDefinition();
5733 if (const auto *PD = dyn_cast<ObjCProtocolDecl>(Val: D))
5734 return PD->getDefinition();
5735 if (const auto *TD = dyn_cast<TemplateDecl>(Val: D))
5736 if (const NamedDecl *TTD = TD->getTemplatedDecl())
5737 return getDefinitionToImport(D: TTD);
5738 return nullptr;
5739}
5740
5741void Sema::diagnoseMissingImport(SourceLocation Loc, const NamedDecl *Decl,
5742 MissingImportKind MIK, bool Recover) {
5743 // Suggest importing a module providing the definition of this entity, if
5744 // possible.
5745 const NamedDecl *Def = getDefinitionToImport(D: Decl);
5746 if (!Def)
5747 Def = Decl;
5748
5749 Module *Owner = getOwningModule(Entity: Def);
5750 assert(Owner && "definition of hidden declaration is not in a module");
5751
5752 llvm::SmallVector<Module*, 8> OwningModules;
5753 OwningModules.push_back(Elt: Owner);
5754 auto Merged = Context.getModulesWithMergedDefinition(Def);
5755 llvm::append_range(C&: OwningModules, R&: Merged);
5756
5757 diagnoseMissingImport(Loc, Decl: Def, DeclLoc: Def->getLocation(), Modules: OwningModules, MIK,
5758 Recover);
5759}
5760
5761/// Get a "quoted.h" or <angled.h> include path to use in a diagnostic
5762/// suggesting the addition of a #include of the specified file.
5763static std::string getHeaderNameForHeader(Preprocessor &PP, FileEntryRef E,
5764 llvm::StringRef IncludingFile) {
5765 bool IsAngled = false;
5766 auto Path = PP.getHeaderSearchInfo().suggestPathToFileForDiagnostics(
5767 File: E, MainFile: IncludingFile, IsAngled: &IsAngled);
5768 return (IsAngled ? '<' : '"') + Path + (IsAngled ? '>' : '"');
5769}
5770
5771void Sema::diagnoseMissingImport(SourceLocation UseLoc, const NamedDecl *Decl,
5772 SourceLocation DeclLoc,
5773 ArrayRef<Module *> Modules,
5774 MissingImportKind MIK, bool Recover) {
5775 assert(!Modules.empty());
5776
5777 // See https://github.com/llvm/llvm-project/issues/73893. It is generally
5778 // confusing than helpful to show the namespace is not visible.
5779 if (isa<NamespaceDecl>(Val: Decl))
5780 return;
5781
5782 auto NotePrevious = [&] {
5783 // FIXME: Suppress the note backtrace even under
5784 // -fdiagnostics-show-note-include-stack. We don't care how this
5785 // declaration was previously reached.
5786 Diag(Loc: DeclLoc, DiagID: diag::note_unreachable_entity) << (int)MIK;
5787 };
5788
5789 // Weed out duplicates from module list.
5790 llvm::SmallVector<Module*, 8> UniqueModules;
5791 llvm::SmallDenseSet<Module*, 8> UniqueModuleSet;
5792 for (auto *M : Modules) {
5793 if (M->isExplicitGlobalModule() || M->isPrivateModule())
5794 continue;
5795 if (UniqueModuleSet.insert(V: M).second)
5796 UniqueModules.push_back(Elt: M);
5797 }
5798
5799 // Try to find a suitable header-name to #include.
5800 std::string HeaderName;
5801 if (OptionalFileEntryRef Header =
5802 PP.getHeaderToIncludeForDiagnostics(IncLoc: UseLoc, MLoc: DeclLoc)) {
5803 if (const FileEntry *FE =
5804 SourceMgr.getFileEntryForID(FID: SourceMgr.getFileID(SpellingLoc: UseLoc)))
5805 HeaderName =
5806 getHeaderNameForHeader(PP, E: *Header, IncludingFile: FE->tryGetRealPathName());
5807 }
5808
5809 // If we have a #include we should suggest, or if all definition locations
5810 // were in global module fragments, don't suggest an import.
5811 if (!HeaderName.empty() || UniqueModules.empty()) {
5812 // FIXME: Find a smart place to suggest inserting a #include, and add
5813 // a FixItHint there.
5814 Diag(Loc: UseLoc, DiagID: diag::err_module_unimported_use_header)
5815 << (int)MIK << Decl << !HeaderName.empty() << HeaderName;
5816 // Produce a note showing where the entity was declared.
5817 NotePrevious();
5818 if (Recover)
5819 createImplicitModuleImportForErrorRecovery(Loc: UseLoc, Mod: Modules[0]);
5820 return;
5821 }
5822
5823 Modules = UniqueModules;
5824
5825 auto GetModuleNameForDiagnostic = [this](const Module *M) -> std::string {
5826 if (M->isModuleMapModule())
5827 return M->getFullModuleName();
5828
5829 if (M->isImplicitGlobalModule())
5830 M = M->getTopLevelModule();
5831
5832 // If the current module unit is in the same module with M, it is OK to show
5833 // the partition name. Otherwise, it'll be sufficient to show the primary
5834 // module name.
5835 if (getASTContext().isInSameModule(M1: M, M2: getCurrentModule()))
5836 return M->getTopLevelModuleName().str();
5837 else
5838 return M->getPrimaryModuleInterfaceName().str();
5839 };
5840
5841 if (Modules.size() > 1) {
5842 std::string ModuleList;
5843 unsigned N = 0;
5844 for (const auto *M : Modules) {
5845 ModuleList += "\n ";
5846 if (++N == 5 && N != Modules.size()) {
5847 ModuleList += "[...]";
5848 break;
5849 }
5850 ModuleList += GetModuleNameForDiagnostic(M);
5851 }
5852
5853 Diag(Loc: UseLoc, DiagID: diag::err_module_unimported_use_multiple)
5854 << (int)MIK << Decl << ModuleList;
5855 } else {
5856 // FIXME: Add a FixItHint that imports the corresponding module.
5857 Diag(Loc: UseLoc, DiagID: diag::err_module_unimported_use)
5858 << (int)MIK << Decl << GetModuleNameForDiagnostic(Modules[0]);
5859 }
5860
5861 NotePrevious();
5862
5863 // Try to recover by implicitly importing this module.
5864 if (Recover)
5865 createImplicitModuleImportForErrorRecovery(Loc: UseLoc, Mod: Modules[0]);
5866}
5867
5868void Sema::diagnoseTypo(const TypoCorrection &Correction,
5869 const PartialDiagnostic &TypoDiag,
5870 const PartialDiagnostic &PrevNote,
5871 bool ErrorRecovery) {
5872 std::string CorrectedStr = Correction.getAsString(LO: getLangOpts());
5873 std::string CorrectedQuotedStr = Correction.getQuoted(LO: getLangOpts());
5874 FixItHint FixTypo = FixItHint::CreateReplacement(
5875 RemoveRange: Correction.getCorrectionRange(), Code: CorrectedStr);
5876
5877 // Maybe we're just missing a module import.
5878 if (Correction.requiresImport()) {
5879 NamedDecl *Decl = Correction.getFoundDecl();
5880 assert(Decl && "import required but no declaration to import");
5881
5882 diagnoseMissingImport(Loc: Correction.getCorrectionRange().getBegin(), Decl,
5883 MIK: MissingImportKind::Declaration, Recover: ErrorRecovery);
5884 return;
5885 }
5886
5887 Diag(Loc: Correction.getCorrectionRange().getBegin(), PD: TypoDiag)
5888 << CorrectedQuotedStr << (ErrorRecovery ? FixTypo : FixItHint());
5889
5890 NamedDecl *ChosenDecl =
5891 Correction.isKeyword() ? nullptr : Correction.getFoundDecl();
5892
5893 // For builtin functions which aren't declared anywhere in source,
5894 // don't emit the "declared here" note.
5895 if (const auto *FD = dyn_cast_if_present<FunctionDecl>(Val: ChosenDecl);
5896 FD && FD->getBuiltinID() &&
5897 PrevNote.getDiagID() == diag::note_previous_decl &&
5898 Correction.getCorrectionRange().getBegin() == FD->getBeginLoc()) {
5899 ChosenDecl = nullptr;
5900 }
5901
5902 if (PrevNote.getDiagID() && ChosenDecl)
5903 Diag(Loc: ChosenDecl->getLocation(), PD: PrevNote)
5904 << CorrectedQuotedStr << (ErrorRecovery ? FixItHint() : FixTypo);
5905
5906 // Add any extra diagnostics.
5907 for (const PartialDiagnostic &PD : Correction.getExtraDiagnostics())
5908 Diag(Loc: Correction.getCorrectionRange().getBegin(), PD);
5909}
5910
5911void Sema::ActOnPragmaDump(Scope *S, SourceLocation IILoc, IdentifierInfo *II) {
5912 DeclarationNameInfo Name(II, IILoc);
5913 LookupResult R(*this, Name, LookupAnyName,
5914 RedeclarationKind::NotForRedeclaration);
5915 R.suppressDiagnostics();
5916 R.setHideTags(false);
5917 LookupName(R, S);
5918 R.dump();
5919}
5920
5921void Sema::ActOnPragmaDump(Expr *E) {
5922 E->dump();
5923}
5924
5925RedeclarationKind Sema::forRedeclarationInCurContext() const {
5926 // A declaration with an owning module for linkage can never link against
5927 // anything that is not visible. We don't need to check linkage here; if
5928 // the context has internal linkage, redeclaration lookup won't find things
5929 // from other TUs, and we can't safely compute linkage yet in general.
5930 if (cast<Decl>(Val: CurContext)->getOwningModuleForLinkage())
5931 return RedeclarationKind::ForVisibleRedeclaration;
5932 return RedeclarationKind::ForExternalRedeclaration;
5933}
5934