clang 24.0.0git
SemaLookup.cpp
Go to the documentation of this file.
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
16#include "clang/AST/Decl.h"
17#include "clang/AST/DeclCXX.h"
19#include "clang/AST/DeclObjC.h"
21#include "clang/AST/Expr.h"
22#include "clang/AST/ExprCXX.h"
29#include "clang/Sema/DeclSpec.h"
30#include "clang/Sema/Lookup.h"
31#include "clang/Sema/Overload.h"
33#include "clang/Sema/Scope.h"
35#include "clang/Sema/Sema.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(Ctx, Ctx);
123 } else if (!Ctx || Ctx->isFunctionOrMethod()) {
124 for (auto *I : S->using_directives())
125 if (SemaRef.isVisible(I))
126 visit(I, 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(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(NS).second)
151 return;
152
153 addUsingDirective(UD, EffectiveDC);
154 addUsingDirectives(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(UD) && visited.insert(NS).second) {
166 addUsingDirective(UD, EffectiveDC);
167 queue.push_back(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(EffectiveDC))
190 Common = Common->getParent();
191 Common = Common->getPrimaryContext();
192
193 list.push_back(UnqualUsingEntry(UD->getNominatedNamespace(), Common));
194 }
195
196 void done() { llvm::stable_sort(list, 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(std::equal_range(begin(), end(),
206 DC->getPrimaryContext(),
207 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) {
224 IDNS = Decl::IDNS_Ordinary;
225 if (CPlusPlus) {
227 if (Redeclaration)
229 }
230 if (Redeclaration)
232 break;
233
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");
239 break;
240
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)
252 } else {
253 IDNS = Decl::IDNS_Tag;
254 }
255 break;
256
258 IDNS = Decl::IDNS_Label;
259 break;
260
262 IDNS = Decl::IDNS_Member;
263 if (CPlusPlus)
265 break;
266
269 break;
270
273 break;
274
276 assert(Redeclaration && "should only be used for redecl lookup");
280 break;
281
284 break;
285
288 break;
289
292 break;
293
298 break;
299 }
300 return IDNS;
301}
302
303void LookupResult::configure() {
304 IDNS = getIDNS(LookupKind, getSema().getLangOpts().CPlusPlus,
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:
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(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 &&
345 assert((Paths != nullptr) ==
346 (ResultKind == LookupResultKind::Ambiguous &&
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.
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.
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.
380 !isa<UsingShadowDecl>(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>(EUnderlying);
397 bool WantTag =
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>(DUnderlying)) {
407 const auto *EFD = cast<FunctionDecl>(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>(DUnderlying)) {
419 const auto *ETD = cast<TemplateDecl>(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) {
433 ETD->getTemplateParameters()->getParam(I)) &&
435 DTD->getTemplateParameters()->getParam(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>(DUnderlying)) {
443 const auto *EVD = cast<VarDecl>(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(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>(DUnderlying) && !isa<VarDecl>(DUnderlying)) {
454 // If the existing declaration is hidden, prefer the new one. Otherwise,
455 // keep what we've got.
456 return !S.isVisible(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();
485}
486
487/// Resolves the result kind of this lookup.
489 unsigned N = Decls.size();
490
491 // Fast case: no possible ambiguity.
492 if (N == 0) {
493 assert(ResultKind == LookupResultKind::NotFound ||
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();
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();
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>(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>(D)) {
545 bool Hidden = false;
546 for (auto *OtherDecl : Decls) {
547 if (canHideTag(OtherDecl) && !OtherDecl->isInvalidDecl() &&
548 getContextForScopeMatching(OtherDecl)->Equals(
549 getContextForScopeMatching(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>(D)) {
566 auto UniqueResult = UniqueTypes.insert(
567 std::make_pair(getSema().Context.getCanonicalTypeDeclType(TD), 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(std::make_pair(D, 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.
588 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
597 HasUnresolved = true;
598 } else if (isa<TagDecl>(D)) {
599 if (HasTag)
600 Ambiguous = true;
601 HasTag = true;
602 } else if (isa<FunctionTemplateDecl>(D)) {
603 HasFunction = true;
604 HasFunctionTemplate = true;
605 } else if (isa<FunctionDecl>(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(HasNonFunction,
614 D)) {
615 EquivalentNonFunctions.push_back(D);
616 RemovedDecls.set(I);
617 continue;
618 }
619 if (D->isPlaceholderVar(getSema().getLangOpts()) &&
621 getContextForScopeMatching(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)
634 getNameLoc(), HasNonFunction, 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(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)
649 else if (Ambiguous)
651 else if (HasUnresolved)
653 else if (N > 1 || HasFunctionTemplate)
655 else
656 ResultKind = LookupResultKind::Found;
657}
658
659void LookupResult::addDeclsFromBasePaths(const CXXBasePaths &P) {
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(*DI);
665}
666
668 Paths = new CXXBasePaths;
669 Paths->swap(P);
670 addDeclsFromBasePaths(*Paths);
671 resolveKind();
673}
674
676 Paths = new CXXBasePaths;
677 Paths->swap(P);
678 addDeclsFromBasePaths(*Paths);
679 resolveKind();
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, 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(SourceLocation(), 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) {
714 if (Result.empty())
715 return diagOpenCLBuiltinTypeError(S, "enum", Name);
716 EnumDecl *Decl = Result.getAsSingle<EnumDecl>();
717 if (!Decl)
718 return diagOpenCLBuiltinTypeError(S, "enum", Name);
720}
721
722/// Lookup an OpenCL typedef type.
723static QualType getOpenCLTypedefType(Sema &S, llvm::StringRef Name) {
727 if (Result.empty())
728 return diagOpenCLBuiltinTypeError(S, "typedef", Name);
729 TypedefNameDecl *Decl = Result.getAsSingle<TypedefNameDecl>();
730 if (!Decl)
731 return diagOpenCLBuiltinTypeError(S, "typedef", Name);
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) .
748 Sema &S, const OpenCLBuiltinStruct &OpenCLBuiltin, unsigned &GenTypeMaxCnt,
749 SmallVector<QualType, 1> &RetTypes,
751 // Get the QualType instances of the return types.
752 unsigned Sig = SignatureTable[OpenCLBuiltin.SigTableIndex];
753 OCL2Qual(S, TypeTable[Sig], 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++) {
760 OCL2Qual(S, TypeTable[SignatureTable[OpenCLBuiltin.SigTableIndex + Index]],
761 Ty);
762 GenTypeMaxCnt = (Ty.size() > GenTypeMaxCnt) ? Ty.size() : GenTypeMaxCnt;
763 ArgTypes.push_back(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.
777 ASTContext &Context, unsigned GenTypeMaxCnt,
778 std::vector<QualType> &FunctionList, SmallVector<QualType, 1> &RetTypes,
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++) {
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(ArgTypes[A][Idx]);
805 }
806
807 FunctionList.push_back(Context.getFunctionType(
808 RetTypes[(RetTypes.size() != 1) ? IGenType : 0], ArgList, 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.
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(Context.getLangOpts(),
841 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()) {
850 Extensions.split(ExtVec, " ");
851 bool AllExtensionsDefined = true;
852 for (StringRef Ext : ExtVec) {
853 if (!S.getPreprocessor().isMacroDefined(Ext)) {
854 AllExtensionsDefined = false;
855 break;
856 }
857 }
858 if (!AllExtensionsDefined)
859 continue;
860 }
861
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 Context, Parent, Loc, Loc, II, FTy, /*TInfo=*/nullptr, SC_Extern,
885 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>(FTy);
892 for (unsigned IParm = 0, e = FP->getNumParams(); IParm != e; ++IParm) {
894 Context, NewOpenCLBuiltin, SourceLocation(), SourceLocation(),
895 nullptr, FP->getParamType(IParm), nullptr, SC_None, nullptr);
896 Parm->setScopeInfo(0, IParm);
897 ParmList.push_back(Parm);
898 }
899 NewOpenCLBuiltin->setParams(ParmList);
900
901 // Add function attributes.
902 if (OpenCLBuiltin.IsPure)
903 NewOpenCLBuiltin->addAttr(PureAttr::CreateImplicit(Context));
904 if (OpenCLBuiltin.IsConst)
905 NewOpenCLBuiltin->addAttr(ConstAttr::CreateImplicit(Context));
906 if (OpenCLBuiltin.IsConv)
907 NewOpenCLBuiltin->addAttr(ConvergentAttr::CreateImplicit(Context));
908
909 if (!S.getLangOpts().OpenCLCPlusPlus)
910 NewOpenCLBuiltin->addAttr(OverloadableAttr::CreateImplicit(Context));
911
912 LR.addDecl(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
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 ||
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(II->getName());
955 if (Index.first) {
956 InsertOCLBuiltinDeclarationsFromTable(*this, R, II, Index.first - 1,
957 Index.second);
958 return true;
959 }
960 }
961
962 if (RISCV().DeclareRVVBuiltins || RISCV().DeclareSiFiveVectorBuiltins ||
963 RISCV().DeclareAndesVectorBuiltins) {
964 if (!RISCV().IntrinsicManager)
966
967 RISCV().IntrinsicManager->InitIntrinsicList();
968
969 if (RISCV().IntrinsicManager->CreateIntrinsicIfFound(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.
978 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
979 return false;
980
981 if (NamedDecl *D =
982 LazilyCreateBuiltin(II, BuiltinID, TUScope,
983 R.isForRedeclaration(), 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.
998 ASTContext &Context = Sema.Context;
999 LookupResult Result(Sema, &Context.Idents.get("objc_super"), SourceLocation(),
1002 if (Result.getResultKind() == LookupResultKind::Found)
1003 if (const TagDecl *TD = Result.getAsSingle<TagDecl>())
1004 Context.setObjCSuperType(Context.getCanonicalTagType(TD));
1005}
1006
1008 if (ID == Builtin::BIobjc_msgSendSuper)
1010}
1011
1012/// Determine whether we can declare a special member function within
1013/// the class at this point.
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
1025 return;
1026
1027 // If the default constructor has not yet been declared, do so now.
1028 if (Class->needsImplicitDefaultConstructor())
1030
1031 // If the copy constructor has not yet been declared, do so now.
1032 if (Class->needsImplicitCopyConstructor())
1034
1035 // If the copy assignment operator has not yet been declared, do so now.
1036 if (Class->needsImplicitCopyAssignment())
1038
1039 if (getLangOpts().CPlusPlus11) {
1040 // If the move constructor has not yet been declared, do so now.
1041 if (Class->needsImplicitMoveConstructor())
1043
1044 // If the move assignment operator has not yet been declared, do so now.
1045 if (Class->needsImplicitMoveAssignment())
1047 }
1048
1049 // If the destructor has not yet been declared, do so now.
1050 if (Class->needsImplicitDestructor())
1052}
1053
1054/// Determine whether this is the name of an implicitly-declared
1055/// special member function.
1057 switch (Name.getNameKind()) {
1060 return true;
1061
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.
1075 DeclarationName Name,
1076 SourceLocation Loc,
1077 const DeclContext *DC) {
1078 if (!DC)
1079 return;
1080
1081 switch (Name.getNameKind()) {
1083 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC))
1084 if (Record->getDefinition() && CanDeclareSpecialMemberFunction(Record)) {
1085 CXXRecordDecl *Class = const_cast<CXXRecordDecl *>(Record);
1086 if (Record->needsImplicitDefaultConstructor())
1088 if (Record->needsImplicitCopyConstructor())
1090 if (S.getLangOpts().CPlusPlus11 &&
1091 Record->needsImplicitMoveConstructor())
1093 }
1094 break;
1095
1097 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC))
1098 if (Record->getDefinition() && Record->needsImplicitDestructor() &&
1101 break;
1102
1104 if (Name.getCXXOverloadedOperator() != OO_Equal)
1105 break;
1106
1107 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC)) {
1108 if (Record->getDefinition() && CanDeclareSpecialMemberFunction(Record)) {
1109 CXXRecordDecl *Class = const_cast<CXXRecordDecl *>(Record);
1110 if (Record->needsImplicitCopyAssignment())
1112 if (S.getLangOpts().CPlusPlus11 &&
1113 Record->needsImplicitMoveAssignment())
1115 }
1116 }
1117 break;
1118
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, R.getLookupName(), R.getNameLoc(),
1136 DC);
1137
1138 // Perform lookup into this declaration context.
1139 DeclContext::lookup_result DR = DC->lookup(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()
1152 R.getLookupName().getCXXNameType()->isDependentType() ||
1153 !isa<CXXRecordDecl>(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. [...]
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() ==
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>(*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(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!
1212 EPI.ExceptionSpec = EST_None;
1213 QualType ExpectedType = R.getSema().Context.getFunctionType(
1214 R.getLookupName().getCXXNameType(), {}, EPI);
1215
1216 // Perform template argument deduction against the type that we would
1217 // expect the function to have.
1218 if (R.getSema().DeduceTemplateArguments(ConvTemplate, nullptr, ExpectedType,
1219 Specialization, Info) ==
1221 R.addDecl(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, 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(NS))
1242 if (LookupDirect(S, R, UUE.getNominatedNamespace()))
1243 Found = true;
1244
1245 R.resolveKind();
1246
1247 return Found;
1248}
1249
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.
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() &
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
1296 for (Scope *PreS = S; PreS; PreS = PreS->getParent())
1297 if (DeclContext *DC = PreS->getEntity())
1298 DeclareImplicitMemberFunctionsWithName(*this, Name, 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.
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(*I); ++I) {
1350 if (NamedDecl *ND = R.getAcceptableDecl(*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(*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(ND);
1373 }
1374 }
1375 if (!SearchNamespaceScope) {
1376 R.resolveKind();
1377 if (S->isClassScope())
1378 if (auto *Record = dyn_cast_if_present<CXXRecordDecl>(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(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>(Ctx)) {
1408 if (Method->isInstanceMethod() && Name.getAsIdentifierInfo())
1409 if (ObjCInterfaceDecl *Class = Method->getClassInterface()) {
1410 ObjCInterfaceDecl *ClassDeclared;
1411 if (ObjCIvarDecl *Ivar = Class->lookupInstanceVariable(
1412 Name.getAsIdentifierInfo(),
1413 ClassDeclared)) {
1414 if (NamedDecl *ND = R.getAcceptableDecl(Ivar)) {
1415 R.addDecl(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(UCtx, 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(InnermostFileScope))
1444 InnermostFileScope = InnermostFileScope->getParent();
1445 UDirs.visitScopeChain(Initial, InnermostFileScope);
1446
1447 UDirs.done();
1448
1449 VisitedUsingDirectives = true;
1450 }
1451
1452 if (CppNamespaceLookup(*this, R, Context, 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, 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(Initial, 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(*I); ++I) {
1503 if (NamedDecl *ND = R.getAcceptableDecl(*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(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(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(*this, R, Context, 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
1558 if (auto *M = getCurrentModule())
1559 Context.mergeDefinitionIntoModule(ND, M);
1560 else
1561 // We're not building a module; just make the definition visible.
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>(ND))
1567 for (auto *Param : *TD->getTemplateParameters())
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>(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(ECD->getDeclName()).empty())
1581 RedeclCtx->makeDeclVisibleInContext(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>(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>(Entity)) {
1595 Entity = Pattern->getDefinition();
1596 } else if (EnumDecl *ED = dyn_cast<EnumDecl>(Entity)) {
1597 if (auto *Pattern = ED->getTemplateInstantiationPattern())
1598 Entity = Pattern->getDefinition();
1599 } else if (VarDecl *VD = dyn_cast<VarDecl>(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, cast<Decl>(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(*this, CodeSynthesisContexts[I].Entity) :
1620 nullptr;
1621 if (M && !LookupModulesCache.insert(M).second)
1622 M = nullptr;
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(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(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(ModuleScopes,
1670 [&M](const ModuleScope &MS) { return MS.Module == M; }) ||
1671 getASTContext().isInSameModule(M, Current)) {
1672 UsableModuleUnitsCache.insert(M);
1673 return true;
1674 }
1675
1676 return false;
1677}
1678
1680 for (const Module *Merged : Context.getModulesWithMergedDefinition(Def))
1681 if (isModuleVisible(Merged))
1682 return true;
1683 return false;
1684}
1685
1687 for (const Module *Merged : Context.getModulesWithMergedDefinition(Def))
1688 if (isUsableModule(Merged))
1689 return true;
1690 return false;
1691}
1692
1693template <typename ParmDecl>
1694static bool
1697 Sema::AcceptableKind Kind) {
1698 if (!D->hasDefaultArgument())
1699 return false;
1700
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(S.getOwningModule(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
1720 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules,
1721 Sema::AcceptableKind Kind) {
1722 if (auto *P = dyn_cast<TemplateTypeParmDecl>(D))
1723 return ::hasAcceptableDefaultArgument(*this, P, Modules, Kind);
1724
1725 if (auto *P = dyn_cast<NonTypeTemplateParmDecl>(D))
1726 return ::hasAcceptableDefaultArgument(*this, P, Modules, Kind);
1727
1728 return ::hasAcceptableDefaultArgument(
1729 *this, cast<TemplateTemplateParmDecl>(D), Modules, Kind);
1730}
1731
1737
1743
1744template <typename Filter>
1745static bool
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>(Redecl);
1753 if (!F(R))
1754 continue;
1755
1756 if (S.isAcceptable(R, Kind))
1757 return true;
1758
1759 HasFilteredRedecls = true;
1760
1761 if (Modules)
1762 Modules->push_back(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
1775 Sema::AcceptableKind Kind) {
1777 S, D, Modules,
1778 [](const NamedDecl *D) {
1779 if (auto *RD = dyn_cast<CXXRecordDecl>(D))
1780 return RD->getTemplateSpecializationKind() ==
1782 if (auto *FD = dyn_cast<FunctionDecl>(D))
1783 return FD->getTemplateSpecializationKind() ==
1785 if (auto *VD = dyn_cast<VarDecl>(D))
1786 return VD->getTemplateSpecializationKind() ==
1788 llvm_unreachable("unknown explicit specialization kind");
1789 },
1790 Kind);
1791}
1792
1794 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
1795 return ::hasAcceptableExplicitSpecialization(*this, D, Modules,
1797}
1798
1800 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
1801 return ::hasAcceptableExplicitSpecialization(*this, D, Modules,
1803}
1804
1805static bool
1808 Sema::AcceptableKind Kind) {
1809 assert(isa<CXXRecordDecl>(D->getDeclContext()) &&
1810 "not a member specialization");
1812 S, D, Modules,
1813 [](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
1832
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(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(DeclModule,
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>(DC) ||
1866 isa<ExportDecl>(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.
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>(DC)) {
1884 if (const auto *TD = DCD->getDescribedTemplate()) {
1885 TemplateParameterList *TPL = TD->getTemplateParameters();
1886 auto Index = getDepthAndIndex(D).second;
1887 SearchDefinitions = Index >= TPL->size() || TPL->getParam(Index) != D;
1888 }
1889 }
1890 if (SearchDefinitions)
1891 AcceptableWithinParent =
1892 SemaRef.hasAcceptableDefinition(cast<NamedDecl>(DC), Kind);
1893 else
1894 AcceptableWithinParent =
1895 isAcceptable(SemaRef, cast<NamedDecl>(DC), Kind);
1896 } else if (isa<ParmVarDecl>(D) ||
1897 (isa<FunctionDecl>(DC) && !SemaRef.getLangOpts().CPlusPlus))
1898 AcceptableWithinParent = isAcceptable(SemaRef, cast<NamedDecl>(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 {
1905 AcceptableWithinParent = true;
1906 break;
1907 }
1908 DC = DC->getLexicalParent();
1909 } while (!IsEffectivelyFileContext(DC));
1910 } else if (auto *FD = dyn_cast<FunctionDecl>(DC);
1911 FD && !FD->getDefinition()) {
1912 // This is possible as the definition are removed in reduced BMI.
1913 AcceptableWithinParent = isAcceptable(SemaRef, FD, Kind);
1914 } else {
1915 AcceptableWithinParent =
1916 SemaRef.hasAcceptableDefinition(cast<NamedDecl>(DC), Kind);
1917 }
1918
1919 if (AcceptableWithinParent && SemaRef.CodeSynthesisContexts.empty() &&
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.
1926 }
1927 return AcceptableWithinParent;
1928 }
1929
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(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(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(LookupModules, [&](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(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(CurrentM->getTopLevelModule()->Imports, 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(*this, 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.
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>(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(IDNS) &&
2112 return ND;
2113 }
2114
2115 return nullptr;
2116}
2117
2120 assert(!isVisible(D) && "not in slow case");
2122 *this, D, Modules, [](const NamedDecl *) { return true; },
2124}
2125
2127 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
2128 assert(!isReachable(D) && "not in slow case");
2130 *this, D, Modules, [](const NamedDecl *) { return true; },
2132}
2133
2134NamedDecl *LookupResult::getAcceptableDeclSlow(NamedDecl *D) const {
2135 if (auto *ND = dyn_cast<NamespaceDecl>(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(Key))
2144 return Acceptable;
2145 auto *Acceptable = isVisible(getSema(), Key)
2146 ? Key
2147 : findAcceptableDecl(getSema(), Key, IDNS);
2148 if (Acceptable)
2149 getSema().VisibleNamespaceCache.insert(std::make_pair(Key, Acceptable));
2150 return Acceptable;
2151 }
2152
2153 return findAcceptableDecl(getSema(), D, IDNS);
2154}
2155
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, Sema::AcceptableKind::Visible);
2164}
2165
2167 if (D->isUnconditionallyVisible())
2168 return true;
2169
2170 return isAcceptableSlow(SemaRef, D, Sema::AcceptableKind::Reachable);
2171}
2172
2174 // We should check the visibility at the callsite already.
2175 if (isVisible(SemaRef, 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(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>(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>(DC))
2216 return SemaRef.hasReachableDefinition(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(*I)) {
2251 if (NameKind == LookupRedeclarationWithLinkage) {
2252 // Determine whether this (or a previous) declaration is
2253 // out-of-scope.
2254 if (!LeftStartingScope && !S->isDeclScope(*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 &&
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.
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
2290 for (++LastI; LastI != IEnd; ++LastI) {
2291 if (S) {
2292 // Match based on scope.
2293 if (!S->isDeclScope(*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(*LastI))
2305 R.addDecl(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.
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.
2366
2367 // We have at least added all these contexts to the queue.
2369 Visited.insert(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(I) && Visited.insert(ND).second)
2376 Queue.push_back(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
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, DirectR, 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(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(I) && Visited.insert(Nom).second)
2424 Queue.push_back(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
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(Context);
2460 }
2461 ~QualifiedLookupInScope() {
2462 if (Source)
2463 Source->FinishedQualifiedLookup(Context);
2464 }
2465 } QL(ExternalSource.get(), LookupCtx);
2466
2467 CXXRecordDecl *LookupRec = dyn_cast<CXXRecordDecl>(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();
2482 Name.getCXXNameType()->isDependentType()) {
2483 R.setNotFoundInCurrentInstantiation();
2484 return false;
2485 }
2486 }
2487
2488 if (LookupDirect(*this, R, 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(*this, R, 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(IDNS))
2548 return true;
2549 }
2550 return false;
2551 };
2552
2553 CXXBasePaths Paths;
2554 Paths.setOrigin(LookupRec);
2555 if (!LookupRec->lookupInBases(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(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,
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(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(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>(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({AResult, /*FoundInB*/false});
2632 unsigned Found = 0;
2633 for (; BResult; BResult = Next(BIt, BEnd)) {
2634 auto It = AResults.find(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(SubobjectAccess, 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(PathElement.Base->getType());
2659 SubobjectNumber = PathElement.SubobjectNumber;
2660 continue;
2661 }
2662
2663 if (SubobjectType !=
2664 Context.getCanonicalType(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(SubobjectAccess,
2704 (*I)->getAccess());
2705 if (NamedDecl *ND = R.getAcceptableDecl(*I))
2706 R.addDecl(ND, AS);
2707 }
2708 R.resolveKind();
2709 return true;
2710}
2711
2713 CXXScopeSpec &SS) {
2714 NestedNameSpecifier Qualifier = SS.getScopeRep();
2715 if (Qualifier.getKind() == NestedNameSpecifier::Kind::MicrosoftSuper)
2716 return LookupInSuper(R, Qualifier.getAsMicrosoftSuper());
2717 return LookupQualifiedName(R, LookupCtx);
2718}
2719
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(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, EnteringContext))) {
2745 // The declaration context must be complete.
2746 if (!DC->isDependentContext() && RequireCompleteDeclContext(*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, Qualifier.getAsMicrosoftSuper());
2755 }
2756 IsDependent = !DC && isDependentScopeSpecifier(*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, 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
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(Class));
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(I.getDecl(),
2789 CXXRecordDecl::MergeAccess(BaseSpec.getAccessSpecifier(),
2790 I.getAccess()));
2791 }
2792
2793 Result.suppressDiagnostics();
2794 }
2795
2796 R.resolveKind();
2797 R.setNamingClass(Class);
2798
2799 return !R.empty();
2800}
2801
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()) {
2811 CXXBasePaths *Paths = Result.getBasePaths();
2812 QualType SubobjectType = Paths->front().back().Base->getType();
2813 Diag(NameLoc, diag::err_ambiguous_member_multiple_subobjects)
2814 << Name << SubobjectType << getAmbiguousPathsDisplayString(*Paths)
2815 << LookupRange;
2816
2818 while (isa<CXXMethodDecl>(*Found) &&
2819 cast<CXXMethodDecl>(*Found)->isStatic())
2820 ++Found;
2821
2822 Diag((*Found)->getLocation(), diag::note_ambiguous_member_found);
2823 break;
2824 }
2825
2827 Diag(NameLoc, 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(Result.getIdentifierNamespace()))
2837 continue;
2838 if (DeclsPrinted.insert(D).second) {
2839 if (const auto *TD = dyn_cast<TypedefNameDecl>(D->getUnderlyingDecl()))
2840 Diag(D->getLocation(), diag::note_ambiguous_member_type_found)
2841 << TD->getUnderlyingType();
2842 else if (const auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl()))
2843 Diag(D->getLocation(), diag::note_ambiguous_member_type_found)
2844 << Context.getTypeDeclType(TD);
2845 else
2846 Diag(D->getLocation(), diag::note_ambiguous_member_found);
2847 }
2848 }
2849 break;
2850 }
2851
2853 Diag(NameLoc, diag::err_ambiguous_tag_hiding) << Name << LookupRange;
2854
2856
2857 for (auto *D : Result)
2858 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
2859 TagDecls.insert(TD);
2860 Diag(TD->getLocation(), diag::note_hidden_tag);
2861 }
2862
2863 for (auto *D : Result)
2864 if (!isa<TagDecl>(D))
2865 Diag(D->getLocation(), 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(F.next()))
2871 F.erase();
2872 }
2873 F.done();
2874 break;
2875 }
2876
2878 Diag(NameLoc, diag::err_using_placeholder_variable) << Name << LookupRange;
2879 DeclContext *DC = nullptr;
2880 for (auto *D : Result) {
2881 Diag(D->getLocation(), diag::note_reference_placeholder) << D;
2882 if (DC != nullptr && DC != D->getDeclContext())
2883 break;
2884 DC = D->getDeclContext();
2885 }
2886 break;
2887 }
2888
2890 Diag(NameLoc, diag::err_ambiguous_reference) << Name << LookupRange;
2891
2892 for (auto *D : Result)
2893 Diag(D->getLocation(), 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(RD);
2910 return ClassesTransitive.insert(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(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(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
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.
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>(PrimaryCtx);
2970 Decl *D = cast<Decl>(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(D->getOwningModule(), PrimaryD->getOwningModule()))
3013 Namespaces.insert(Ctx);
3014 else
3015 Namespaces.insert(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
3022 const TemplateArgument &Arg) {
3023 // C++ [basic.lookup.argdep]p2, last bullet:
3024 // -- [...] ;
3025 switch (Arg.getKind()) {
3027 break;
3028
3030 // [...] the namespaces and classes associated with the types of the
3031 // template arguments provided for template type parameters (excluding
3032 // template template parameters)
3034 break;
3035
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.
3042 if (ClassTemplateDecl *ClassTemplate
3043 = dyn_cast<ClassTemplateDecl>(Template.getAsTemplateDecl())) {
3044 DeclContext *Ctx = ClassTemplate->getDeclContext();
3045 if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx))
3046 Result.Classes.insert(EnclosingClass);
3047 // Add the associated namespace for this class.
3048 CollectEnclosingNamespace(Result.Namespaces, Ctx);
3049 }
3050 break;
3051 }
3052
3058 // [Note: non-type template arguments do not contribute to the set of
3059 // associated namespaces. ]
3060 break;
3061
3063 for (const auto &P : Arg.pack_elements())
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
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(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>(Ctx))
3094 Result.Classes.insert(EnclosingClass);
3095
3096 // Add the associated namespace for this class.
3097 CollectEnclosingNamespace(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. ]
3109 = dyn_cast<ClassTemplateSpecializationDecl>(Class)) {
3110 DeclContext *Ctx = Spec->getSpecializedTemplate()->getDeclContext();
3111 if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx))
3112 Result.Classes.insert(EnclosingClass);
3113 // Add the associated namespace for this class.
3114 CollectEnclosingNamespace(Result.Namespaces, Ctx);
3115
3116 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
3117 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
3118 addAssociatedClassesAndNamespaces(Result, 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(Class))
3124 return;
3125
3126 // Only recurse into base classes for complete types.
3127 if (!Result.S.isCompleteType(Result.InstantiationLoc,
3128 Result.S.Context.getCanonicalTagType(Class)))
3129 return;
3130
3131 // Add direct and indirect base classes along with their associated
3132 // namespaces.
3134 Bases.push_back(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(BaseDecl)) {
3151 // Find the associated namespace for this base class.
3152 DeclContext *BaseCtx = BaseDecl->getDeclContext();
3153 CollectEnclosingNamespace(Result.Namespaces, BaseCtx);
3154
3155 // Make sure we visit the bases of this base class.
3156 if (!BaseDecl->bases().empty())
3157 Bases.push_back(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
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
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>(T)->getPointeeType().getTypePtr();
3202 continue;
3203 case Type::ConstantArray:
3204 case Type::IncompleteArray:
3205 case Type::VariableArray:
3206 T = cast<ArrayType>(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>(cast<RecordType>(T)->getDecl())
3222 ->getDefinitionOrSelf();
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>(Ctx))
3237 Result.Classes.insert(EnclosingClass);
3238
3239 // Add the associated namespace for this enumeration.
3240 CollectEnclosingNamespace(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(T))
3251 break;
3253 for (const auto &Arg : Proto->param_types())
3254 Queue.push_back(Arg.getTypePtr());
3255 // fallthrough
3256 [[fallthrough]];
3257 }
3258 case Type::FunctionNoProto: {
3259 const FunctionType *FnType = cast<FunctionType>(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>(T);
3275 if (CXXRecordDecl *Class = MemberPtr->getMostRecentCXXRecordDecl())
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>(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>(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(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>(T)->getValueType().getTypePtr();
3319 continue;
3320 case Type::Pipe:
3321 T = cast<PipeType>(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>(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>(T)->getUnderlyingType().getTypePtr();
3337 }
3338
3339 if (Queue.empty())
3340 break;
3341 T = Queue.pop_back_val();
3342 }
3343}
3344
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) {
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.
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.
3386 }
3387 }
3388}
3389
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
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(Operators, S);
3410
3411 assert(!Operators.isAmbiguous() && "Operator lookup cannot be ambiguous");
3412 Functions.append(Operators.begin(), Operators.end());
3413}
3414
3417 bool ConstArg, bool VolatileArg, bool RValueThis,
3418 bool ConstThis, bool VolatileThis) {
3419 unsigned Flags = llvm::to_underlying(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
3430 bool ConstArg, bool VolatileArg, bool RValueThis,
3431 bool ConstThis, bool VolatileThis) {
3433 "doing special member lookup into record that isn't fully complete");
3434 RD = RD->getDefinition();
3435 if (RValueThis || ConstThis || VolatileThis)
3438 "constructors and destructors always have unqualified lvalue this");
3439 if (ConstArg || VolatileArg)
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
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
3456 if (RD->needsImplicitDestructor()) {
3458 DeclareImplicitDestructor(RD);
3459 });
3460 }
3461 CXXDestructorDecl *DD = RD->getDestructor();
3462 Result.setMethod(DD);
3463 Result.setKind(DD && !DD->isDeleted()
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(RD);
3472 DeclarationName Name;
3473 Expr *Arg = nullptr;
3474 unsigned NumArgs;
3475
3476 QualType ArgType = CanTy;
3478
3480 Name = Context.DeclarationNames.getCXXConstructorName(CanTy);
3481 NumArgs = 0;
3484 DeclareImplicitDefaultConstructor(RD);
3485 });
3486 }
3487 } else {
3490 Name = Context.DeclarationNames.getCXXConstructorName(CanTy);
3491 if (RD->needsImplicitCopyConstructor()) {
3493 DeclareImplicitCopyConstructor(RD);
3494 });
3495 }
3498 DeclareImplicitMoveConstructor(RD);
3499 });
3500 }
3501 } else {
3502 Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
3503 if (RD->needsImplicitCopyAssignment()) {
3505 DeclareImplicitCopyAssignment(RD);
3506 });
3507 }
3510 DeclareImplicitMoveAssignment(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.
3529 VK = VK_LValue;
3530 else
3531 VK = VK_PRValue;
3532 }
3533
3534 OpaqueValueExpr FakeArg(LookupLoc, ArgType, VK);
3535
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(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.
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.
3563 "lookup for a constructor or assignment operator was empty");
3564 Result.setMethod(nullptr);
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
3578 auto CtorInfo = getConstructorInfo(Cand);
3579 if (CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(Cand->getUnderlyingDecl())) {
3582 AddMethodCandidate(M, Cand, RD, ThisTy, Classification,
3583 llvm::ArrayRef(&Arg, NumArgs), OCS, true);
3584 else if (CtorInfo)
3585 AddOverloadCandidate(CtorInfo.Constructor, CtorInfo.FoundDecl,
3586 llvm::ArrayRef(&Arg, NumArgs), OCS,
3587 /*SuppressUserConversions*/ true);
3588 else
3589 AddOverloadCandidate(M, Cand, llvm::ArrayRef(&Arg, NumArgs), OCS,
3590 /*SuppressUserConversions*/ true);
3591 } else if (FunctionTemplateDecl *Tmpl =
3592 dyn_cast<FunctionTemplateDecl>(Cand->getUnderlyingDecl())) {
3595 AddMethodTemplateCandidate(Tmpl, Cand, RD, nullptr, ThisTy,
3596 Classification,
3597 llvm::ArrayRef(&Arg, NumArgs), OCS, true);
3598 else if (CtorInfo)
3599 AddTemplateOverloadCandidate(CtorInfo.ConstructorTmpl,
3600 CtorInfo.FoundDecl, nullptr,
3601 llvm::ArrayRef(&Arg, NumArgs), OCS, true);
3602 else
3603 AddTemplateOverloadCandidate(Tmpl, Cand, nullptr,
3604 llvm::ArrayRef(&Arg, NumArgs), OCS, true);
3605 } else {
3606 assert(isa<UsingDecl>(Cand.getDecl()) &&
3607 "illegal Kind of operator = Decl");
3608 }
3609 }
3610
3612 switch (OCS.BestViableFunction(*this, LookupLoc, Best)) {
3613 case OR_Success:
3614 Result.setMethod(cast<CXXMethodDecl>(Best->Function));
3616 break;
3617
3618 case OR_Deleted:
3619 Result.setMethod(cast<CXXMethodDecl>(Best->Function));
3621 break;
3622
3623 case OR_Ambiguous:
3624 Result.setMethod(nullptr);
3626 break;
3627
3629 Result.setMethod(nullptr);
3631 break;
3632 }
3633
3634 return SpecialMemberCache[Key] = Result;
3635}
3636
3640 false, false, false, false, false);
3641
3642 return cast_or_null<CXXConstructorDecl>(Result.getMethod());
3643}
3644
3646 unsigned Quals) {
3647 assert(!(Quals & ~(Qualifiers::Const | Qualifiers::Volatile)) &&
3648 "non-const, non-volatile qualifiers for copy ctor arg");
3651 Quals & Qualifiers::Volatile, false, false, false);
3652
3653 return cast_or_null<CXXConstructorDecl>(Result.getMethod());
3654}
3655
3657 unsigned Quals) {
3660 Quals & Qualifiers::Volatile, false, false, false);
3661
3662 return cast_or_null<CXXConstructorDecl>(Result.getMethod());
3663}
3664
3666 // If the implicit constructors have not yet been declared, do so now.
3668 runWithSufficientStackSpace(Class->getLocation(), [&] {
3669 if (Class->needsImplicitDefaultConstructor())
3670 DeclareImplicitDefaultConstructor(Class);
3671 if (Class->needsImplicitCopyConstructor())
3672 DeclareImplicitCopyConstructor(Class);
3673 if (getLangOpts().CPlusPlus11 && Class->needsImplicitMoveConstructor())
3674 DeclareImplicitMoveConstructor(Class);
3675 });
3676 }
3677
3678 CanQualType T = Context.getCanonicalTagType(Class);
3679 DeclarationName Name = Context.DeclarationNames.getCXXConstructorName(T);
3680 return Class->lookup(Name);
3681}
3682
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");
3692 Quals & Qualifiers::Volatile, RValueThis, ThisQuals & Qualifiers::Const,
3693 ThisQuals & Qualifiers::Volatile);
3694
3695 return Result.getMethod();
3696}
3697
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");
3706 Quals & Qualifiers::Volatile, RValueThis, ThisQuals & Qualifiers::Const,
3707 ThisQuals & Qualifiers::Volatile);
3708
3709 return Result.getMethod();
3710}
3711
3713 return cast_or_null<CXXDestructorDecl>(
3715 false, false, false)
3716 .getMethod());
3717}
3718
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>(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>(D)) {
3754 if (FD->getNumParams() == 1 &&
3755 FD->getParamDecl(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(ArgIdx)->getType();
3761 if (!Context.hasSameUnqualifiedType(ArgTys[ArgIdx], ParamTy)) {
3762 IsCooked = false;
3763 break;
3764 }
3765 }
3766 }
3767 }
3768 if (FunctionTemplateDecl *FD = dyn_cast<FunctionTemplateDecl>(D)) {
3769 TemplateParameterList *Params = FD->getTemplateParameters();
3770 if (Params->size() == 1) {
3771 IsTemplate = true;
3772 if (!Params->getParam(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);
3786 TemplateArgument(StringLit, /*IsCanonical=*/false), StringLit);
3788 Params->getParam(0), Arg, FD, R.getNameLoc(), R.getNameLoc(),
3789 /*ArgumentPackIndex=*/0, CTAI, 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(R.getNameLoc(), diag::err_ovl_ambiguous_call) << R.getLookupName();
3846 for (const NamedDecl *D : R)
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)
3859
3860 // Didn't find anything we could use.
3861 if (DiagnoseMissing) {
3862 Diag(R.getNameLoc(), 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
3870}
3871
3873 NamedDecl *&Old = Decls[cast<NamedDecl>(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
3905 // Find all of the associated namespaces and classes based on the
3906 // arguments we have.
3907 AssociatedNamespaceSet AssociatedNamespaces;
3908 AssociatedClassSet AssociatedClasses;
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>(D))
3957 Underlying = USD->getTargetDecl();
3958
3959 if (!isa<FunctionDecl>(Underlying) &&
3960 !isa<FunctionTemplateDecl>(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>(D->getPreviousDecl())) {
3970 if (isVisible(D)) {
3971 Visible = true;
3972 break;
3973 }
3974
3975 if (!D->getOwningModule() ||
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(AssociatedClasses, [&](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()) {
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(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(Underlying);
4031 }
4032 }
4033}
4034
4035//----------------------------------------------------------------------------
4036// Search for all visible declarations.
4037//----------------------------------------------------------------------------
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.
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(Ctx).second;
4071 }
4072
4073 bool alreadyVisitedContext(DeclContext *Ctx) {
4074 return VisitedContexts.count(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(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(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() &&
4122 continue;
4123
4124 // Protocols are in distinct namespaces from everything else.
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!
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>(ND) && isa<UsingDecl>(D) &&
4141 cast<UsingShadowDecl>(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(Initial, 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(SemaRef.getASTContext().getTranslationUnitDecl());
4180 ShadowContextRAII Shadow(Visited);
4181 lookupInScope(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(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->getPrimaryContext()))
4204 return;
4205
4206 Consumer.EnteredContext(Ctx);
4207
4208 // Outside C++, lookup results for the TU live on identifiers.
4209 if (isa<TranslationUnitDecl>(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(Ident.getValue()),
4227 E = S.IdResolver.end();
4228 I != E; ++I) {
4229 if (S.IdResolver.isDeclInScope(*I, Ctx)) {
4230 if (NamedDecl *ND = Result.getAcceptableDecl(*I)) {
4231 Consumer.FoundDecl(ND, 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>(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 ||
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(D);
4259
4260 for (auto *D : DeclsToVisit)
4261 if (auto *ND = Result.getAcceptableDecl(D)) {
4262 Consumer.FoundDecl(ND, 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(I))
4273 continue;
4274 lookupInDeclContext(I->getNominatedNamespace(), Result,
4275 QualifiedNameLookup, InBaseClass);
4276 }
4277 }
4278
4279 // Traverse the contexts of inherited C++ classes.
4280 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(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>(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(RD, Result, QualifiedNameLookup,
4334 /*InBaseClass=*/true);
4335 }
4336 }
4337
4338 // Traverse the contexts of Objective-C classes.
4339 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Ctx)) {
4340 // Traverse categories.
4341 for (auto *Cat : IFace->visible_categories()) {
4342 ShadowContextRAII Shadow(Visited);
4343 lookupInDeclContext(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(I, Result, QualifiedNameLookup,
4351 /*InBaseClass=*/false);
4352 }
4353
4354 // Traverse the superclass.
4355 if (IFace->getSuperClass()) {
4356 ShadowContextRAII Shadow(Visited);
4357 lookupInDeclContext(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(IFace->getImplementation(), Result,
4366 QualifiedNameLookup, InBaseClass);
4367 }
4368 } else if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Ctx)) {
4369 for (auto *I : Protocol->protocols()) {
4370 ShadowContextRAII Shadow(Visited);
4371 lookupInDeclContext(I, Result, QualifiedNameLookup,
4372 /*InBaseClass=*/false);
4373 }
4374 } else if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Ctx)) {
4375 for (auto *I : Category->protocols()) {
4376 ShadowContextRAII Shadow(Visited);
4377 lookupInDeclContext(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(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(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>(D))
4408 if ((ND = Result.getAcceptableDecl(ND))) {
4409 Consumer.FoundDecl(ND, Visited.checkHidden(ND), nullptr, 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(OuterCtx);
4423 Ctx = Ctx->getLookupParent()) {
4424 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(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(),
4430 if (ObjCInterfaceDecl *IFace = Method->getClassInterface()) {
4431 lookupInDeclContext(IFace, 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(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(Entity))
4469 lookupInDeclContext(
4470 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->getParent(), Result, UDirs);
4478 }
4479
4480private:
4481 VisibleDeclsRecord Visited;
4482 VisibleDeclConsumer &Consumer;
4483 bool IncludeDependentBases;
4484 bool LoadExternal;
4485};
4486} // namespace
4487
4490 bool IncludeGlobalScope, bool LoadExternal) {
4491 LookupVisibleHelper H(Consumer, /*IncludeDependentBases=*/false,
4492 LoadExternal);
4493 H.lookupVisibleDecls(*this, S, Kind, IncludeGlobalScope);
4494}
4495
4498 bool IncludeGlobalScope,
4499 bool IncludeDependentBases, bool LoadExternal) {
4500 LookupVisibleHelper H(Consumer, IncludeDependentBases, LoadExternal);
4501 H.lookupVisibleDecls(*this, Ctx, Kind, IncludeGlobalScope);
4502}
4503
4505 NamedDecl *Res = LookupSingleName(CurScope, II, Loc, LookupLabel,
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 ||
4511 CurContext->getEnclosingNonExpansionStatementContext())
4512 return nullptr;
4513 return cast<LabelDecl>(Res);
4514}
4515
4517 SourceLocation GnuLabelLoc,
4518 bool IsLabelStmt) {
4519 if (GnuLabelLoc.isValid()) {
4520 // Local label definitions always shadow existing labels.
4521 auto *Res = LabelDecl::Create(Context, CurContext, Loc, II, GnuLabelLoc);
4522 Scope *S = CurScope;
4523 PushOnScopeChains(Res, S, true);
4524 return cast<LabelDecl>(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, 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(Context, CurContext, Loc, II);
4561 Scope *S = CurScope->getFnParent();
4562 assert(S && "Not in a function?");
4563 PushOnScopeChains(Res, S, true);
4564 return Res;
4565}
4566
4567//===----------------------------------------------------------------------===//
4568// Typo correction
4569//===----------------------------------------------------------------------===//
4570
4572 TypoCorrection &Candidate) {
4573 Candidate.setCallbackDistance(CCC.RankCandidate(Candidate));
4574 return Candidate.getEditDistance(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.
4590 TypoCorrection::decl_iterator DI = TC.begin(), DE = TC.end();
4591
4592 for (/**/; DI != DE; ++DI)
4593 if (!LookupResult::isVisible(SemaRef, *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, *DI)) {
4606 if (!AnyVisibleDecls) {
4607 // Found a visible decl, discard all hidden ones.
4608 AnyVisibleDecls = true;
4609 NewDecls.clear();
4610 }
4611 NewDecls.push_back(*DI);
4612 } else if (!AnyVisibleDecls && !(*DI)->isModulePrivate())
4613 NewDecls.push_back(*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").
4630 switch (NNS.getKind()) {
4632 Identifiers.clear();
4633 return;
4634
4636 auto [Namespace, Prefix] = NNS.getAsNamespaceAndPrefix();
4637 getNestedNameSpecifierIdentifiers(Prefix, Identifiers);
4638 if (const auto *NS = dyn_cast<NamespaceDecl>(Namespace);
4639 NS && NS->isAnonymousNamespace())
4640 return;
4641 Identifiers.push_back(Namespace->getIdentifier());
4642 return;
4643 }
4644
4646 for (const Type *T = NNS.getAsType(); /**/; /**/) {
4647 switch (T->getTypeClass()) {
4648 case Type::DependentName: {
4649 auto *DT = cast<DependentNameType>(T);
4650 getNestedNameSpecifierIdentifiers(DT->getQualifier(), Identifiers);
4651 Identifiers.push_back(DT->getIdentifier());
4652 return;
4653 }
4654 case Type::TemplateSpecialization: {
4655 TemplateName Name =
4656 cast<TemplateSpecializationType>(T)->getTemplateName();
4657 if (const DependentTemplateName *DTN =
4659 getNestedNameSpecifierIdentifiers(DTN->getQualifier(), Identifiers);
4660 if (const auto *II = DTN->getName().getIdentifier())
4661 Identifiers.push_back(II);
4662 return;
4663 }
4664 if (const QualifiedTemplateName *QTN =
4666 getNestedNameSpecifierIdentifiers(QTN->getQualifier(), Identifiers);
4667 Name = QTN->getUnderlyingTemplate();
4668 }
4669 if (const auto *TD = Name.getAsTemplateDecl(/*IgnoreDeduced=*/true))
4670 Identifiers.push_back(TD->getIdentifier());
4671 return;
4672 }
4673 case Type::SubstTemplateTypeParm:
4675 ->getReplacementType()
4676 .getTypePtr();
4677 continue;
4678 case Type::TemplateTypeParm:
4679 Identifiers.push_back(cast<TemplateTypeParmType>(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>(T);
4687 getNestedNameSpecifierIdentifiers(TT->getQualifier(), Identifiers);
4688 Identifiers.push_back(TT->getDecl()->getIdentifier());
4689 return;
4690 }
4691 case Type::Typedef: {
4692 auto *TT = cast<TypedefType>(T);
4693 getNestedNameSpecifierIdentifiers(TT->getQualifier(), Identifiers);
4694 Identifiers.push_back(TT->getDecl()->getIdentifier());
4695 return;
4696 }
4697 case Type::Using: {
4698 auto *TT = cast<UsingType>(T);
4699 getNestedNameSpecifierIdentifiers(TT->getQualifier(), Identifiers);
4700 Identifiers.push_back(TT->getDecl()->getIdentifier());
4701 return;
4702 }
4703 case Type::UnresolvedUsing: {
4704 auto *TT = cast<UnresolvedUsingType>(T);
4705 getNestedNameSpecifierIdentifiers(TT->getQualifier(), Identifiers);
4706 Identifiers.push_back(TT->getDecl()->getIdentifier());
4707 return;
4708 }
4709 default:
4710 Identifiers.push_back(QualType(T, 0).getBaseTypeIdentifier());
4711 return;
4712 }
4713 }
4714 break;
4715 }
4716
4719 return;
4720 }
4721}
4722
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, ND) && Name != Typo)
4739 return;
4740
4741 FoundName(Name->getName());
4742}
4743
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, nullptr);
4748}
4749
4751 // Compute the edit distance between the typo and this keyword,
4752 // and add the keyword to the list of results.
4753 addName(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((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(Name, true, 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(nullptr, Result.getLookupNameInfo());
4774 addCorrection(TC);
4775}
4776
4777static const unsigned MaxTypoDistanceResultSets = 5;
4778
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(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, Correction);
4793 if (!Correction || !isCandidateViable(*CorrectionValidator, Correction))
4794 return;
4795 }
4796
4797 TypoResultList &CList =
4798 CorrectionResults[Correction.getEditDistance(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(CList, [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>(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(SemaRef.getLangOpts())};
4824
4825 std::pair<bool, std::string> PrevKey = {
4826 IsDeprecated(RI->getFoundDecl()),
4827 RI->getAsString(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(Correction);
4836
4837 while (CorrectionResults.size() > MaxTypoDistanceResultSets)
4838 CorrectionResults.erase(std::prev(CorrectionResults.end()));
4839}
4840
4842 const llvm::MapVector<NamespaceDecl *, bool> &KnownNamespaces) {
4843 SearchNamespaces = true;
4844
4845 for (auto KNPair : KnownNamespaces)
4846 Namespaces.addNameSpecifier(KNPair.first);
4847
4848 bool SSIsTemplate = false;
4849 if (NestedNameSpecifier NNS = (SS ? SS->getScopeRep() : std::nullopt)) {
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>(CD)) &&
4865 (CD->isBeingDefined() || CD->isCompleteDefinition()))
4866 Namespaces.addNameSpecifier(CD);
4867 }
4868 }
4869}
4870
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(DI);
4880 continue;
4881 }
4882
4883 auto RI = DI->second.begin();
4884 if (RI->second.empty()) {
4885 DI->second.erase(RI);
4886 performQualifiedLookups();
4887 continue;
4888 }
4889
4890 TypoCorrection TC = RI->second.pop_back_val();
4891 if (TC.isResolved() || TC.requiresImport() || resolveCorrection(TC)) {
4892 ValidatedCorrections.push_back(TC);
4893 return ValidatedCorrections[CurrentTCIndex];
4894 }
4895 }
4896 return ValidatedCorrections[0]; // The empty correction.
4897}
4898
4899bool TypoCorrectionConsumer::resolveCorrection(TypoCorrection &Candidate) {
4901 DeclContext *TempMemberContext = MemberContext;
4902 CXXScopeSpec *TempSS = SS.get();
4903retry_lookup:
4904 LookupPotentialTypoResult(SemaRef, Result, Name, S, TempSS, TempMemberContext,
4905 EnteringContext,
4906 CorrectionValidator->IsObjCIvarLookup,
4907 Name == Typo && !Candidate.WillReplaceSpecifier());
4908 switch (Result.getResultKind()) {
4912 if (TempSS) {
4913 // Immediately retry the lookup without the given CXXScopeSpec
4914 TempSS = nullptr;
4915 Candidate.WillReplaceSpecifier(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(Candidate);
4926 break;
4927
4929 // We don't deal with ambiguities.
4930 break;
4931
4934 // Store all of the Decls for overloaded symbols
4935 for (auto *TRD : Result)
4936 Candidate.addCorrectionDecl(TRD);
4937 checkCorrectionVisibility(SemaRef, Candidate);
4938 if (!isCandidateViable(*CorrectionValidator, Candidate)) {
4939 if (SearchNamespaces)
4940 QualifiedResults.push_back(Candidate);
4941 break;
4942 }
4943 Candidate.setCorrectionRange(SS.get(), 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(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(Result, 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()) {
4988 if (SS && SS->isValid()) {
4989 std::string NewQualified = TC.getAsString(SemaRef.getLangOpts());
4990 std::string OldQualified;
4991 llvm::raw_string_ostream OldOStream(OldQualified);
4992 SS->getScopeRep().print(OldOStream, 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(TC.getCorrectionRange().getBegin(),
5003 NamingClass,
5004 TRD.getPair()) == Sema::AR_accessible)
5005 TC.addCorrectionDecl(*TRD);
5006 }
5007 if (TC.isResolved()) {
5008 TC.setCorrectionRange(SS.get(), Result.getLookupNameInfo());
5009 addCorrection(TC);
5010 }
5011 break;
5012 }
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(CurContext)) {
5027 if (NestedNameSpecifier NNS =
5028 CurScopeSpec ? CurScopeSpec->getScopeRep() : std::nullopt) {
5029 llvm::raw_string_ostream SpecifierOStream(CurNameSpecifier);
5030 NNS.print(SpecifierOStream, Context.getPrintingPolicy());
5031
5032 getNestedNameSpecifierIdentifiers(NNS, 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(CurContextChain)) {
5038 if (auto *ND = dyn_cast_or_null<NamespaceDecl>(C))
5039 CurContextIdentifiers.push_back(ND->getIdentifier());
5040 }
5041
5042 // Add the global context as a NestedNameSpecifier
5043 SpecifierInfo SI = {cast<DeclContext>(Context.getTranslationUnitDecl()),
5045 DistanceMap[1].push_back(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>(DC);
5055 if (!DC->isInlineNamespace() && !DC->isTransparentContext() &&
5056 !(ND && ND->isAnonymousNamespace()))
5057 Chain.push_back(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(DeclChain)) {
5067 if (auto *ND = dyn_cast_or_null<NamespaceDecl>(C)) {
5068 NNS = NestedNameSpecifier(Context, ND, NNS);
5069 ++NumSpecifiers;
5070 } else if (auto *RD = dyn_cast_or_null<RecordDecl>(C)) {
5071 QualType T = Context.getTagType(ElaboratedTypeKeyword::None, NNS, 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(Ctx));
5085 DeclContextList FullNamespaceDeclChain(NamespaceDeclChain);
5086
5087 // Eliminate common elements from the two DeclContext chains.
5088 for (DeclContext *C : llvm::reverse(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(NamespaceDeclChain, NNS);
5096
5097 // Add an explicit leading '::' specifier if needed.
5098 if (NamespaceDeclChain.empty()) {
5099 // Rebuild the NestedNameSpecifier as a globally-qualified specifier.
5101 NumSpecifiers =
5102 buildNestedNameSpecifier(FullNamespaceDeclChain, NNS);
5103 } else if (NamedDecl *ND =
5104 dyn_cast_or_null<NamedDecl>(NamespaceDeclChain.back())) {
5105 IdentifierInfo *Name = ND->getIdentifier();
5106 bool SameNameSpecifier = false;
5107 if (llvm::is_contained(CurNameSpecifierIdentifiers, Name)) {
5108 std::string NewNameSpecifier;
5109 llvm::raw_string_ostream SpecifierOStream(NewNameSpecifier);
5110 SmallVector<const IdentifierInfo *, 4> NewNameSpecifierIdentifiers;
5111 getNestedNameSpecifierIdentifiers(NNS, NewNameSpecifierIdentifiers);
5112 NNS.print(SpecifierOStream, Context.getPrintingPolicy());
5113 SameNameSpecifier = NewNameSpecifier == CurNameSpecifier;
5114 }
5115 if (SameNameSpecifier || llvm::is_contained(CurContextIdentifiers, Name)) {
5116 // Rebuild the NestedNameSpecifier as a globally-qualified specifier.
5118 NumSpecifiers =
5119 buildNestedNameSpecifier(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, NewNameSpecifierIdentifiers);
5130 NumSpecifiers =
5131 llvm::ComputeEditDistance(llvm::ArrayRef(CurNameSpecifierIdentifiers),
5132 llvm::ArrayRef(NewNameSpecifierIdentifiers));
5133 }
5134
5135 SpecifierInfo SI = {Ctx, NNS, NumSpecifiers};
5136 DistanceMap[NumSpecifiers].push_back(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>(MemberContext)) {
5154 if (isObjCIvarLookup) {
5155 if (ObjCIvarDecl *Ivar = Class->lookupInstanceVariable(Name)) {
5156 Res.addDecl(Ivar);
5157 Res.resolveKind();
5158 return;
5159 }
5160 }
5161
5162 if (ObjCPropertyDecl *Prop = Class->FindPropertyDeclaration(
5164 Res.addDecl(Prop);
5165 Res.resolveKind();
5166 return;
5167 }
5168 }
5169
5170 SemaRef.LookupQualifiedName(Res, MemberContext);
5171 return;
5172 }
5173
5174 SemaRef.LookupParsedName(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() &&
5185 if (ObjCIvarDecl *IV
5186 = Method->getClassInterface()->lookupInstanceVariable(Name)) {
5187 Res.addDecl(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,
5198 bool AfterNestedNameSpecifier) {
5199 if (AfterNestedNameSpecifier) {
5200 // For 'X::', we know exactly which keywords can appear next.
5201 Consumer.addKeywordResult("template");
5202 if (CCC.WantExpressionKeywords)
5203 Consumer.addKeywordResult("operator");
5204 return;
5205 }
5206
5207 if (CCC.WantObjCSuper)
5208 Consumer.addKeywordResult("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(CTS);
5222
5223 if (SemaRef.getLangOpts().C99 && !SemaRef.getLangOpts().C2y)
5224 Consumer.addKeywordResult("_Imaginary");
5225
5226 if (SemaRef.getLangOpts().C99)
5227 Consumer.addKeywordResult("restrict");
5228 if (SemaRef.getLangOpts().Bool || SemaRef.getLangOpts().CPlusPlus)
5229 Consumer.addKeywordResult("bool");
5230 else if (SemaRef.getLangOpts().C99)
5231 Consumer.addKeywordResult("_Bool");
5232
5233 if (SemaRef.getLangOpts().CPlusPlus) {
5234 Consumer.addKeywordResult("class");
5235 Consumer.addKeywordResult("typename");
5236 Consumer.addKeywordResult("wchar_t");
5237
5238 if (SemaRef.getLangOpts().CPlusPlus11) {
5239 Consumer.addKeywordResult("char16_t");
5240 Consumer.addKeywordResult("char32_t");
5241 Consumer.addKeywordResult("constexpr");
5242 Consumer.addKeywordResult("decltype");
5243 Consumer.addKeywordResult("thread_local");
5244 }
5245 }
5246
5247 if (SemaRef.getLangOpts().GNUKeywords)
5248 Consumer.addKeywordResult("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(kw);
5256 }
5257
5258 if (CCC.WantCXXNamedCasts && SemaRef.getLangOpts().CPlusPlus) {
5259 Consumer.addKeywordResult("const_cast");
5260 Consumer.addKeywordResult("dynamic_cast");
5261 Consumer.addKeywordResult("reinterpret_cast");
5262 Consumer.addKeywordResult("static_cast");
5263 }
5264
5265 if (CCC.WantExpressionKeywords) {
5266 Consumer.addKeywordResult("sizeof");
5267 if (SemaRef.getLangOpts().Bool || SemaRef.getLangOpts().CPlusPlus) {
5268 Consumer.addKeywordResult("false");
5269 Consumer.addKeywordResult("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(CE);
5278
5279 if (isa<CXXMethodDecl>(SemaRef.CurContext) &&
5280 cast<CXXMethodDecl>(SemaRef.CurContext)->isInstance())
5281 Consumer.addKeywordResult("this");
5282
5283 if (SemaRef.getLangOpts().CPlusPlus11) {
5284 Consumer.addKeywordResult("alignof");
5285 Consumer.addKeywordResult("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("_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(CS);
5303
5304 if (SemaRef.getLangOpts().CPlusPlus) {
5305 Consumer.addKeywordResult("catch");
5306 Consumer.addKeywordResult("try");
5307 }
5308
5309 if (S && S->getBreakParent())
5310 Consumer.addKeywordResult("break");
5311
5312 if (S && S->getContinueParent())
5313 Consumer.addKeywordResult("continue");
5314
5315 if (SemaRef.getCurFunction() &&
5316 !SemaRef.getCurFunction()->SwitchStack.empty()) {
5317 Consumer.addKeywordResult("case");
5318 Consumer.addKeywordResult("default");
5319 }
5320 } else {
5321 if (SemaRef.getLangOpts().CPlusPlus) {
5322 Consumer.addKeywordResult("namespace");
5323 Consumer.addKeywordResult("template");
5324 }
5325
5326 if (S && S->isClassScope()) {
5327 Consumer.addKeywordResult("explicit");
5328 Consumer.addKeywordResult("friend");
5329 Consumer.addKeywordResult("mutable");
5330 Consumer.addKeywordResult("private");
5331 Consumer.addKeywordResult("protected");
5332 Consumer.addKeywordResult("public");
5333 Consumer.addKeywordResult("virtual");
5334 }
5335 }
5336
5337 if (SemaRef.getLangOpts().CPlusPlus) {
5338 Consumer.addKeywordResult("using");
5339
5340 if (SemaRef.getLangOpts().CPlusPlus11)
5341 Consumer.addKeywordResult("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>(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(Typo);
5383 if (locs != TypoCorrectionFailures.end() &&
5384 locs->second.count(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("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(Typo->getName(),
5407 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 *this, TypoName, LookupKind, S, SS, std::move(ClonedCCC), MemberContext,
5417 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(MemberContext, LookupKind, *Consumer);
5424
5425 // Look in qualified interfaces.
5426 if (OPT) {
5427 for (auto *I : OPT->quals())
5428 LookupVisibleDecls(I, LookupKind, *Consumer);
5429 }
5430 } else if (SS && SS->isSet()) {
5431 QualifiedDC = computeDeclContext(*SS, EnteringContext);
5432 if (!QualifiedDC)
5433 return nullptr;
5434
5435 LookupVisibleDecls(QualifiedDC, LookupKind, *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(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(*this, *Consumer, S,
5469 *Consumer->getCorrectionValidator(),
5470 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(ExternalKnownNamespaces);
5480 for (auto *N : ExternalKnownNamespaces)
5481 KnownNamespaces[N] = true;
5482 }
5483
5484 Consumer->addNamespaces(KnownNamespaces);
5485 }
5486
5487 return Consumer;
5488}
5489
5491 Sema::LookupNameKind LookupKind,
5492 Scope *S, CXXScopeSpec *SS,
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(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,
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, 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(true);
5529 unsigned TypoLen = Typo->getName().size();
5530 if (ED > 0 && TypoLen / ED < 3)
5531 return FailedCorrection(Typo, TypoName.getLoc(), RecordFailure);
5532
5533 TypoCorrection BestTC = Consumer->getNextCorrection();
5534 TypoCorrection SecondBestTC = Consumer->getNextCorrection();
5535 if (!BestTC)
5536 return FailedCorrection(Typo, 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, TypoName.getLoc(), RecordFailure);
5545 }
5546
5547 // If only a single name remains, return that result.
5548 if (!SecondBestTC ||
5549 SecondBestTC.getEditDistance(false) > BestTC.getEditDistance(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, TypoName.getLoc(), RecordFailure);
5556
5558 TC.setCorrectionRange(SS, TypoName);
5559 checkCorrectionVisibility(*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, 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, TypoName.getLoc(), RecordFailure && !SecondBestTC);
5585}
5586
5588 if (!CDecl) return;
5589
5590 if (isKeyword())
5591 CorrectionDecls.clear();
5592
5593 CorrectionDecls.push_back(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(PrefixOStream, PrintingPolicy(LO));
5604 PrefixOStream << CorrectionName;
5605 return PrefixOStream.str();
5606 }
5607
5608 return CorrectionName.getAsString();
5609}
5610
5612 const TypoCorrection &candidate) {
5613 if (!candidate.isResolved())
5614 return true;
5615
5616 if (candidate.isKeyword())
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>(D))
5625 D = FTD->getTemplatedDecl();
5626 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
5627 if (Method->isStatic())
5628 HasStaticMethod = true;
5629 else
5630 HasNonStaticMethod = true;
5631 }
5632 if (!isa<TypeDecl>(D))
5633 HasNonType = true;
5634 }
5635
5636 if (IsAddressOfOperand && HasNonStaticMethod && !HasStaticMethod &&
5637 !candidate.getCorrectionSpecifier())
5638 return false;
5639
5640 return WantTypeSpecifiers || HasNonType;
5641}
5642
5644 bool HasExplicitTemplateArgs,
5645 MemberExpr *ME)
5646 : NumArgs(NumArgs), HasExplicitTemplateArgs(HasExplicitTemplateArgs),
5647 CurContext(SemaRef.CurContext), MemberFn(ME) {
5648 WantTypeSpecifiers = false;
5650 !HasExplicitTemplateArgs && NumArgs == 1;
5651 WantCXXNamedCasts = HasExplicitTemplateArgs && NumArgs == 1;
5652 WantRemainingKeywords = false;
5653}
5654
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>(ND))
5663 FD = FTD->getTemplatedDecl();
5664 if (!HasExplicitTemplateArgs && !FD) {
5665 if (!(FD = dyn_cast<FunctionDecl>(ND)) && isa<ValueDecl>(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>(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(ND) != nullptr
5682 : isa<TypeDecl>(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>(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>(FD)) {
5698 if (MemberFn || !MD->isStatic()) {
5699 const auto *CurMD =
5700 MemberFn
5701 ? dyn_cast_if_present<CXXMethodDecl>(MemberFn->getMemberDecl())
5702 : dyn_cast_if_present<CXXMethodDecl>(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(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, PDiag(diag::note_previous_decl),
5720}
5721
5722/// Find which declaration we should import to provide the definition of
5723/// the given declaration.
5725 if (const auto *VD = dyn_cast<VarDecl>(D))
5726 return VD->getDefinition();
5727 if (const auto *FD = dyn_cast<FunctionDecl>(D))
5728 return FD->getDefinition();
5729 if (const auto *TD = dyn_cast<TagDecl>(D))
5730 return TD->getDefinition();
5731 if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(D))
5732 return ID->getDefinition();
5733 if (const auto *PD = dyn_cast<ObjCProtocolDecl>(D))
5734 return PD->getDefinition();
5735 if (const auto *TD = dyn_cast<TemplateDecl>(D))
5736 if (const NamedDecl *TTD = TD->getTemplatedDecl())
5737 return getDefinitionToImport(TTD);
5738 return nullptr;
5739}
5740
5742 MissingImportKind MIK, bool Recover) {
5743 // Suggest importing a module providing the definition of this entity, if
5744 // possible.
5745 const NamedDecl *Def = getDefinitionToImport(Decl);
5746 if (!Def)
5747 Def = Decl;
5748
5749 Module *Owner = getOwningModule(Def);
5750 assert(Owner && "definition of hidden declaration is not in a module");
5751
5752 llvm::SmallVector<Module*, 8> OwningModules;
5753 OwningModules.push_back(Owner);
5754 auto Merged = Context.getModulesWithMergedDefinition(Def);
5755 llvm::append_range(OwningModules, Merged);
5756
5757 diagnoseMissingImport(Loc, Def, Def->getLocation(), 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.
5764 llvm::StringRef IncludingFile) {
5765 bool IsAngled = false;
5767 E, IncludingFile, &IsAngled);
5768 return (IsAngled ? '<' : '"') + Path + (IsAngled ? '>' : '"');
5769}
5770
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.
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(DeclLoc, 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(M).second)
5796 UniqueModules.push_back(M);
5797 }
5798
5799 // Try to find a suitable header-name to #include.
5800 std::string HeaderName;
5801 if (OptionalFileEntryRef Header =
5802 PP.getHeaderToIncludeForDiagnostics(UseLoc, DeclLoc)) {
5803 if (const FileEntry *FE =
5804 SourceMgr.getFileEntryForID(SourceMgr.getFileID(UseLoc)))
5805 HeaderName =
5806 getHeaderNameForHeader(PP, *Header, 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(UseLoc, 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)
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(M, 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(UseLoc, 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(UseLoc, 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)
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(getLangOpts());
5873 std::string CorrectedQuotedStr = Correction.getQuoted(getLangOpts());
5875 Correction.getCorrectionRange(), 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
5884 return;
5885 }
5886
5887 Diag(Correction.getCorrectionRange().getBegin(), 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>(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(ChosenDecl->getLocation(), PrevNote)
5904 << CorrectedQuotedStr << (ErrorRecovery ? FixItHint() : FixTypo);
5905
5906 // Add any extra diagnostics.
5907 for (const PartialDiagnostic &PD : Correction.getExtraDiagnostics())
5908 Diag(Correction.getCorrectionRange().getBegin(), PD);
5909}
5910
5912 DeclarationNameInfo Name(II, IILoc);
5913 LookupResult R(*this, Name, LookupAnyName,
5915 R.suppressDiagnostics();
5916 R.setHideTags(false);
5917 LookupName(R, S);
5918 R.dump();
5919}
5920
5922 E->dump();
5923}
5924
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>(CurContext)->getOwningModuleForLinkage())
5933}
Defines the clang::ASTContext interface.
Defines enum values for all the target-independent builtin functions.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
This file defines the classes used to store parsed information about declaration-specifiers and decla...
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
FormatToken * Next
The next token in the unwrapped line.
Result
Implement __builtin_bit_cast and related operations.
Defines the clang::LangOptions interface.
llvm::MachO::Record Record
Definition MachO.h:31
static StringRef getIdentifier(const Token &Tok)
Defines the clang::Preprocessor interface.
RedeclarationKind
Specifies whether (or how) name lookup is being performed for a redeclaration (vs.
@ NotForRedeclaration
The lookup is a reference to this name that is not for the purpose of redeclaring the name.
@ ForExternalRedeclaration
The lookup results will be used for redeclaration of a name with external linkage; non-visible lookup...
@ ForVisibleRedeclaration
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
static Module * getDefiningModule(Sema &S, Decl *Entity)
Find the module in which the given declaration was defined.
static bool isPreferredLookupResult(Sema &S, Sema::LookupNameKind Kind, const NamedDecl *D, const NamedDecl *Existing)
Determine whether D is a better lookup result than Existing, given that they declare the same entity.
static bool CanDeclareSpecialMemberFunction(const CXXRecordDecl *Class)
Determine whether we can declare a special member function within the class at this point.
static bool canHideTag(const NamedDecl *D)
Determine whether D can hide a tag declaration.
static std::string getHeaderNameForHeader(Preprocessor &PP, FileEntryRef E, llvm::StringRef IncludingFile)
Get a "quoted.h" or <angled.h> include path to use in a diagnostic suggesting the addition of a inclu...
static void addAssociatedClassesAndNamespaces(AssociatedLookup &Result, QualType T)
static QualType getOpenCLTypedefType(Sema &S, llvm::StringRef Name)
Lookup an OpenCL typedef type.
static DeclContext * findOuterContext(Scope *S)
Find the outer declaration context from this scope.
static void LookupPotentialTypoResult(Sema &SemaRef, LookupResult &Res, IdentifierInfo *Name, Scope *S, CXXScopeSpec *SS, DeclContext *MemberContext, bool EnteringContext, bool isObjCIvarLookup, bool FindHidden)
Perform name lookup for a possible result for typo correction.
static void checkCorrectionVisibility(Sema &SemaRef, TypoCorrection &TC)
Check whether the declarations found for a typo correction are visible.
static bool isNamespaceOrTranslationUnitScope(Scope *S)
static bool LookupQualifiedNameInUsingDirectives(Sema &S, LookupResult &R, DeclContext *StartDC)
Perform qualified name lookup in the namespaces nominated by using directives by the given context.
static bool LookupDirect(Sema &S, LookupResult &R, const DeclContext *DC)
static QualType getOpenCLEnumType(Sema &S, llvm::StringRef Name)
Lookup an OpenCL enum type.
static void CollectEnclosingNamespace(Sema::AssociatedNamespaceSet &Namespaces, DeclContext *Ctx)
static bool hasAcceptableDefaultArgument(Sema &S, const ParmDecl *D, llvm::SmallVectorImpl< Module * > *Modules, Sema::AcceptableKind Kind)
static bool isImplicitlyDeclaredMemberFunctionName(DeclarationName Name)
Determine whether this is the name of an implicitly-declared special member function.
static void getNestedNameSpecifierIdentifiers(NestedNameSpecifier NNS, SmallVectorImpl< const IdentifierInfo * > &Identifiers)
static void DeclareImplicitMemberFunctionsWithName(Sema &S, DeclarationName Name, SourceLocation Loc, const DeclContext *DC)
If there are any implicit member functions with the given name that need to be declared in the given ...
static void AddKeywordsToConsumer(Sema &SemaRef, TypoCorrectionConsumer &Consumer, Scope *S, CorrectionCandidateCallback &CCC, bool AfterNestedNameSpecifier)
Add keywords to the consumer as possible typo corrections.
static void GetQualTypesForOpenCLBuiltin(Sema &S, const OpenCLBuiltinStruct &OpenCLBuiltin, unsigned &GenTypeMaxCnt, SmallVector< QualType, 1 > &RetTypes, SmallVector< SmallVector< QualType, 1 >, 5 > &ArgTypes)
Get the QualType instances of the return type and arguments for an OpenCL builtin function signature.
static QualType diagOpenCLBuiltinTypeError(Sema &S, llvm::StringRef TypeClass, llvm::StringRef Name)
Diagnose a missing builtin type.
static bool hasAcceptableMemberSpecialization(Sema &S, const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules, Sema::AcceptableKind Kind)
static bool hasAcceptableDeclarationImpl(Sema &S, const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules, Filter F, Sema::AcceptableKind Kind)
static bool isCandidateViable(CorrectionCandidateCallback &CCC, TypoCorrection &Candidate)
static const DeclContext * getContextForScopeMatching(const Decl *D)
Get a representative context for a declaration such that two declarations will have the same context ...
static NamedDecl * findAcceptableDecl(Sema &SemaRef, NamedDecl *D, unsigned IDNS)
Retrieve the visible declaration corresponding to D, if any.
static void GetOpenCLBuiltinFctOverloads(ASTContext &Context, unsigned GenTypeMaxCnt, std::vector< QualType > &FunctionList, SmallVector< QualType, 1 > &RetTypes, SmallVector< SmallVector< QualType, 1 >, 5 > &ArgTypes)
Create a list of the candidate function overloads for an OpenCL builtin function.
static const unsigned MaxTypoDistanceResultSets
static const NamedDecl * getDefinitionToImport(const NamedDecl *D)
Find which declaration we should import to provide the definition of the given declaration.
static Sema::SpecialMemberCacheKey makeSpecialMemberCacheKey(const CXXRecordDecl *RD, CXXSpecialMemberKind SM, bool ConstArg, bool VolatileArg, bool RValueThis, bool ConstThis, bool VolatileThis)
static bool hasAcceptableExplicitSpecialization(Sema &S, const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules, Sema::AcceptableKind Kind)
static unsigned getIDNS(Sema::LookupNameKind NameKind, bool CPlusPlus, bool Redeclaration)
static void InsertOCLBuiltinDeclarationsFromTable(Sema &S, LookupResult &LR, IdentifierInfo *II, const unsigned FctIndex, const unsigned Len)
When trying to resolve a function name, if isOpenCLBuiltin() returns a non-null <Index,...
static void LookupPredefedObjCSuperType(Sema &Sema, Scope *S)
Looks up the declaration of "struct objc_super" and saves it for later use in building builtin declar...
static bool CppNamespaceLookup(Sema &S, LookupResult &R, ASTContext &Context, const DeclContext *NS, UnqualUsingDirectiveSet &UDirs)
This file declares semantic analysis functions specific to RISC-V.
__DEVICE__ long long abs(long long __n)
A class for storing results from argument-dependent lookup.
Definition Lookup.h:871
void insert(NamedDecl *D)
Adds a new ADL candidate to this map.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition ASTContext.h:245
TranslationUnitDecl * getTranslationUnitDecl() const
IdentifierTable & Idents
Definition ASTContext.h:855
Builtin::Context & BuiltinInfo
Definition ASTContext.h:857
bool isInSameModule(const Module *M1, const Module *M2) const
If the two module M1 and M2 are in the same module.
const clang::PrintingPolicy & getPrintingPolicy() const
Definition ASTContext.h:908
CanQualType VoidTy
QualType getTypedefType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const TypedefNameDecl *Decl, QualType UnderlyingType=QualType(), std::optional< bool > TypeMatchesDeclOrNone=std::nullopt) const
Return the unique reference to the type for the specified typedef-name decl.
CanQualType getCanonicalTagType(const TagDecl *TD) const
bool isPredefinedLibFunction(unsigned ID) const
Determines whether this builtin is a predefined libc/libm function, such as "malloc",...
Definition Builtins.h:323
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
DeclContext::lookup_iterator Decls
The declarations found inside this base class subobject.
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
CXXBasePath & front()
paths_iterator begin()
paths_iterator end()
void setOrigin(const CXXRecordDecl *Rec)
std::list< CXXBasePath >::iterator paths_iterator
std::list< CXXBasePath >::const_iterator const_paths_iterator
void swap(CXXBasePaths &Other)
Swap this data structure's contents with another CXXBasePaths object.
Represents a base class of a C++ class.
Definition DeclCXX.h:146
QualType getType() const
Retrieves the type of the base class.
Definition DeclCXX.h:249
Represents a C++ constructor within a class.
Definition DeclCXX.h:2645
Represents a C++ destructor within a class.
Definition DeclCXX.h:2924
Represents a static or instance method of a struct/union/class.
Definition DeclCXX.h:2153
Represents a C++ struct/union/class.
Definition DeclCXX.h:258
base_class_range bases()
Definition DeclCXX.h:609
bool hasAnyDependentBases() const
Determine whether this class has any dependent base classes which are not the current instantiation.
Definition DeclCXX.cpp:606
bool needsImplicitDefaultConstructor() const
Determine if we need to declare a default constructor for this class.
Definition DeclCXX.h:771
bool needsImplicitMoveConstructor() const
Determine whether this class should get an implicit move constructor or if any existing special membe...
Definition DeclCXX.h:899
CXXRecordDecl * getDefinition() const
Definition DeclCXX.h:549
static AccessSpecifier MergeAccess(AccessSpecifier PathAccess, AccessSpecifier DeclAccess)
Calculates the access of a decl that is reached along a path.
Definition DeclCXX.h:1745
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
Definition DeclCXX.cpp:2087
bool lookupInBases(BaseMatchesCallback BaseMatches, CXXBasePaths &Paths, bool LookupInDependent=false) const
Look for entities within the base classes of this C++ class, transitively searching all base class su...
bool needsImplicitCopyConstructor() const
Determine whether this class needs an implicit copy constructor to be lazily declared.
Definition DeclCXX.h:805
bool needsImplicitDestructor() const
Determine whether this class needs an implicit destructor to be lazily declared.
Definition DeclCXX.h:1017
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition DeclCXX.cpp:2129
UnresolvedSetIterator conversion_iterator
Definition DeclCXX.h:1129
bool needsImplicitMoveAssignment() const
Determine whether this class should get an implicit move assignment operator or if any existing speci...
Definition DeclCXX.h:992
bool needsImplicitCopyAssignment() const
Determine whether this class needs an implicit copy assignment operator to be lazily declared.
Definition DeclCXX.h:933
bool isDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is derived from the class Base.
Represents a C++ nested-name-specifier or a global scope specifier.
Definition DeclSpec.h:77
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition DeclSpec.h:184
SourceRange getRange() const
Definition DeclSpec.h:83
NestedNameSpecifier getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition DeclSpec.h:98
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition DeclSpec.h:187
bool isEmpty() const
No scope specifier.
Definition DeclSpec.h:182
Declaration of a class template.
Represents a class template specialization, which refers to a class template with a given set of temp...
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
virtual unsigned RankCandidate(const TypoCorrection &candidate)
Method used by Sema::CorrectTypo to assign an "edit distance" rank to a candidate (where a lower valu...
virtual bool ValidateCandidate(const TypoCorrection &candidate)
Simple predicate used by the default RankCandidate to determine whether to return an edit distance of...
virtual std::unique_ptr< CorrectionCandidateCallback > clone()=0
Clone this CorrectionCandidateCallback.
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
NamedDecl * getDecl() const
DeclListNode::iterator iterator
Definition DeclBase.h:1410
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition DeclBase.h:1467
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition DeclBase.h:2106
udir_range using_directives() const
Returns iterator range [First, Last) of UsingDirectiveDecls stored within this context.
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
Definition DeclBase.h:2259
lookup_result::iterator lookup_iterator
Definition DeclBase.h:2608
bool isFileContext() const
Definition DeclBase.h:2197
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
DeclContextLookupResult lookup_result
Definition DeclBase.h:2607
bool isTransparentContext() const
isTransparentContext - Determines whether this context is a "transparent" context,...
lookups_range noload_lookups(bool PreserveInternalState) const
Definition DeclLookups.h:89
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
Definition DeclBase.h:2122
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
bool isTranslationUnit() const
Definition DeclBase.h:2202
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
lookups_range lookups() const
Definition DeclLookups.h:75
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
bool isInlineNamespace() const
bool isFunctionOrMethod() const
Returns true if this DeclContext is a function, Objective-C method, or block, or a DeclContext that c...
Definition DeclBase.h:2161
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context semantically encloses the declaration context DC.
DeclContext * getEnclosingNonExpansionStatementContext()
Retrieve the innermost enclosing context that doesn't belong to an expansion statement.
Decl - This represents one declaration (or definition), e.g.
Definition DeclBase.h:86
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
Definition DeclBase.h:1079
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
Definition DeclBase.h:1244
bool isFunctionOrFunctionTemplate() const
Whether this declaration is a function or function template.
Definition DeclBase.h:1137
ASTContext & getASTContext() const LLVM_READONLY
Definition DeclBase.cpp:550
void addAttr(Attr *A)
bool isInNamedModule() const
Whether this declaration comes from a named module.
bool isUnconditionallyVisible() const
Determine whether this declaration is definitely visible to name lookup, independent of whether the o...
Definition DeclBase.h:872
bool isInIdentifierNamespace(unsigned NS) const
Definition DeclBase.h:911
bool isInvisibleOutsideTheOwningModule() const
Definition DeclBase.h:679
bool isInExportDeclContext() const
Whether this declaration was exported in a lexical context.
bool isInAnotherModuleUnit() const
Whether this declaration comes from another module unit.
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
Definition DeclBase.h:855
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition DeclBase.cpp:273
void dump() const
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
Definition DeclBase.h:2805
bool isInvalidDecl() const
Definition DeclBase.h:597
unsigned getIdentifierNamespace() const
Definition DeclBase.h:907
SourceLocation getLocation() const
Definition DeclBase.h:448
@ IDNS_NonMemberOperator
This declaration is a C++ operator declared in a non-class context.
Definition DeclBase.h:168
@ IDNS_TagFriend
This declaration is a friend class.
Definition DeclBase.h:157
@ IDNS_Ordinary
Ordinary names.
Definition DeclBase.h:144
@ IDNS_Type
Types, declared with 'struct foo', typedefs, etc.
Definition DeclBase.h:130
@ IDNS_OMPReduction
This declaration is an OpenMP user defined reduction construction.
Definition DeclBase.h:178
@ IDNS_Label
Labels, declared with 'x:' and referenced with 'goto x'.
Definition DeclBase.h:117
@ IDNS_Member
Members, declared with object declarations within tag definitions.
Definition DeclBase.h:136
@ IDNS_OMPMapper
This declaration is an OpenMP user defined mapper.
Definition DeclBase.h:181
@ IDNS_ObjCProtocol
Objective C @protocol.
Definition DeclBase.h:147
@ IDNS_Namespace
Namespaces, declared with 'namespace foo {}'.
Definition DeclBase.h:140
@ IDNS_OrdinaryFriend
This declaration is a friend function.
Definition DeclBase.h:152
@ IDNS_Using
This declaration is a using declaration.
Definition DeclBase.h:163
@ IDNS_LocalExtern
This declaration is a function-local extern declaration of a variable or function.
Definition DeclBase.h:175
@ IDNS_Tag
Tags, declared with 'struct foo;' and referenced with 'struct foo'.
Definition DeclBase.h:125
bool isDeprecated(std::string *Message=nullptr) const
Determine whether this declaration is marked 'deprecated'.
Definition DeclBase.h:775
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack.
Definition DeclBase.cpp:256
void setImplicit(bool I=true)
Definition DeclBase.h:603
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition DeclBase.h:1067
bool isDefinedOutsideFunctionOrMethod() const
isDefinedOutsideFunctionOrMethod - This predicate returns true if this scoped decl is defined outside...
Definition DeclBase.h:967
DeclContext * getDeclContext()
Definition DeclBase.h:457
bool hasTagIdentifierNamespace() const
Definition DeclBase.h:917
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
Definition DeclBase.h:936
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition DeclBase.h:996
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible.
Definition DeclBase.h:883
The name of a declaration.
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...
TemplateDecl * getCXXDeductionGuideTemplate() const
If this name is the name of a C++ deduction guide, return the template associated with that name.
std::string getAsString() const
Retrieve the human-readable string for this name.
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
QualType getCXXNameType() const
If this name is one of the C++ names (of a constructor, destructor, or conversion function),...
NameKind getNameKind() const
Determine what kind of name this is.
Represents an enum.
Definition Decl.h:4192
The return type of classify().
Definition Expr.h:341
This represents one expression.
Definition Expr.h:114
Classification Classify(ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
Definition Expr.h:417
QualType getType() const
Definition Expr.h:146
An abstract interface that should be implemented by external AST sources that also provide informatio...
bool isFPConstrained() const
A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...
Definition FileEntry.h:57
Cached information about one file (either on disk or in the virtual file system).
Definition FileEntry.h:273
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition Diagnostic.h:78
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
Definition Diagnostic.h:139
bool ValidateCandidate(const TypoCorrection &candidate) override
Simple predicate used by the default RankCandidate to determine whether to return an edit distance of...
FunctionCallFilterCCC(Sema &SemaRef, unsigned NumArgs, bool HasExplicitTemplateArgs, MemberExpr *ME=nullptr)
Represents a function declaration or definition.
Definition Decl.h:2082
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin=false, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=ConstexprSpecKind::Unspecified, const AssociatedConstraint &TrailingRequiresClause={})
Definition Decl.h:2345
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
Definition Decl.cpp:3926
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
Definition Decl.cpp:4340
bool isDeleted() const
Whether this function has been deleted.
Definition Decl.h:2709
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition Decl.cpp:3900
Represents a prototype with parameter type info, e.g.
Definition TypeBase.h:5548
ExtProtoInfo getExtProtoInfo() const
Definition TypeBase.h:5837
ArrayRef< QualType > param_types() const
Definition TypeBase.h:5988
Declaration of a template function.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
ExtInfo withCallingConv(CallingConv cc) const
Definition TypeBase.h:4967
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition TypeBase.h:4744
QualType getReturnType() const
Definition TypeBase.h:5084
std::string suggestPathToFileForDiagnostics(FileEntryRef File, llvm::StringRef MainFile, bool *IsAngled=nullptr) const
Suggest a path by which the specified file could be found, for use in diagnostics to suggest a includ...
One of these records is kept for each identifier that is lexed.
unsigned getBuiltinID() const
Return a value indicating whether this is a builtin function.
StringRef getName() const
Return the actual identifier string.
iterator - Iterate over the decls of a specified declaration name.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
IdentifierInfoLookup * getExternalIdentifierLookup() const
Retrieve the external identifier lookup object, if any.
Represents the declaration of a label.
Definition Decl.h:526
bool isGnuLocal() const
Definition Decl.h:553
static LabelDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II)
Definition Decl.cpp:5663
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
A class for iterating through a result set and possibly filtering out results.
Definition Lookup.h:677
void restart()
Restart the iteration.
Definition Lookup.h:718
void erase()
Erase the last element returned from this iterator.
Definition Lookup.h:723
Represents the results of name lookup.
Definition Lookup.h:147
static bool isAvailableForLookup(Sema &SemaRef, NamedDecl *ND)
Determine whether this lookup is permitted to see the declaration.
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
Definition Lookup.h:607
void setAllowHidden(bool AH)
Specify whether hidden declarations are visible, e.g., for recovery reasons.
Definition Lookup.h:298
static bool isAcceptable(Sema &SemaRef, NamedDecl *D, Sema::AcceptableKind Kind)
Definition Lookup.h:376
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
Definition Lookup.h:475
void setAmbiguousBaseSubobjects(CXXBasePaths &P)
Make these results show that the name was found in distinct base classes of the same type.
bool isSingleTagDecl() const
Asks if the result is a single tag decl.
Definition Lookup.h:582
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition Lookup.h:270
bool empty() const
Return true if no decls were found.
Definition Lookup.h:362
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition Lookup.h:666
void setAmbiguousBaseSubobjectTypes(CXXBasePaths &P)
Make these results show that the name was found in base classes of different types.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition Lookup.h:569
bool isAmbiguous() const
Definition Lookup.h:324
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition Lookup.h:331
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition Lookup.h:275
Sema & getSema() const
Get the Sema object that this lookup result is searching with.
Definition Lookup.h:672
UnresolvedSetImpl::iterator iterator
Definition Lookup.h:154
void print(raw_ostream &)
static bool isReachable(Sema &SemaRef, NamedDecl *D)
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition Lookup.h:636
bool isForRedeclaration() const
True if this lookup is just looking for an existing declaration.
Definition Lookup.h:280
DeclarationName getLookupName() const
Gets the name to look up.
Definition Lookup.h:265
iterator end() const
Definition Lookup.h:359
static bool isVisible(Sema &SemaRef, NamedDecl *D)
Determine whether the given declaration is visible to the program.
iterator begin() const
Definition Lookup.h:358
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition Expr.h:3433
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition TypeBase.h:3751
Describes a module or submodule.
Definition Module.h:340
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition Module.h:953
bool isPrivateModule() const
Definition Module.h:451
bool isModuleVisible(const Module *M) const
Determine whether the specified module would be visible to a lookup at the end of this module.
Definition Module.h:1068
bool isModuleInterfaceUnit() const
Definition Module.h:901
bool isModuleMapModule() const
Definition Module.h:453
bool isHeaderLikeModule() const
Is this module have similar semantics as headers.
Definition Module.h:869
StringRef getPrimaryModuleInterfaceName() const
Get the primary module interface name from a partition.
Definition Module.h:908
bool isExplicitGlobalModule() const
Definition Module.h:444
bool isGlobalModule() const
Does this Module scope describe a fragment of the global module within some C++ module.
Definition Module.h:441
bool isImplicitGlobalModule() const
Definition Module.h:447
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
Definition Module.cpp:242
bool isNamedModule() const
Does this Module is a named module of a standard named module?
Definition Module.h:426
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
Definition Module.h:943
llvm::SmallVector< ModuleRef, 2 > Imports
The set of modules imported by this module, and on which this module depends.
Definition Module.h:661
This represents a decl that may have a name.
Definition Decl.h:276
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition Decl.h:489
bool isModulePrivate() const
Whether this declaration was marked as being private to the module in which it was defined.
Definition DeclBase.h:657
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition Decl.h:297
bool isPlaceholderVar(const LangOptions &LangOpts) const
Definition Decl.cpp:1097
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition Decl.h:342
NamedDecl * getMostRecentDecl()
Definition Decl.h:503
bool isExternallyDeclarable() const
Determine whether this declaration can be redeclared in a different translation unit.
Definition Decl.h:441
Represent a C++ namespace.
Definition Decl.h:594
bool isAnonymousNamespace() const
Returns true if this is an anonymous namespace declaration.
Definition Decl.h:645
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
static constexpr NestedNameSpecifier getGlobal()
NamespaceAndPrefix getAsNamespaceAndPrefix() const
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool ResolveTemplateArguments=false, bool PrintFinalScopeResOp=true) const
Print this nested name specifier to the given output stream.
@ MicrosoftSuper
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace-like entity, stored as a NamespaceBaseDecl*.
Represents an ObjC class declaration.
Definition DeclObjC.h:1160
ObjCIvarDecl - Represents an ObjC instance variable.
Definition DeclObjC.h:1958
ObjCMethodDecl - Represents an instance or class method declaration.
Definition DeclObjC.h:140
Represents a pointer to an Objective C object.
Definition TypeBase.h:8219
qual_range quals() const
Definition TypeBase.h:8338
Represents one property declaration in an Objective-C interface.
Definition DeclObjC.h:734
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Definition Expr.h:1223
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
Definition Overload.h:1162
@ CSK_Normal
Normal lookup.
Definition Overload.h:1166
SmallVectorImpl< OverloadCandidate >::iterator iterator
Definition Overload.h:1378
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
Definition ExprCXX.h:3143
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition ExprCXX.h:3204
llvm::iterator_range< decls_iterator > decls() const
Definition ExprCXX.h:3242
Represents a parameter to a function.
Definition Decl.h:1832
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition Decl.h:1865
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition Decl.cpp:2963
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition TypeBase.h:3403
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
bool isMacroDefined(StringRef Id)
HeaderSearch & getHeaderSearchInfo() const
A (possibly-)qualified type.
Definition TypeBase.h:938
void addConst()
Add the const type qualifier to this QualType.
Definition TypeBase.h:1172
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition TypeBase.h:1005
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition TypeBase.h:8578
void addVolatile()
Add the volatile type qualifier to this QualType.
Definition TypeBase.h:1180
Represents a template name as written in source code.
Scope - A scope is a transient data structure that is used while parsing the program.
Definition Scope.h:41
bool isClassScope() const
isClassScope - Return true if this scope is a class/struct/union scope.
Definition Scope.h:414
const Scope * getFnParent() const
getFnParent - Return the closest scope that is a function body.
Definition Scope.h:284
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition Scope.h:269
DeclContext * getLookupEntity() const
Get the DeclContext in which to continue unqualified lookup after a lookup in this scope.
Definition Scope.h:393
using_directives_range using_directives()
Definition Scope.h:646
Scope * getContinueParent()
getContinueParent - Return the closest scope that a continue statement would be affected by.
Definition Scope.h:294
bool isDeclScope(const Decl *D) const
isDeclScope - Return true if this is the scope that the specified decl is declared in.
Definition Scope.h:384
DeclContext * getEntity() const
Get the entity corresponding to this scope.
Definition Scope.h:387
bool isTemplateParamScope() const
isTemplateParamScope - Return true if this scope is a C++ template parameter scope.
Definition Scope.h:467
Scope * getBreakParent()
getBreakParent - Return the closest scope that a break statement would be affected by.
Definition Scope.h:308
decl_range decls() const
Definition Scope.h:342
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition Scope.h:280
@ DeclScope
This is a scope that can contain a declaration.
Definition Scope.h:63
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition SemaBase.cpp:33
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition SemaBase.cpp:61
std::unique_ptr< sema::RISCVIntrinsicManager > IntrinsicManager
Definition SemaRISCV.h:57
A RAII object to temporarily push a declaration context.
Definition Sema.h:3652
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
Definition Sema.h:12735
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Definition Sema.h:12769
SpecialMemberOverloadResult - The overloading result for a special member function.
Definition Sema.h:9517
Sema - This implements semantic analysis and AST building for C.
Definition Sema.h:863
void DeclareGlobalNewDelete()
DeclareGlobalNewDelete - Declare the global forms of operator new and delete.
bool hasReachableDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a reachable definition.
CXXConstructorDecl * DeclareImplicitDefaultConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit default constructor for the given class.
llvm::DenseSet< Module * > LookupModulesCache
Cache of additional modules that should be used for name lookup within the current template instantia...
Definition Sema.h:13914
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
Definition Sema.h:13898
llvm::DenseSet< Module * > & getLookupModules()
Get the set of additional modules that should be checked during name lookup.
LookupNameKind
Describes the kind of name lookup to perform.
Definition Sema.h:9551
@ LookupLabel
Label name lookup.
Definition Sema.h:9560
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
Definition Sema.h:9555
@ LookupUsingDeclName
Look up all declarations in a scope with the given name, including resolved using declarations.
Definition Sema.h:9582
@ LookupNestedNameSpecifierName
Look up of a name that precedes the '::' scope resolution operator in C++.
Definition Sema.h:9574
@ LookupOMPReductionName
Look up the name of an OpenMP user-defined reduction operation.
Definition Sema.h:9596
@ LookupLocalFriendName
Look up a friend of a local class.
Definition Sema.h:9590
@ LookupObjCProtocolName
Look up the name of an Objective-C protocol.
Definition Sema.h:9592
@ LookupRedeclarationWithLinkage
Look up an ordinary name that is going to be redeclared as a name with linkage.
Definition Sema.h:9587
@ LookupOperatorName
Look up of an operator name (e.g., operator+) for use with operator overloading.
Definition Sema.h:9567
@ LookupObjCImplicitSelfParam
Look up implicit 'self' parameter of an objective-c method.
Definition Sema.h:9594
@ LookupNamespaceName
Look up a namespace name within a C++ using directive or namespace alias definition,...
Definition Sema.h:9578
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
Definition Sema.h:9563
@ LookupDestructorName
Look up a name following ~ in a destructor name.
Definition Sema.h:9570
@ LookupTagName
Tag name lookup, which finds the names of enums, classes, structs, and unions.
Definition Sema.h:9558
@ LookupOMPMapperName
Look up the name of an OpenMP user-defined mapper.
Definition Sema.h:9598
@ LookupAnyName
Look up any declaration with any name.
Definition Sema.h:9600
std::pair< const CXXRecordDecl *, unsigned > SpecialMemberCacheKey
Definition Sema.h:9536
bool hasReachableDeclarationSlow(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
MissingImportKind
Kinds of missing import.
Definition Sema.h:9991
void ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class)
Force the declaration of any implicitly-declared members of this class.
bool hasVisibleDeclarationSlow(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules)
void LookupNecessaryTypesForBuiltin(Scope *S, unsigned ID)
bool LookupInSuper(LookupResult &R, CXXRecordDecl *Class)
Perform qualified name lookup into all base classes of the given class.
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
@ AR_accessible
Definition Sema.h:1728
Preprocessor & getPreprocessor() const
Definition Sema.h:934
CXXConstructorDecl * DeclareImplicitMoveConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit move constructor for the given class.
static NamedDecl * getAsTemplateNameDecl(NamedDecl *D, bool AllowFunctionTemplates=true, bool AllowDependent=true)
Try to interpret the lookup result D as a template-name.
LiteralOperatorLookupResult LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef< QualType > ArgTys, bool AllowRaw, bool AllowTemplate, bool AllowStringTemplate, bool DiagnoseMissing, StringLiteral *StringLit=nullptr)
LookupLiteralOperator - Determine which literal operator should be used for a user-defined literal,...
bool hasVisibleExplicitSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if there is a visible declaration of D that is an explicit specialization declaration for a...
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=RedeclarationKind::NotForRedeclaration)
Look up a name, looking for a single declaration.
@ CTAK_Specified
The template argument was specified in the code or was instantiated with some deduced template argume...
Definition Sema.h:12249
llvm::DenseMap< NamedDecl *, NamedDecl * > VisibleNamespaceCache
Map from the most recent declaration of a namespace to the most recent visible declaration of that na...
Definition Sema.h:13918
bool hasMergedDefinitionInCurrentModule(const NamedDecl *Def)
ASTContext & Context
Definition Sema.h:1332
bool LookupBuiltin(LookupResult &R)
Lookup a builtin function, when name lookup would otherwise fail.
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S, UnresolvedSetImpl &Functions)
bool hasVisibleDefaultArgument(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if the template parameter D has a visible default argument.
NamedDecl * LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID, Scope *S, bool ForRedeclaration, SourceLocation Loc)
LazilyCreateBuiltin - The specified Builtin-ID was first used at file scope.
ASTContext & getASTContext() const
Definition Sema.h:935
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
llvm::SmallSetVector< CXXRecordDecl *, 16 > AssociatedClassSet
Definition Sema.h:9548
std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths)
Builds a string representing ambiguous paths from a specific derived class to different subobjects of...
Module * getOwningModule(const Decl *Entity)
Get the module owning an entity.
Definition Sema.h:3769
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
Definition Sema.cpp:1785
void FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc, ArrayRef< Expr * > Args, AssociatedNamespaceSet &AssociatedNamespaces, AssociatedClassSet &AssociatedClasses)
Find the associated classes and namespaces for argument-dependent lookup for a call with the given se...
void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, TemplateArgumentListInfo *ExplicitTemplateArgs, QualType ObjectType, Expr::Classification ObjectClassification, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, OverloadCandidateParamOrder PO={})
Add a C++ member function template as a candidate to the candidate set, using template argument deduc...
bool CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &Arg, NamedDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, unsigned ArgumentPackIndex, CheckTemplateArgumentInfo &CTAI, CheckTemplateArgumentKind CTAK)
Check that the given template argument corresponds to the given template parameter.
void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
Add a C++ function template specialization as a candidate in the candidate set, using template argume...
FPOptions & getCurFPFeatures()
Definition Sema.h:930
CXXConstructorDecl * LookupDefaultConstructor(CXXRecordDecl *Class)
Look up the default constructor for the given class.
const LangOptions & getLangOpts() const
Definition Sema.h:928
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
void LookupVisibleDecls(Scope *S, LookupNameKind Kind, VisibleDeclConsumer &Consumer, bool IncludeGlobalScope=true, bool LoadExternal=true)
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, QualType ObjectType, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
Preprocessor & PP
Definition Sema.h:1331
bool hasVisibleMemberSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if there is a visible declaration of D that is a member specialization declaration (as oppo...
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, bool AllowExplicitConversion=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions={}, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false, bool StrictPackMatch=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
bool isReachable(const NamedDecl *D)
Determine whether a declaration is reachable.
Definition Sema.h:15865
SemaHLSL & HLSL()
Definition Sema.h:1521
llvm::SmallSetVector< DeclContext *, 16 > AssociatedNamespaceSet
Definition Sema.h:9547
CXXMethodDecl * DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl)
Declare the implicit move assignment operator for the given class.
SemaRISCV & RISCV()
Definition Sema.h:1586
NamedDecl * getCurFunctionOrMethodDecl() const
getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method or C function we're in,...
Definition Sema.cpp:1792
sema::FunctionScopeInfo * getCurFunction() const
Definition Sema.h:1367
bool isVisible(const NamedDecl *D)
Determine whether a declaration is visible to name lookup.
Definition Sema.h:15859
Module * getCurrentModule() const
Get the module unit whose scope we are currently within.
Definition Sema.h:10083
void NoteOverloadCandidate(const NamedDecl *Found, const FunctionDecl *Fn, OverloadCandidateRewriteKind RewriteKind=OverloadCandidateRewriteKind(), QualType DestType=QualType(), bool TakingAddress=false)
bool hasReachableDefaultArgument(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if the template parameter D has a reachable default argument.
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
Definition Sema.cpp:2695
void ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc, ArrayRef< Expr * > Args, ADLResult &Functions)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition Sema.h:1484
SemaOpenCL & OpenCL()
Definition Sema.h:1566
CXXMethodDecl * LookupMovingAssignment(CXXRecordDecl *Class, unsigned Quals, bool RValueThis, unsigned ThisQuals)
Look up the moving assignment operator for the given class.
CXXMethodDecl * DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl)
Declare the implicit copy assignment operator for the given class.
CXXConstructorDecl * LookupMovingConstructor(CXXRecordDecl *Class, unsigned Quals)
Look up the moving constructor for the given class.
bool isAcceptable(const NamedDecl *D, AcceptableKind Kind)
Determine whether a declaration is acceptable (visible/reachable).
Definition Sema.h:15872
CXXMethodDecl * LookupCopyingAssignment(CXXRecordDecl *Class, unsigned Quals, bool RValueThis, unsigned ThisQuals)
Look up the copying assignment operator for the given class.
bool isModuleVisible(const Module *M, bool ModulePrivate=false)
void AddMethodCandidate(DeclAccessPair FoundDecl, QualType ObjectType, Expr::Classification ObjectClassification, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversion=false, OverloadCandidateParamOrder PO={})
AddMethodCandidate - Adds a named decl (which is some kind of method) as a method candidate to the gi...
bool hasVisibleMergedDefinition(const NamedDecl *Def)
void DeclareImplicitDeductionGuides(TemplateDecl *Template, SourceLocation Loc)
Declare implicit deduction guides for a class template if we've not already done so.
void diagnoseEquivalentInternalLinkageDeclarations(SourceLocation Loc, const NamedDecl *D, ArrayRef< const NamedDecl * > Equiv)
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
void diagnoseMissingImport(SourceLocation Loc, const NamedDecl *Decl, MissingImportKind MIK, bool Recover=true)
Diagnose that the specified declaration needs to be visible but isn't, and suggest a module import th...
bool hasReachableMemberSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if there is a reachable declaration of D that is a member specialization declaration (as op...
LabelDecl * LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc, SourceLocation GnuLabelLoc=SourceLocation(), bool IsLabelStmt=false)
LookupOrCreateLabel - Do a name lookup of a label with the specified name.
RedeclarationKind forRedeclarationInCurContext() const
CXXConstructorDecl * LookupCopyingConstructor(CXXRecordDecl *Class, unsigned Quals)
Look up the copying constructor for the given class.
IntrusiveRefCntPtr< ExternalSemaSource > ExternalSource
Source of additional semantic information.
Definition Sema.h:1622
ASTConsumer & Consumer
Definition Sema.h:1333
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition Sema.h:1291
void DiagnoseAmbiguousLookup(LookupResult &Result)
Produce a diagnostic describing the ambiguity that resulted from name lookup.
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
void makeMergedDefinitionVisible(NamedDecl *ND)
Make a merged definition of an existing hidden definition ND visible at the specified location.
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
SourceManager & SourceMgr
Definition Sema.h:1335
bool hasReachableExplicitSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if there is a reachable declaration of D that is an explicit specialization declaration for...
CXXConstructorDecl * DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit copy constructor for the given class.
SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D, CXXSpecialMemberKind SM, bool ConstArg, bool VolatileArg, bool RValueThis, bool ConstThis, bool VolatileThis)
bool hasAcceptableDefaultArgument(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules, Sema::AcceptableKind Kind)
Determine if the template parameter D has a reachable default argument.
SmallVector< Module *, 16 > CodeSynthesisContextLookupModules
Extra modules inspected when performing a lookup during a template instantiation.
Definition Sema.h:13909
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
Definition Sema.cpp:643
bool hasAcceptableDefinition(NamedDecl *D, NamedDecl **Suggested, AcceptableKind Kind, bool OnlyNeedComplete=false)
llvm::DenseMap< SpecialMemberCacheKey, SpecialMemberOverloadResult > SpecialMemberCache
A cache of special member function overload resolution results for C++ records.
Definition Sema.h:9541
LiteralOperatorLookupResult
The possible outcomes of name lookup for a literal operator.
Definition Sema.h:9604
@ LOLR_ErrorNoDiagnostic
The lookup found no match but no diagnostic was issued.
Definition Sema.h:9608
@ LOLR_Raw
The lookup found a single 'raw' literal operator, which expects a string literal containing the spell...
Definition Sema.h:9614
@ LOLR_Error
The lookup resulted in an error.
Definition Sema.h:9606
@ LOLR_Cooked
The lookup found a single 'cooked' literal operator, which expects a normal literal to be built and p...
Definition Sema.h:9611
@ LOLR_StringTemplatePack
The lookup found an overload set of literal operator templates, which expect the character type and c...
Definition Sema.h:9622
@ LOLR_Template
The lookup found an overload set of literal operator templates, which expect the characters of the sp...
Definition Sema.h:9618
void ActOnPragmaDump(Scope *S, SourceLocation Loc, IdentifierInfo *II)
Called on pragma clang __debug dump II.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
IdentifierResolver IdResolver
Definition Sema.h:3645
LabelDecl * LookupExistingLabel(IdentifierInfo *II, SourceLocation IdentLoc)
Perform a name lookup for a label with the specified name; this does not create a new label if the lo...
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
CXXDestructorDecl * DeclareImplicitDestructor(CXXRecordDecl *ClassDecl)
Declare the implicit destructor for the given class.
void createImplicitModuleImportForErrorRecovery(SourceLocation Loc, Module *Mod)
Create an implicit import of the given module at the given source location, for error recovery,...
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
A trivial tuple used to represent a source range.
SourceLocation getBegin() const
void dump() const
Dumps the specified AST fragment and all subtrees to llvm::errs().
StringLiteral - This represents a string literal expression, e.g.
Definition Expr.h:1844
Represents the declaration of a struct/union/class/enum.
Definition Decl.h:3898
A template argument list.
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Location wrapper for a TemplateArgument.
Represents a template argument.
QualType getAsType() const
Retrieve the type for a type template argument.
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ StructuralValue
The template argument is a non-type template argument that can't be represented by the special-case D...
@ Pack
The template argument is actually a parameter pack.
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion,...
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl(bool IgnoreDeduced=false) const
Retrieve the underlying template declaration that this template name refers to, if known.
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
Represents a declaration of a type.
Definition Decl.h:3694
The base class of the type hierarchy.
Definition TypeBase.h:1879
const TemplateSpecializationType * getAsNonAliasTemplateSpecializationType() const
Look through sugar for an instance of TemplateSpecializationType which is not a type alias,...
Definition Type.cpp:2092
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition Type.h:26
const T * castAs() const
Member-template castAs<specific type>.
Definition TypeBase.h:9498
bool isReferenceType() const
Definition TypeBase.h:8839
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition Type.cpp:885
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition TypeBase.h:2863
QualType getCanonicalTypeInternal() const
Definition TypeBase.h:3200
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
Definition Type.cpp:2657
bool isAnyPointerType() const
Definition TypeBase.h:8823
TypeClass getTypeClass() const
Definition TypeBase.h:2449
const T * getAs() const
Member-template getAs<specific type>'.
Definition TypeBase.h:9431
Base class for declarations which introduce a typedef-name.
Definition Decl.h:3743
void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx, bool InBaseClass) override
Invoked each time Sema::LookupVisibleDecls() finds a declaration visible from the current scope or co...
void addKeywordResult(StringRef Keyword)
void addCorrection(TypoCorrection Correction)
const TypoCorrection & getNextCorrection()
Return the next typo correction that passes all internal filters and is deemed valid by the consumer'...
void FoundName(StringRef Name)
void addNamespaces(const llvm::MapVector< NamespaceDecl *, bool > &KnownNamespaces)
Set-up method to add to the consumer the set of namespaces to use in performing corrections to nested...
Simple class containing the result of Sema::CorrectTypo.
IdentifierInfo * getCorrectionAsIdentifierInfo() const
ArrayRef< PartialDiagnostic > getExtraDiagnostics() const
static const unsigned InvalidDistance
void addCorrectionDecl(NamedDecl *CDecl)
Add the given NamedDecl to the list of NamedDecls that are the declarations associated with the Decla...
void setCorrectionDecls(ArrayRef< NamedDecl * > Decls)
Clears the list of NamedDecls and adds the given set.
std::string getAsString(const LangOptions &LO) const
bool requiresImport() const
Returns whether this typo correction is correcting to a declaration that was declared in a module tha...
void setCorrectionRange(CXXScopeSpec *SS, const DeclarationNameInfo &TypoName)
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
SourceRange getCorrectionRange() const
void WillReplaceSpecifier(bool ForceReplacement)
void setCallbackDistance(unsigned ED)
decl_iterator begin()
DeclarationName getCorrection() const
Gets the DeclarationName of the typo correction.
unsigned getEditDistance(bool Normalized=true) const
Gets the "edit distance" of the typo correction from the typo.
SmallVectorImpl< NamedDecl * >::iterator decl_iterator
void setRequiresImport(bool Req)
std::string getQuoted(const LangOptions &LO) const
NestedNameSpecifier getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
NamedDecl * getFoundDecl() const
Get the correction declaration found by name lookup (before we looked through using shadow declaratio...
A set of unresolved declarations.
void append(iterator I, iterator E)
NamespaceDecl * getNominatedNamespace()
Returns the namespace nominated by this using-directive.
Definition DeclCXX.cpp:3357
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Definition DeclCXX.h:3446
QualType getType() const
Definition Decl.h:725
Represents a variable declaration or definition.
Definition Decl.h:934
VarDecl * getTemplateInstantiationPattern() const
Retrieve the variable declaration from which this variable could be instantiated, if it is an instant...
Definition Decl.cpp:2719
Consumes visible declarations found when searching for all visible names within a given scope or cont...
Definition Lookup.h:838
virtual bool includeHiddenDecls() const
Determine whether hidden declarations (from unimported modules) should be given to this consumer.
virtual ~VisibleDeclConsumer()
Destroys the visible declaration consumer.
SmallVector< SwitchInfo, 8 > SwitchStack
SwitchStack - This is the current set of active switch statements in the block.
Definition ScopeInfo.h:214
Provides information about an attempted template argument deduction, whose success or failure was des...
Defines the clang::TargetInfo interface.
Definition SPIR.cpp:47
bool Load(InterpState &S, CodePtr OpPC)
Definition Interp.h:2189
std::variant< struct RequiresDecl, struct HeaderDecl, struct UmbrellaDirDecl, struct ModuleDecl, struct ExcludeDecl, struct ExportDecl, struct ExportAsDecl, struct ExternModuleDecl, struct UseDecl, struct LinkDecl, struct ConfigMacrosDecl, struct ConflictDecl > Decl
All declarations that can appear in a module declaration.
Top level wrappers for InstallAPI frontend operations.
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
bool isa(CodeGen::Address addr)
Definition Address.h:330
CustomizableOptional< FileEntryRef > OptionalFileEntryRef
Definition FileEntry.h:196
@ CPlusPlus
@ CPlusPlus11
@ OR_Deleted
Succeeded, but refers to a deleted function.
Definition Overload.h:61
@ OR_Success
Overload resolution succeeded.
Definition Overload.h:52
@ OR_Ambiguous
Ambiguous candidates found.
Definition Overload.h:58
@ OR_No_Viable_Function
No viable function found.
Definition Overload.h:55
@ Specialization
We are substituting template parameters for template arguments in order to form a template specializa...
Definition Template.h:50
@ Ambiguous
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
Definition Lookup.h:64
@ NotFound
No entity found met the criteria.
Definition Lookup.h:41
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
Definition Lookup.h:54
@ Found
Name lookup found a single declaration that met the criteria.
Definition Lookup.h:50
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
Definition Lookup.h:59
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
Definition Lookup.h:46
@ TemplateName
The identifier is a template name. FIXME: Add an annotation for that.
Definition Parser.h:61
@ Redeclaration
Merge availability attributes for a redeclaration, which requires an exact match.
Definition Sema.h:627
std::unique_ptr< sema::RISCVIntrinsicManager > CreateRISCVIntrinsicManager(Sema &S)
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition Specifiers.h:127
@ AS_public
Definition Specifiers.h:128
@ AS_none
Definition Specifiers.h:131
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
@ AmbiguousBaseSubobjects
Name lookup results in an ambiguity because multiple nonstatic entities that meet the lookup criteria...
Definition Lookup.h:94
@ AmbiguousTagHiding
Name lookup results in an ambiguity because an entity with a tag name was hidden by an entity with an...
Definition Lookup.h:137
@ AmbiguousReferenceToPlaceholderVariable
Name lookup results in an ambiguity because multiple placeholder variables were found in the same sco...
Definition Lookup.h:120
@ AmbiguousReference
Name lookup results in an ambiguity because multiple definitions of entity that meet the lookup crite...
Definition Lookup.h:109
@ AmbiguousBaseSubobjectTypes
Name lookup results in an ambiguity because multiple entities that meet the lookup criteria were foun...
Definition Lookup.h:80
@ SC_Extern
Definition Specifiers.h:255
@ SC_None
Definition Specifiers.h:254
@ External
External linkage, which indicates that the entity can be referred to from other translation units.
Definition Linkage.h:58
TemplateDecl * getAsTypeTemplateDecl(Decl *D)
@ Result
The result type of a method or function.
Definition TypeBase.h:906
std::pair< unsigned, unsigned > getDepthAndIndex(const NamedDecl *ND)
Retrieve the depth and index of a template parameter.
CorrectTypoKind
Definition Sema.h:812
const FunctionProtoType * T
llvm::Expected< QualType > ExpectedType
@ Template
We are parsing a template declaration.
Definition Parser.h:81
@ Keyword
The name has been typo-corrected to a keyword.
Definition Sema.h:556
CXXSpecialMemberKind
Kinds of C++ special members.
Definition Decl.h:2031
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition Specifiers.h:136
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
Definition Specifiers.h:139
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
Definition Specifiers.h:143
for(const auto &A :T->param_types())
@ Success
Template argument deduction was successful.
Definition Sema.h:376
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
Definition Specifiers.h:202
U cast(CodeGen::Address addr)
Definition Address.h:327
ConstructorInfo getConstructorInfo(NamedDecl *ND)
Definition Overload.h:1525
@ None
No keyword precedes the qualified type name.
Definition TypeBase.h:6167
@ Class
The "class" keyword introduces the elaborated-type-specifier.
Definition TypeBase.h:6157
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
Definition TypeBase.h:6160
@ EST_None
no exception specification
Represents an element in a path from a derived class to a base class.
int SubobjectNumber
Identifies which base class subobject (of type Base->getType()) this base path element refers to.
const CXXBaseSpecifier * Base
The base specifier that states the link from a derived class to a base class, which will be followed ...
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
Extra information about a function prototype.
Definition TypeBase.h:5633
Describes how types, statements, expressions, and declarations should be printed.