Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/SemaLookup_8cpp_source.html below:

clang: lib/Sema/SemaLookup.cpp Source File

;

UnqualUsingEntry {

: Nominated(Nominated), CommonAncestor(CommonAncestor) {

CommonAncestor;

operator()(

UnqualUsingEntry &L,

UnqualUsingEntry &R) {

L.getCommonAncestor() < R.getCommonAncestor();

operator()(

UnqualUsingEntry &

,

*DC) {

.getCommonAncestor() < DC;

operator()(

*DC,

UnqualUsingEntry &

) {

DC <

.getCommonAncestor();

UnqualUsingDirectiveSet {

UnqualUsingDirectiveSet(

&SemaRef) : SemaRef(SemaRef) {}

visitScopeChain(

*S,

*InnermostFileScope) {

assert(InnermostFileDC && InnermostFileDC->

());

(; S; S = S->getParent()) {

(Ctx && Ctx->isFileContext()) {

}

(!Ctx || Ctx->isFunctionOrMethod()) {

(

*I : S->using_directives())

visit(I, InnermostFileDC);

(!visited.insert(DC).second)

addUsingDirectives(DC, EffectiveDC);

(!visited.insert(NS).second)

addUsingDirective(UD, EffectiveDC);

addUsingDirectives(NS, EffectiveDC);

(SemaRef.

(UD) && visited.insert(NS).second) {

addUsingDirective(UD, EffectiveDC);

DC = queue.pop_back_val();

(!Common->

(EffectiveDC))

done() { llvm::sort(list, UnqualUsingEntry::Comparator()); }

ListTy::const_iterator const_iterator;

const_iterator begin()

{

list.begin(); }

const_iterator end()

{

list.end(); }

llvm::iterator_range<const_iterator>

llvm::make_range(std::equal_range(begin(), end(),

UnqualUsingEntry::Comparator()));

Redeclaration) {

assert(!Redeclaration &&

);

assert(Redeclaration &&

);

LookupResult::configure() {

OO_Array_Delete:

(

BuiltinID =

->getBuiltinID()) {

LookupResult::checkDebugAssumptions()

{

assert(ResultKind !=

|| Decls.

() == 1);

(Decls.

() == 1 &&

isa<FunctionTemplateDecl>((*

())->getUnderlyingDecl())));

assert((Paths !=

) == (ResultKind ==

&&

!isa<UsingShadowDecl>(Existing))

*DUnderlying =

->getUnderlyingDecl();

(DUnderlying->getCanonicalDecl() != EUnderlying->getCanonicalDecl()) {

assert(isa<TypeDecl>(DUnderlying) && isa<TypeDecl>(EUnderlying));

HaveTag = isa<TagDecl>(EUnderlying);

HaveTag != WantTag;

(

*DFD = dyn_cast<FunctionDecl>(DUnderlying)) {

*EFD = cast<FunctionDecl>(EUnderlying);

DMin = DFD->getMinRequiredArguments();

EMin = EFD->getMinRequiredArguments();

(

*DTD = dyn_cast<TemplateDecl>(DUnderlying)) {

*ETD = cast<TemplateDecl>(EUnderlying);

DMin = DTD->getTemplateParameters()->getMinRequiredArguments();

EMin = ETD->getTemplateParameters()->getMinRequiredArguments();

(

I = DMin, N = DTD->getTemplateParameters()->size();

ETD->getTemplateParameters()->getParam(I)) &&

DTD->getTemplateParameters()->getParam(I)))

(

*DVD = dyn_cast<VarDecl>(DUnderlying)) {

*EVD = cast<VarDecl>(EUnderlying);

(EVD->getType()->isIncompleteType() &&

!DVD->getType()->isIncompleteType()) {

(!isa<FunctionDecl>(DUnderlying) && !isa<VarDecl>(DUnderlying)) {

(Prev == EUnderlying)

=

->getUnderlyingDecl();

isa<VarDecl>(

) || isa<EnumConstantDecl>(

) || isa<FunctionDecl>(

) ||

isa<FunctionTemplateDecl>(

) || isa<FieldDecl>(

) ||

isa<UnresolvedUsingValueDecl>(

);

N = Decls.

();

(isa<FunctionTemplateDecl>(

))

(isa<UnresolvedUsingValueDecl>(

))

llvm::SmallDenseMap<const NamedDecl *, unsigned, 16> Unique;

llvm::SmallDenseMap<QualType, unsigned, 16> UniqueTypes;

ReferenceToPlaceHolderVariable =

;

HasTag =

, HasFunction =

;

HasFunctionTemplate =

, HasUnresolved =

;

*HasNonFunction =

;

llvm::BitVector RemovedDecls(N);

(

I = 0; I < N; I++) {

*

= Decls[I]->getUnderlyingDecl();

N - RemovedDecls.count() > 1) {

(HideTags && isa<TagDecl>(

)) {

Hidden =

;

(

*OtherDecl : Decls) {

(

(OtherDecl) && !OtherDecl->isInvalidDecl() &&

std::optional<unsigned> ExistingI;

(

*TD = dyn_cast<TypeDecl>(

)) {

UniqueResult = UniqueTypes.insert(

(!UniqueResult.second) {

ExistingI = UniqueResult.first->second;

UniqueResult = Unique.insert(std::make_pair(

, I));

(!UniqueResult.second) {

ExistingI = UniqueResult.first->second;

Decls[*ExistingI] = Decls[I];

(isa<UnresolvedUsingValueDecl>(

)) {

HasUnresolved =

;

}

(isa<TagDecl>(

)) {

}

(isa<FunctionTemplateDecl>(

)) {

HasFunctionTemplate =

;

}

(isa<FunctionDecl>(

)) {

(HasNonFunction) {

(

().isEquivalentInternalLinkageDeclaration(HasNonFunction,

EquivalentNonFunctions.push_back(

);

(

->isPlaceholderVar(

().getLangOpts()) &&

ReferenceToPlaceHolderVariable =

;

(!EquivalentNonFunctions.empty() && !

)

(), HasNonFunction, EquivalentNonFunctions);

(

I = RemovedDecls.find_last(); I >= 0; I = RemovedDecls.find_prev(I))

Decls[I] = Decls[--N];

((HasNonFunction && (HasFunction || HasUnresolved)) ||

(HideTags && HasTag && (HasFunction || HasNonFunction || HasUnresolved)))

(

&& ReferenceToPlaceHolderVariable)

(HasUnresolved)

(N > 1 || HasFunctionTemplate)

LookupResult::addDeclsFromBasePaths(

&

) {

(I =

.begin(),

=

.end(); I !=

; ++I)

addDeclsFromBasePaths(*Paths);

addDeclsFromBasePaths(*Paths);

Out << Decls.

() <<

;

(Paths) Out <<

;

llvm::StringRef Name) {

<< TypeClass << Name;

&S,

OpenCLBuiltinStruct &OpenCLBuiltin,

&GenTypeMaxCnt,

Sig = SignatureTable[OpenCLBuiltin.SigTableIndex];

OCL2Qual(S, TypeTable[Sig], RetTypes);

GenTypeMaxCnt = RetTypes.size();

(

Index = 1; Index < OpenCLBuiltin.NumTypes; Index++) {

OCL2Qual(S, TypeTable[SignatureTable[OpenCLBuiltin.SigTableIndex + Index]],

GenTypeMaxCnt = (Ty.size() > GenTypeMaxCnt) ? Ty.size() : GenTypeMaxCnt;

ArgTypes.push_back(std::move(Ty));

(RetTypes.size() == 0)

(

IGenType = 0; IGenType < GenTypeMaxCnt; IGenType++) {

(

A = 0; A < ArgTypes.size(); A++) {

(ArgTypes[A].size() == 0)

assert(GenTypeMaxCnt % ArgTypes[A].size() == 0 &&

);

Idx = IGenType % ArgTypes[A].size();

ArgList.push_back(ArgTypes[A][Idx]);

RetTypes[(RetTypes.size() != 1) ? IGenType : 0], ArgList, PI));

FctIndex,

Len) {

HasGenType =

;

GenTypeMaxCnt;

(

SignatureIndex = 0; SignatureIndex < Len; SignatureIndex++) {

OpenCLBuiltinStruct &OpenCLBuiltin =

BuiltinTable[FctIndex + SignatureIndex];

(!isOpenCLVersionContainedInMask(Context.

(),

OpenCLBuiltin.Versions))

StringRef Extensions = FunctionExtensionTable[OpenCLBuiltin.Extension];

(!Extensions.empty()) {

Extensions.split(ExtVec,

);

AllExtensionsDefined =

;

(StringRef Ext : ExtVec) {

AllExtensionsDefined =

;

(!AllExtensionsDefined)

(GenTypeMaxCnt > 1) {

std::vector<QualType> FunctionList;

(

&FTy : FunctionList) {

FTy->isFunctionProtoType());

*FP = cast<FunctionProtoType>(FTy);

(

IParm = 0, e = FP->getNumParams(); IParm != e; ++IParm) {

, FP->getParamType(IParm),

,

,

);

ParmList.push_back(Parm);

NewOpenCLBuiltin->setParams(ParmList);

(OpenCLBuiltin.IsPure)

NewOpenCLBuiltin->

(PureAttr::CreateImplicit(Context));

(OpenCLBuiltin.IsConst)

NewOpenCLBuiltin->

(ConstAttr::CreateImplicit(Context));

(OpenCLBuiltin.IsConv)

NewOpenCLBuiltin->

(ConvergentAttr::CreateImplicit(Context));

NewOpenCLBuiltin->

(OverloadableAttr::CreateImplicit(Context));

LR.

(NewOpenCLBuiltin);

(Len > 1 || HasGenType)

Index = isOpenCLBuiltin(II->

());

(

().DeclareRVVBuiltins ||

().DeclareSiFiveVectorBuiltins) {

(!

().IntrinsicManager)

(

().IntrinsicManager->CreateIntrinsicIfFound(R, II,

))

(ID == Builtin::BIobjc_msgSendSuper)

(!

->getDefinition() ||

->isDependentContext())

!

->isBeingDefined();

(

->needsImplicitDefaultConstructor())

(

->needsImplicitCopyConstructor())

(

->needsImplicitCopyAssignment())

(

->needsImplicitMoveConstructor())

(

->needsImplicitMoveAssignment())

(

->needsImplicitDestructor())

(Name.getNameKind()) {

Name.getCXXOverloadedOperator() == OO_Equal;

(Name.getNameKind()) {

(

->needsImplicitDefaultConstructor())

(

->needsImplicitCopyConstructor())

->needsImplicitMoveConstructor())

(

->getDefinition() &&

->needsImplicitDestructor() &&

(Name.getCXXOverloadedOperator() != OO_Equal)

(

->needsImplicitCopyAssignment())

->needsImplicitMoveAssignment())

=

;

!isa<CXXRecordDecl>(DC))

(!

->isCompleteDefinition())

*ContainedDeducedType =

ContainedDeducedType && ContainedDeducedType->isUndeducedType())

UEnd =

->conversion_end();

!= UEnd; ++

) {

assert(ConvProto &&

);

UnqualUsingDirectiveSet &UDirs) {

assert(NS && NS->

() &&

);

(

UnqualUsingEntry &UUE : UDirs.getNamespacesFor(NS))

Ctx->isFileContext();

(

*OuterS = S->getParent(); OuterS; OuterS = OuterS->getParent())

FindLocalExternScope {

: R(R), OldFindLocalExtern(R.getIdentifierNamespace() &

::IDNS_LocalExtern) {

~FindLocalExternScope() {

OldFindLocalExtern;

Name.getCXXNameType()->isDependentType()) {

UnqualUsingDirectiveSet UDirs(*

);

VisitedUsingDirectives =

;

LeftStartingScope =

;

FindLocalExternScope FindLocals(R);

SearchNamespaceScope =

;

(; I != IEnd && S->isDeclScope(*I); ++I) {

!(*I)->isTemplateParameter()) {

(!LeftStartingScope && !Initial->

(*I))

LeftStartingScope =

;

(LeftStartingScope && !((*I)->hasLinkage())) {

SearchNamespaceScope =

;

(!SearchNamespaceScope) {

(S->isClassScope())

(

*

= dyn_cast_if_present<CXXRecordDecl>(S->getEntity()))

(; Ctx && !Ctx->Equals(OuterCtx); Ctx = Ctx->getLookupParent()) {

(Ctx->isTransparentContext())

(Ctx->isFunctionOrMethod()) {

(Method->isInstanceMethod() && Name.getAsIdentifierInfo())

Name.getAsIdentifierInfo(),

(Ctx->isFileContext()) {

(!VisitedUsingDirectives) {

(UCtx->isTransparentContext())

UDirs.visit(UCtx, UCtx);

*InnermostFileScope = S;

(InnermostFileScope &&

InnermostFileScope = InnermostFileScope->

();

UDirs.visitScopeChain(Initial, InnermostFileScope);

VisitedUsingDirectives =

;

(!S)

;

(!VisitedUsingDirectives) {

UDirs.visitScopeChain(Initial, S);

FindLocals.restore();

(; S; S = S->getParent()) {

=

;

(; I != IEnd && S->isDeclScope(*I); ++I) {

(

&& S->isTemplateParamScope()) {

(; Ctx && !Ctx->Equals(OuterCtx); Ctx = Ctx->getLookupParent()) {

(Ctx->isTransparentContext())

(!(

&& S->isTemplateParamScope())) {

assert(Ctx->isFileContext() &&

);

!R.

();

(

*TD = dyn_cast<TemplateDecl>(ND))

(

*Param : *TD->getTemplateParameters())

(

*FD = dyn_cast<FunctionDecl>(Entity)) {

}

(

*RD = dyn_cast<CXXRecordDecl>(Entity)) {

}

(

*ED = dyn_cast<EnumDecl>(Entity)) {

(

*Pattern = ED->getTemplateInstantiationPattern())

}

(

*VD = dyn_cast<VarDecl>(Entity)) {

(Context->isFileContext())

Sema::isUsableModule(

*M) {

assert(M &&

);

(UsableModuleUnitsCache.count(M))

(M == TheGlobalModuleFragment || M == TheImplicitGlobalModuleFragment) {

UsableModuleUnitsCache.insert(M);

(Current->isImplicitGlobalModule())

Current = Current->getTopLevelModule();

(llvm::count_if(ModuleScopes,

[&M](

ModuleScope &MS) {

MS.Module == M; }) ||

UsableModuleUnitsCache.insert(M);

(isUsableModule(Merged))

<

ParmDecl>

(!

->hasDefaultArgument())

(

&&

.insert(

).second) {

&DefaultArg =

->getDefaultArgStorage();

(!DefaultArg.isInherited() && S.

(

, Kind))

(!DefaultArg.isInherited() && Modules) {

*NonConstD =

ParmDecl*

(

);

= DefaultArg.getInheritedFrom();

(

*

= dyn_cast<TemplateTypeParmDecl>(

))

return ::hasAcceptableDefaultArgument(*

,

, Modules, Kind);

(

*

= dyn_cast<NonTypeTemplateParmDecl>(

))

return ::hasAcceptableDefaultArgument(*

,

, Modules, Kind);

return ::hasAcceptableDefaultArgument(

*

, cast<TemplateTemplateParmDecl>(

), Modules, Kind);

<

Filter>

HasFilteredRedecls =

;

(

*Redecl :

->

()) {

*R = cast<NamedDecl>(Redecl);

HasFilteredRedecls =

;

Modules->push_back(R->getOwningModule());

(HasFilteredRedecls)

(

*RD = dyn_cast<CXXRecordDecl>(

))

RD->getTemplateSpecializationKind() ==

(

*FD = dyn_cast<FunctionDecl>(

))

FD->getTemplateSpecializationKind() ==

(

*VD = dyn_cast<VarDecl>(

))

VD->getTemplateSpecializationKind() ==

llvm_unreachable(

);

return ::hasAcceptableExplicitSpecialization(*

,

, Modules,

return ::hasAcceptableExplicitSpecialization(*

,

, Modules,

);

LookupResult::isAcceptableSlow(

&SemaRef,

*

,

);

assert(DeclModule &&

);

IsEffectivelyFileContext = [](

*DC) {

isa<ExportDecl>(DC);

(DC && !IsEffectivelyFileContext(DC)) {

AcceptableWithinParent;

SearchDefinitions =

;

(

*DCD = dyn_cast<Decl>(DC)) {

(

*TD = DCD->getDescribedTemplate()) {

SearchDefinitions = Index >= TPL->

() || TPL->

(Index) !=

;

(SearchDefinitions)

AcceptableWithinParent =

AcceptableWithinParent =

}

(isa<ParmVarDecl>(

) ||

(isa<FunctionDecl>(DC) && !SemaRef.

().CPlusPlus))

AcceptableWithinParent =

(SemaRef, cast<NamedDecl>(DC), Kind);

AcceptableWithinParent =

;

AcceptableWithinParent =

;

}

(!IsEffectivelyFileContext(DC));

AcceptableWithinParent =

!SemaRef.

().ModulesLocalVisibility) {

AcceptableWithinParent;

);

isReachableSlow(SemaRef,

);

(ModulePrivate && isUsableModule(M))

(!ModulePrivate && VisibleModules.

(M))

(LookupModules.empty())

(LookupModules.count(M))

llvm::any_of(LookupModules, [&](

*LookupM) {

LookupResult::isReachableSlow(

&SemaRef,

*

) {

assert(!

(SemaRef,

) &&

);

assert(DeclModule &&

);

(

*

: R) {

assert(

->isExternallyDeclarable() &&

);

(

*RD :

->

()) {

ND = cast<NamedDecl>(RD);

(ND->isInIdentifierNamespace(IDNS) &&

assert(!

(

) &&

);

*

,

, Modules, [](

*) {

; },

*

,

, Modules, [](

*) {

; },

(

*ND = dyn_cast<NamespaceDecl>(

)) {

(

*Acceptable =

().VisibleNamespaceCache.lookup(Key))

(

*FD = dyn_cast<FunctionDecl>(ND);

FD && FD->isReservedGlobalPlacementOperator())

(

*TD = dyn_cast<TagDecl>(DC))

ForceNoCPlusPlus) {

(!Name)

;

(S->getEntity() && S->getEntity()->isTransparentContext()))

FindLocalExternScope FindLocals(R);

LeftStartingScope =

;

(!LeftStartingScope && !S->isDeclScope(*I))

LeftStartingScope =

;

(LeftStartingScope && !((*I)->hasLinkage())) {

!isa<ImplicitParamDecl>(*I))

(S && !S->isDeclScope(

))

(++LastI; LastI != IEnd; ++LastI) {

(!S->isDeclScope(*LastI))

(!LastDC->

(DC))

(CppLookupName(R, S))

assert(StartDC->

() &&

);

*ND = I->getNominatedNamespace()->getFirstDecl();

Queue.push_back(ND);

FoundTag =

;

FoundNonTag =

;

=

;

(!Queue.empty()) {

UseLocal = !R.

();

FoundNonTag =

;

Queue.push_back(Nom);

(FoundTag && FoundNonTag)

InUnqualifiedLookup) {

assert(LookupCtx &&

);

assert((!isa<TagDecl>(LookupCtx) ||

cast<TagDecl>(LookupCtx)->isCompleteDefinition() ||

cast<TagDecl>(LookupCtx)->isBeingDefined()) &&

);

QualifiedLookupInScope {

~QualifiedLookupInScope() {

Context->setUseQualifiedLookup(oldVal);

*LookupRec = dyn_cast<CXXRecordDecl>(LookupCtx);

Name.getCXXNameType()->isDependentType()) {

((*

.Decls)->isInIdentifierNamespace(IDNS))

Paths.setOrigin(LookupRec);

SubobjectNumber = 0;

((*I)->isInIdentifierNamespace(IDNS) && (*I)->isCXXInstanceMember())

=

*;

Next = [&](Iterator &It, Iterator End) ->

{

(TemplateNameLookup)

.getCanonicalType().getAsOpaquePtr();

Iterator AIt = A, BIt = B, AEnd, BEnd;

AResult = Next(AIt, AEnd);

BResult = Next(BIt, BEnd);

(!AResult && !BResult)

(!AResult || !BResult)

(AResult != BResult) {

llvm::SmallDenseMap<Result, bool, 32> AResults;

(; AResult; AResult = Next(AIt, AEnd))

AResults.insert({AResult,

});

(; BResult; BResult = Next(BIt, BEnd)) {

It = AResults.find(BResult);

(It == AResults.end())

AResults.size() ==

;

SubobjectAccess = std::min(SubobjectAccess,

->Access);

(SubobjectType.isNull()) {

(SubobjectType !=

(HasOnlyStaticMembers(

->Decls) &&

HasSameDeclarations(Paths.begin()->Decls,

->Decls))

R.setAmbiguousBaseSubobjectTypes(Paths);

(HasOnlyStaticMembers(

->Decls))

R.setAmbiguousBaseSubobjects(Paths);

(

*ND = R.getAcceptableDecl(*I))

ObjectType,

AllowBuiltinCreation,

EnteringContext) {

IsDependent =

;

(!ObjectType.

()) {

assert((!SS || SS->

()) &&

);

);

(R, S, AllowBuiltinCreation);

(IsDependent)

(

&BaseSpec :

->bases()) {

(

I =

.begin(),

=

.end(); I !=

; ++I) {

.suppressDiagnostics();

!R.

();

assert(

.isAmbiguous() &&

);

(

.getAmbiguityKind()) {

SubobjectType = Paths->front().back().Base->getType();

(NameLoc, diag::err_ambiguous_member_multiple_subobjects)

(isa<CXXMethodDecl>(*

) &&

cast<CXXMethodDecl>(*Found)->isStatic())

((*Found)->getLocation(), diag::note_ambiguous_member_found);

(NameLoc, diag::err_ambiguous_member_multiple_subobject_types)

<< Name << LookupRange;

std::set<const NamedDecl *> DeclsPrinted;

PathEnd = Paths->end();

(DeclsPrinted.insert(

).second) {

(

*TD = dyn_cast<TypedefNameDecl>(

->getUnderlyingDecl()))

<< TD->getUnderlyingType();

(

*TD = dyn_cast<TypeDecl>(

->getUnderlyingDecl()))

(NameLoc, diag::err_ambiguous_tag_hiding) << Name << LookupRange;

(

*TD = dyn_cast<TagDecl>(

)) {

TagDecls.insert(TD);

(TD->getLocation(), diag::note_hidden_tag);

(!isa<TagDecl>(

))

(TagDecls.count(F.

()))

(NameLoc, diag::err_using_placeholder_variable) << Name << LookupRange;

(NameLoc, diag::err_ambiguous_reference) << Name << LookupRange;

AssociatedLookup {

: S(S), Namespaces(Namespaces), Classes(Classes),

InstantiationLoc(InstantiationLoc) {

ClassesTransitive.insert(RD);

(!Ctx->isFileContext() || Ctx->isInlineNamespace())

Ctx = Ctx->getParent();

*PrimaryCtx = Ctx->getPrimaryContext();

*PrimaryD = cast<Decl>(PrimaryCtx);

*

= cast<Decl>(Ctx);

Namespaces.insert(Ctx);

Namespaces.insert(PrimaryCtx);

*Ctx = ClassTemplate->getDeclContext();

(

*EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx))

.Classes.insert(EnclosingClass);

(

->getDeclName() ==

.S.VAListTagName)

(

*EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx))

.Classes.insert(EnclosingClass);

= dyn_cast<ClassTemplateSpecializationDecl>(

)) {

*Ctx = Spec->getSpecializedTemplate()->getDeclContext();

(

*EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx))

.Classes.insert(EnclosingClass);

(

I = 0, N = TemplateArgs.

(); I != N; ++I)

(!

.S.isCompleteType(

.InstantiationLoc,

Bases.push_back(

);

(!Bases.empty()) {

= Bases.pop_back_val();

(

&

:

->bases()) {

(

.addClassTransitive(BaseDecl)) {

Bases.push_back(BaseDecl);

Type::ConstantArray:

Type::IncompleteArray:

Type::VariableArray:

= cast<ArrayType>(

)->getElementType().getTypePtr();

Type::Record: {

cast<CXXRecordDecl>(cast<RecordType>(

)->getDecl());

(

*EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx))

.Classes.insert(EnclosingClass);

Type::FunctionProto: {

Queue.push_back(Arg.getTypePtr());

Type::FunctionNoProto: {

Type::MemberPointer: {

Queue.push_back(MemberPtr->

());

Type::BlockPointer:

Type::LValueReference:

Type::RValueReference:

Type::ExtVector:

Type::ConstantMatrix:

Type::DeducedTemplateSpecialization:

Type::ObjCObject:

Type::ObjCInterface:

Type::ObjCObjectPointer:

.Namespaces.insert(

.S.Context.getTranslationUnitDecl());

= cast<AtomicType>(

)->getValueType().getTypePtr();

= cast<PipeType>(

)->getElementType().getTypePtr();

Type::ArrayParameter:

Type::HLSLAttributedResource:

= cast<HLSLAttributedResourceType>(

)->getWrappedType().getTypePtr();

= Queue.pop_back_val();

AssociatedNamespaces.clear();

AssociatedClasses.clear();

AssociatedLookup

(*

, InstantiationLoc,

AssociatedNamespaces, AssociatedClasses);

(

ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {

*Arg = Args[ArgIdx];

assert(!Operators.

() &&

);

ConstArg,

VolatileArg,

RValueThis,

ConstThis,

VolatileThis) {

);

(RValueThis || ConstThis || VolatileThis)

);

(ConstArg || VolatileArg)

);

llvm::FoldingSetNodeID ID;

ID.AddInteger(llvm::to_underlying(

));

ID.AddInteger(ConstArg);

ID.AddInteger(VolatileArg);

ID.AddInteger(RValueThis);

ID.AddInteger(ConstThis);

ID.AddInteger(VolatileThis);

DeclareImplicitDestructor(RD);

*Arg =

;

DeclareImplicitDefaultConstructor(RD);

DeclareImplicitCopyConstructor(RD);

DeclareImplicitMoveConstructor(RD);

DeclareImplicitCopyAssignment(RD);

DeclareImplicitMoveAssignment(RD);

);

->setMethod(

);

(

*CandDecl : Candidates) {

(CandDecl->isInvalidDecl())

CtorInfo.FoundDecl,

,

assert(isa<UsingDecl>(Cand.

()) &&

);

->setMethod(cast<CXXMethodDecl>(Best->Function));

->setMethod(cast<CXXMethodDecl>(Best->Function));

->setMethod(

);

->setMethod(

);

,

,

,

,

);

cast_or_null<CXXConstructorDecl>(

.getMethod());

);

cast_or_null<CXXConstructorDecl>(

.getMethod());

cast_or_null<CXXConstructorDecl>(

.getMethod());

if (Class->needsImplicitDefaultConstructor())

DeclareImplicitDefaultConstructor(Class);

if (Class->needsImplicitCopyConstructor())

DeclareImplicitCopyConstructor(Class);

if (getLangOpts().CPlusPlus11 && Class->needsImplicitMoveConstructor())

DeclareImplicitMoveConstructor(Class);

->lookup(Name);

Quals,

RValueThis,

ThisQuals) {

);

);

.getMethod();

ThisQuals) {

);

.getMethod();

cast_or_null<CXXDestructorDecl>(

,

,

)

AllowTemplate,

AllowStringTemplatePack,

);

AllowCooked =

;

FoundRaw =

;

FoundTemplate =

;

FoundStringTemplatePack =

;

FoundCooked =

;

= USD->getTargetDecl();

IsRaw =

;

IsTemplate =

;

IsStringTemplatePack =

;

IsCooked =

;

(FD->getNumParams() == 1 &&

FD->getParamDecl(0)->getType()->getAs<

>())

(FD->getNumParams() == ArgTys.size()) {

(

ArgIdx = 0; ArgIdx != ArgTys.size(); ++ArgIdx) {

ParamTy = FD->getParamDecl(ArgIdx)->getType();

(Params->

() == 1) {

IsTemplate =

;

IsStringTemplatePack =

;

(AllowTemplate && StringLit && IsTemplate) {

FoundTemplate =

;

AllowCooked =

;

AllowStringTemplatePack =

;

(FoundRaw || FoundCooked || FoundStringTemplatePack) {

FoundRaw = FoundCooked = FoundStringTemplatePack =

;

}

(AllowCooked && IsCooked) {

FoundCooked =

;

AllowTemplate = StringLit;

AllowStringTemplatePack =

;

(FoundRaw || FoundTemplate || FoundStringTemplatePack) {

FoundRaw = FoundTemplate = FoundStringTemplatePack =

;

}

(AllowRaw && IsRaw) {

}

(AllowTemplate && IsTemplate) {

FoundTemplate =

;

}

(AllowStringTemplatePack && IsStringTemplatePack) {

FoundStringTemplatePack =

;

(StringLit && FoundTemplate)

(FoundRaw && FoundTemplate) {

(FoundStringTemplatePack)

(DiagnoseMissing) {

(R.

(), diag::err_ovl_no_viable_literal_operator)

<< (ArgTys.size() == 2 ? ArgTys[1] :

()) << AllowRaw

<< (AllowTemplate || AllowStringTemplatePack);

(Old ==

|| Old == New) {

Cursor = Cursor->getPreviousDecl();

(!Cursor)

;

(Cursor == OldFD)

;

AssociatedNamespaces,

(

*

: AssociatedNamespaces) {

(

*

: R) {

*Underlying =

;

(

*USD = dyn_cast<UsingShadowDecl>(

))

Underlying = USD->getTargetDecl();

(!isa<FunctionDecl>(Underlying) &&

!isa<FunctionTemplateDecl>(Underlying))

llvm::any_of(AssociatedClasses, [&](

*

) {

if (E->getOwningModule() != FM)

DeclContext *Ctx = E->getDeclContext();

while (!Ctx->isFileContext() || Ctx->isInlineNamespace())

Ctx = Ctx->getParent();

(AssociatedClasses.count(RD) &&

(

)) {

.insert(Underlying);

ShadowContextRAII;

VisibleDeclsRecord {

llvm::TinyPtrVector<NamedDecl*> ShadowMapEntry;

llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;

std::list<ShadowMap> ShadowMaps;

ShadowContextRAII;

!VisitedContexts.insert(Ctx).second;

VisitedContexts.count(Ctx);

ShadowMaps.back()[ND->

()].push_back(ND);

ShadowContextRAII {

VisibleDeclsRecord &Visible;

VisibleDeclsRecord::ShadowMap ShadowMap;

ShadowContextRAII(VisibleDeclsRecord &Visible) : Visible(Visible) {

Visible.ShadowMaps.emplace_back();

~ShadowContextRAII() {

Visible.ShadowMaps.pop_back();

std::list<ShadowMap>::reverse_iterator

= ShadowMaps.rbegin();

(std::list<ShadowMap>::reverse_iterator SMEnd = ShadowMaps.rend();

!= SMEnd; ++

) {

(Pos ==

->end())

(

*

: Pos->second) {

== ShadowMaps.rbegin())

(isa<UsingShadowDecl>(ND) && isa<UsingDecl>(

) &&

cast<UsingShadowDecl>(ND)->getIntroducer() ==

)

LookupVisibleHelper {

: Consumer(Consumer), IncludeDependentBases(IncludeDependentBases),

LoadExternal(LoadExternal) {}

IncludeGlobalScope) {

UnqualUsingDirectiveSet UDirs(SemaRef);

UDirs.visitScopeChain(Initial, S);

Result.setAllowHidden(Consumer.includeHiddenDecls());

(!IncludeGlobalScope)

ShadowContextRAII Shadow(

);

lookupInScope(Initial, Result, UDirs);

Result.setAllowHidden(Consumer.includeHiddenDecls());

(!IncludeGlobalScope)

ShadowContextRAII Shadow(

);

lookupInDeclContext(Ctx, Result,

,

QualifiedNameLookup,

InBaseClass) {

(

.visitedContext(Ctx->getPrimaryContext()))

Consumer.EnteredContext(Ctx);

(isa<TranslationUnitDecl>(Ctx) &&

&S = Result.getSema();

Idents.getExternalIdentifierLookup()) {

std::unique_ptr<IdentifierIterator>

(

->getIdentifiers());

(StringRef Name =

->Next(); !Name.empty();

Name =

->Next())

(

&Ident : Idents) {

(

*ND = Result.getAcceptableDecl(*I)) {

Consumer.FoundDecl(ND,

.checkHidden(ND), Ctx, InBaseClass);

Result.getSema().ForceDeclarationOfImplicitMembers(Class);

= LoadExternal ||

!(isa<TranslationUnitDecl>(Ctx) || isa<NamespaceDecl>(Ctx));

Load ? Ctx->lookups()

: Ctx->noload_lookups(

))

DeclsToVisit.push_back(

);

(

*

: DeclsToVisit)

(

*ND = Result.getAcceptableDecl(

)) {

Consumer.FoundDecl(ND,

.checkHidden(ND), Ctx, InBaseClass);

DeclsToVisit.clear();

(QualifiedNameLookup) {

ShadowContextRAII Shadow(

);

(

*I : Ctx->using_directives()) {

(!Result.getSema().isVisible(I))

lookupInDeclContext(I->getNominatedNamespace(), Result,

QualifiedNameLookup, InBaseClass);

(!

->hasDefinition())

(

&B :

->bases()) {

(!IncludeDependentBases) {

RD = TD->getTemplatedDecl();

ShadowContextRAII Shadow(

);

lookupInDeclContext(RD, Result, QualifiedNameLookup,

(

*Cat : IFace->visible_categories()) {

ShadowContextRAII Shadow(

);

lookupInDeclContext(Cat, Result, QualifiedNameLookup,

(

*I : IFace->all_referenced_protocols()) {

ShadowContextRAII Shadow(

);

lookupInDeclContext(I, Result, QualifiedNameLookup,

(IFace->getSuperClass()) {

ShadowContextRAII Shadow(

);

lookupInDeclContext(IFace->getSuperClass(), Result, QualifiedNameLookup,

(IFace->getImplementation()) {

ShadowContextRAII Shadow(

);

lookupInDeclContext(IFace->getImplementation(), Result,

QualifiedNameLookup, InBaseClass);

}

(

*Protocol = dyn_cast<ObjCProtocolDecl>(Ctx)) {

(

*I :

->protocols()) {

ShadowContextRAII Shadow(

);

lookupInDeclContext(I, Result, QualifiedNameLookup,

(

*I :

->protocols()) {

ShadowContextRAII Shadow(

);

lookupInDeclContext(I, Result, QualifiedNameLookup,

(

->getImplementation()) {

ShadowContextRAII Shadow(

);

lookupInDeclContext(

->getImplementation(), Result,

QualifiedNameLookup,

);

UnqualUsingDirectiveSet &UDirs) {

assert(!IncludeDependentBases &&

);

(!S->getEntity() ||

(!S->getParent() && !

.alreadyVisitedContext(S->getEntity())) ||

(S->getEntity())->isFunctionOrMethod()) {

FindLocalExternScope FindLocals(Result);

(

*

: ScopeDecls) {

(

*ND = dyn_cast<NamedDecl>(

))

((ND = Result.getAcceptableDecl(ND))) {

Consumer.FoundDecl(ND,

.checkHidden(ND),

,

);

(

*Ctx = Entity; Ctx && !Ctx->Equals(OuterCtx);

Ctx = Ctx->getLookupParent()) {

(Method->isInstanceMethod()) {

IvarResult(Result.getSema(), Result.getLookupName(),

Result.getNameLoc(),

lookupInDeclContext(IFace, IvarResult,

(Ctx->isFunctionOrMethod())

lookupInDeclContext(Ctx, Result,

,

}

(!S->getParent()) {

lookupInDeclContext(Entity, Result,

,

(

UnqualUsingEntry &UUE : UDirs.getNamespacesFor(Entity))

lookupInDeclContext(

*

(UUE.getNominatedNamespace()), Result,

ShadowContextRAII Shadow(

);

lookupInScope(S->getParent(), Result, UDirs);

IncludeDependentBases;

IncludeGlobalScope,

LoadExternal) {

LookupVisibleHelper H(

,

,

H.lookupVisibleDecls(*

, S, Kind, IncludeGlobalScope);

IncludeGlobalScope,

IncludeDependentBases,

LoadExternal) {

LookupVisibleHelper H(

, IncludeDependentBases, LoadExternal);

H.lookupVisibleDecls(*

, Ctx, Kind, IncludeGlobalScope);

(GnuLabelLoc.

()) {

*S = CurScope;

cast<LabelDecl>(Res);

RedeclarationKind::NotForRedeclaration);

assert(S &&

);

cast<LabelDecl>(Res);

EnteringContext,

isObjCIvarLookup,

(

; DI != DE; ++DI)

AnyVisibleDecls = !NewDecls.empty();

(

; DI != DE; ++DI) {

(!AnyVisibleDecls) {

AnyVisibleDecls =

;

NewDecls.push_back(*DI);

}

(!AnyVisibleDecls && !(*DI)->isModulePrivate())

NewDecls.push_back(*DI);

(NewDecls.empty())

Identifiers.clear();

Identifiers.push_back(II);

addName(Name,

);

addName(Keyword,

,

,

);

TypoCorrectionConsumer::addName(StringRef Name,

*ND,

StringRef TypoStr = Typo->

();

MinED =

((

)Name.size() - (

)TypoStr.size());

(MinED && TypoStr.size() / MinED < 3)

UpperBound = (TypoStr.size() + 2) / 3;

ED = TypoStr.edit_distance(Name,

, UpperBound);

(ED > UpperBound)

;

(isKeyword) TC.makeKeyword();

TC.setCorrectionRange(

, Result.getLookupNameInfo());

StringRef TypoStr = Typo->

();

(TypoStr.size() < 3 &&

(Name != TypoStr || Correction.

(

) > TypoStr.size()))

(!CList.empty() && !CList.back().isResolved())

RI = llvm::find_if(CList, [NewND](

&TypoCorr) {

(RI != CList.end()) {

IsDeprecated = [](

*

) {

std::pair<bool, std::string> NewKey = {

std::pair<bool, std::string> PrevKey = {

IsDeprecated(RI->getFoundDecl()),

(NewKey < PrevKey)

(CList.empty() || Correction.

())

CList.push_back(Correction);

CorrectionResults.erase(std::prev(CorrectionResults.end()));

llvm::MapVector<NamespaceDecl *, bool> &KnownNamespaces) {

SearchNamespaces =

;

(

KNPair : KnownNamespaces)

Namespaces.addNameSpecifier(KNPair.first);

SSIsTemplate =

;

(SS && SS->isValid()) ? SS->getScopeRep() :

) {

SSIsTemplate =

->

() == Type::TemplateSpecialization;

(

I = 0; I != Types.size(); ++I) {

*TI = Types[I];

CD = CD->getCanonicalDecl();

(!CD->isDependentType() && !CD->isAnonymousStructOrUnion() &&

!CD->isUnion() && CD->getIdentifier() &&

(SSIsTemplate || !isa<ClassTemplateSpecializationDecl>(CD)) &&

(CD->isBeingDefined() || CD->isCompleteDefinition()))

Namespaces.addNameSpecifier(CD);

(++CurrentTCIndex < ValidatedCorrections.size())

ValidatedCorrections[CurrentTCIndex];

CurrentTCIndex = ValidatedCorrections.size();

(!CorrectionResults.empty()) {

DI = CorrectionResults.begin();

(DI->second.empty()) {

CorrectionResults.erase(DI);

RI = DI->second.begin();

(RI->second.empty()) {

DI->second.erase(RI);

performQualifiedLookups();

ValidatedCorrections.push_back(TC);

ValidatedCorrections[CurrentTCIndex];

ValidatedCorrections[0];

TypoCorrectionConsumer::resolveCorrection(

&Candidate) {

CorrectionValidator->IsObjCIvarLookup,

(Result.getResultKind()) {

(TempMemberContext) {

TempMemberContext =

;

(SearchNamespaces)

QualifiedResults.push_back(Candidate);

(

*TRD : Result)

(SearchNamespaces)

QualifiedResults.push_back(Candidate);

TypoCorrectionConsumer::performQualifiedLookups() {

TypoLen = Typo->

().size();

(

&NSI : Namespaces) {

*NSType = NSI.NameSpecifier->getAsType();

(NSDecl->getIdentifier() == QR.getCorrectionAsIdentifierInfo())

TC.ClearCorrectionDecls();

TC.setCorrectionSpecifier(NSI.NameSpecifier);

TC.setQualifierDistance(NSI.EditDistance);

TC.setCallbackDistance(0);

TmpED = TC.getEditDistance(

);

(QR.getCorrectionAsIdentifierInfo() != Typo && TmpED &&

TypoLen / TmpED < 3)

Result.setLookupName(QR.getCorrectionAsIdentifierInfo());

(Result.getResultKind()) {

(SS && SS->isValid()) {

std::string NewQualified = TC.getAsString(SemaRef.

());

std::string OldQualified;

llvm::raw_string_ostream OldOStream(OldQualified);

OldOStream << Typo->

();

(OldOStream.str() == NewQualified)

TRD != TRDEnd; ++TRD) {

TC.addCorrectionDecl(*TRD);

(TC.isResolved()) {

TC.setCorrectionRange(SS.get(), Result.getLookupNameInfo());

QualifiedResults.clear();

TypoCorrectionConsumer::NamespaceSpecifierSet::NamespaceSpecifierSet(

: Context(Context), CurContextChain(buildContextChain(CurContext)) {

CurScopeSpec ? CurScopeSpec->

() :

) {

llvm::raw_string_ostream SpecifierOStream(CurNameSpecifier);

(

*

: llvm::reverse(CurContextChain)) {

(

*ND = dyn_cast_or_null<NamespaceDecl>(

))

DistanceMap[1].push_back(SI);

TypoCorrectionConsumer::NamespaceSpecifierSet::buildContextChain(

assert(Start &&

);

DeclContextList Chain;

TypoCorrectionConsumer::NamespaceSpecifierSet::buildNestedNameSpecifier(

NumSpecifiers = 0;

(

*ND = dyn_cast_or_null<NamespaceDecl>(

)) {

}

(

*RD = dyn_cast_or_null<RecordDecl>(

)) {

NumSpecifiers;

TypoCorrectionConsumer::NamespaceSpecifierSet::addNameSpecifier(

NumSpecifiers = 0;

DeclContextList NamespaceDeclChain(buildContextChain(Ctx));

DeclContextList FullNamespaceDeclChain(NamespaceDeclChain);

(

*

: llvm::reverse(CurContextChain)) {

(NamespaceDeclChain.empty() || NamespaceDeclChain.back() !=

)

NamespaceDeclChain.pop_back();

NumSpecifiers = buildNestedNameSpecifier(NamespaceDeclChain, NNS);

(NamespaceDeclChain.empty()) {

buildNestedNameSpecifier(FullNamespaceDeclChain, NNS);

dyn_cast_or_null<NamedDecl>(NamespaceDeclChain.back())) {

SameNameSpecifier =

;

(llvm::is_contained(CurNameSpecifierIdentifiers, Name)) {

std::string NewNameSpecifier;

llvm::raw_string_ostream SpecifierOStream(NewNameSpecifier);

SameNameSpecifier = NewNameSpecifier == CurNameSpecifier;

(SameNameSpecifier || llvm::is_contained(CurContextIdentifiers, Name)) {

buildNestedNameSpecifier(FullNamespaceDeclChain, NNS);

(NNS && !CurNameSpecifierIdentifiers.empty()) {

llvm::ComputeEditDistance(

(CurNameSpecifierIdentifiers),

SpecifierInfo SI = {Ctx, NNS, NumSpecifiers};

DistanceMap[NumSpecifiers].push_back(SI);

EnteringContext,

isObjCIvarLookup,

(MemberContext) {

(isObjCIvarLookup) {

, EnteringContext);

(Method->isInstanceMethod() && Method->getClassInterface() &&

= Method->getClassInterface()->lookupInstanceVariable(Name)) {

AfterNestedNameSpecifier) {

(AfterNestedNameSpecifier) {

*

CTypeSpecs[] = {

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

(

*CTS : CTypeSpecs)

*

CastableTypeSpecs[] = {

,

,

,

,

,

,

,

,

(

*kw : CastableTypeSpecs)

*

CXXExprs[] = {

,

,

,

,

(

*CE : CXXExprs)

(isa<CXXMethodDecl>(SemaRef.

) &&

cast<CXXMethodDecl>(SemaRef.

)->isInstance())

*

CStmts[] = {

,

,

,

,

,

,

,

};

(

*CS : CStmts)

(S && S->getBreakParent())

(S && S->getContinueParent())

(S && S->isClassScope()) {

std::unique_ptr<TypoCorrectionConsumer> Sema::makeTypoCorrectionConsumer(

locs->second.count(TypoName.

()))

std::unique_ptr<CorrectionCandidateCallback> ClonedCCC = CCC.

();

= std::make_unique<TypoCorrectionConsumer>(

*

, TypoName, LookupKind, S, SS, std::move(ClonedCCC), MemberContext,

IsUnqualifiedLookup =

;

(MemberContext) {

(

*I : OPT->

())

}

(SS && SS->

()) {

IsUnqualifiedLookup =

;

SearchNamespaces

(IsUnqualifiedLookup || (SS && SS->

()));

(IsUnqualifiedLookup || SearchNamespaces) {

std::unique_ptr<IdentifierIterator>

(

->getIdentifiers());

StringRef Name =

->Next();

*

->getCorrectionValidator(),

(SearchNamespaces) {

LoadedExternalKnownNamespaces =

;

(

*N : ExternalKnownNamespaces)

KnownNamespaces[N] =

;

->addNamespaces(KnownNamespaces);

EnteringContext,

RecordFailure) {

MemberContext, EnteringContext, OPT))

= makeTypoCorrectionConsumer(TypoName, LookupKind, S, SS, CCC,

MemberContext, EnteringContext,

FailedCorrection(Typo, TypoName.

(), RecordFailure);

ED =

->getBestEditDistance(

);

TypoLen = Typo->getName().size();

(ED > 0 && TypoLen / ED < 3)

FailedCorrection(Typo, TypoName.

(), RecordFailure);

FailedCorrection(Typo, TypoName.

(), RecordFailure);

(TypoLen >= 3 && ED > 0 && TypoLen / ED < 3) {

FailedCorrection(Typo, TypoName.

(), RecordFailure);

(!SecondBestTC ||

(ED == 0 &&

.isKeyword())

FailedCorrection(Typo, TypoName.

(), RecordFailure);

}

(SecondBestTC && ObjCMessageReceiver) {

BestTC = SecondBestTC;

((*

)[

].front().isKeyword())

BestTC = (*Consumer)[

].front();

FailedCorrection(Typo, TypoName.

(), RecordFailure);

FailedCorrection(Typo, TypoName.

(), RecordFailure && !SecondBestTC);

= makeTypoCorrectionConsumer(TypoName, LookupKind, S, SS, CCC,

MemberContext, EnteringContext,

TypoName, LookupKind, S, SS, *

->getCorrectionValidator(),

MemberContext, EnteringContext, OPT);

->addCorrection(ExternalTypo);

ED =

->getBestEditDistance(

);

(!ExternalTypo && ED > 0 && Typo->getName().size() / ED < 3)

createDelayedTypo(std::move(

), std::move(TDG), std::move(TRC),

(!CDecl)

;

CorrectionDecls.clear();

CorrectionDecls.push_back(CDecl);

(!CorrectionName)

(CorrectionNameSpec) {

std::string tmpBuffer;

llvm::raw_string_ostream PrefixOStream(tmpBuffer);

PrefixOStream << CorrectionName;

PrefixOStream.str();

HasNonType =

;

HasStaticMethod =

;

HasNonStaticMethod =

;

(

*

: candidate) {

= FTD->getTemplatedDecl();

(Method->isStatic())

HasStaticMethod =

;

HasNonStaticMethod =

;

(!isa<TypeDecl>(

))

HasExplicitTemplateArgs,

: NumArgs(NumArgs), HasExplicitTemplateArgs(HasExplicitTemplateArgs),

CurContext(SemaRef.CurContext), MemberFn(ME) {

!HasExplicitTemplateArgs && NumArgs == 1;

(

*

: candidate) {

FD = FTD->getTemplatedDecl();

(!HasExplicitTemplateArgs && !FD) {

(!(FD = dyn_cast<FunctionDecl>(ND)) && isa<ValueDecl>(ND)) {

ValType = cast<ValueDecl>(ND)->getType();

(FPT->getNumParams() == NumArgs)

: isa<TypeDecl>(ND)) &&

NumArgs <= 1 || HasExplicitTemplateArgs || isa<CXXRecordDecl>(ND);

(

*MD = dyn_cast<CXXMethodDecl>(FD)) {

(MemberFn || !MD->isStatic()) {

? dyn_cast_if_present<CXXMethodDecl>(MemberFn->

())

: dyn_cast_if_present<CXXMethodDecl>(CurContext);

CurMD ? CurMD->

()->getCanonicalDecl() :

;

ErrorRecovery) {

(

*VD = dyn_cast<VarDecl>(

))

VD->getDefinition();

(

*FD = dyn_cast<FunctionDecl>(

))

FD->getDefinition();

(

*TD = dyn_cast<TagDecl>(

))

TD->getDefinition();

(

*ID = dyn_cast<ObjCInterfaceDecl>(

))

ID->getDefinition();

(

*PD = dyn_cast<ObjCProtocolDecl>(

))

PD->getDefinition();

(

*TD = dyn_cast<TemplateDecl>(

))

(

*TTD = TD->getTemplatedDecl())

assert(Owner &&

);

OwningModules.push_back(Owner);

OwningModules.insert(OwningModules.end(), Merged.begin(), Merged.end());

llvm::StringRef IncludingFile) {

IsAngled =

;

, IncludingFile, &IsAngled);

(IsAngled ?

:

) +

+ (IsAngled ?

:

);

assert(!Modules.empty());

(isa<NamespaceDecl>(

))

NotePrevious = [&] {

(DeclLoc, diag::note_unreachable_entity) << (

)MIK;

llvm::SmallDenseSet<Module*, 8> UniqueModuleSet;

(

*M : Modules) {

(UniqueModuleSet.insert(M).second)

UniqueModules.push_back(M);

std::string HeaderName;

(!HeaderName.empty() || UniqueModules.empty()) {

(UseLoc, diag::err_module_unimported_use_header)

<< (

)MIK <<

<< !HeaderName.empty() << HeaderName;

Modules = UniqueModules;

GetModuleNameForDiagnostic = [

](

*M) -> std::string {

(Modules.size() > 1) {

std::string ModuleList;

(

*M : Modules) {

ModuleList +=

;

(++N == 5 && N != Modules.size()) {

ModuleList +=

;

ModuleList += GetModuleNameForDiagnostic(M);

(UseLoc, diag::err_module_unimported_use_multiple)

<< (

)MIK <<

<< ModuleList;

(UseLoc, diag::err_module_unimported_use)

<< (

)MIK <<

<< GetModuleNameForDiagnostic(Modules[0]);

ErrorRecovery) {

assert(

&&

);

<< CorrectedQuotedStr << (ErrorRecovery ? FixTypo :

());

(

*FD = dyn_cast_if_present<FunctionDecl>(ChosenDecl);

FD && FD->getBuiltinID() &&

PrevNote.

() == diag::note_previous_decl &&

ChosenDecl =

;

(PrevNote.

() && ChosenDecl)

(ChosenDecl->getLocation(), PrevNote)

<< CorrectedQuotedStr << (ErrorRecovery ?

() : FixTypo);

*Sema::createDelayedTypo(std::unique_ptr<TypoCorrectionConsumer> TCC,

TypoDiagnosticGenerator TDG,

TypoRecoveryCallback TRC,

assert(TCC &&

);

&State = DelayedTypos[TE];

State.Consumer = std::move(TCC);

State.DiagHandler = std::move(TDG);

State.RecoveryHandler = std::move(TRC);

Entry = DelayedTypos.find(TE);

assert(Entry != DelayedTypos.end() &&

);

Entry->second;

DelayedTypos.erase(TE);

RedeclarationKind::NotForRedeclaration);

(cast<Decl>(

)->getOwningModuleForLinkage())

RedeclarationKind::ForVisibleRedeclaration;

RedeclarationKind::ForExternalRedeclaration;

Defines the clang::ASTContext interface.

Defines enum values for all the target-independent builtin functions.

enum clang::sema::@1704::IndirectLocalPathEntry::EntryKind Kind

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

Defines the C++ template declaration subclasses.

Defines the clang::Expr interface and subclasses for C++ expressions.

llvm::DenseSet< const void * > Visited

Defines the clang::LangOptions interface.

llvm::MachO::Record Record

Defines the clang::Preprocessor interface.

RedeclarationKind

Specifies whether (or how) name lookup is being performed for a redeclaration (vs.

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 #incl...

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 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 void getNestedNameSpecifierIdentifiers(NestedNameSpecifier *NNS, SmallVectorImpl< const IdentifierInfo * > &Identifiers)

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.

const NestedNameSpecifier * Specifier

__DEVICE__ long long abs(long long __n)

A class for storing results from argument-dependent lookup.

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 ...

TranslationUnitDecl * getTranslationUnitDecl() const

const SmallVectorImpl< Type * > & getTypes() const

QualType getTagDeclType(const TagDecl *Decl) const

Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.

DeclarationNameTable DeclarationNames

QualType getRecordType(const RecordDecl *Decl) const

CanQualType getCanonicalType(QualType T) const

Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...

CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const

Retrieves the default calling convention for the current target.

QualType getEnumType(const EnumDecl *Decl) const

QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const

Return the unique reference to the type for the specified type declaration.

Builtin::Context & BuiltinInfo

const LangOptions & getLangOpts() const

void setObjCSuperType(QualType ST)

const clang::PrintingPolicy & getPrintingPolicy() const

ArrayRef< Module * > getModulesWithMergedDefinition(const NamedDecl *Def)

Get the additional modules in which the definition Def has been merged.

bool hasSameUnqualifiedType(QualType T1, QualType T2) const

Determine whether the given types are equivalent after cvr-qualifiers have been removed.

QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const

Return a normal function type with a typed argument list.

void mergeDefinitionIntoModule(NamedDecl *ND, Module *M, bool NotifyListeners=true)

Note that the definition ND has been merged into module M, and should be visible whenever M is visibl...

QualType getTypedefType(const TypedefNameDecl *Decl, QualType Underlying=QualType()) const

Return the unique reference to the type for the specified typedef-name decl.

bool isInSameModule(const Module *M1, const Module *M2)

If the two module M1 and M2 are in the same module.

bool isPredefinedLibFunction(unsigned ID) const

Determines whether this builtin is a predefined libc/libm function, such as "malloc",...

Represents a path from a specific derived class (which is not represented as part of the path) to a p...

BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...

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.

QualType getType() const

Retrieves the type of the base class.

Represents a C++ constructor within a class.

Represents a C++ destructor within a class.

Represents a static or instance method of a struct/union/class.

Represents a C++ struct/union/class.

base_class_iterator bases_end()

bool hasAnyDependentBases() const

Determine whether this class has any dependent base classes which are not the current instantiation.

bool needsImplicitDefaultConstructor() const

Determine if we need to declare a default constructor for this class.

bool needsImplicitMoveConstructor() const

Determine whether this class should get an implicit move constructor or if any existing special membe...

CXXRecordDecl * getDefinition() const

static AccessSpecifier MergeAccess(AccessSpecifier PathAccess, AccessSpecifier DeclAccess)

Calculates the access of a decl that is reached along a path.

const CXXRecordDecl * getTemplateInstantiationPattern() const

Retrieve the record declaration from which this record could be instantiated.

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...

base_class_iterator bases_begin()

bool needsImplicitCopyConstructor() const

Determine whether this class needs an implicit copy constructor to be lazily declared.

bool needsImplicitDestructor() const

Determine whether this class needs an implicit destructor to be lazily declared.

CXXDestructorDecl * getDestructor() const

Returns the destructor decl for this class.

bool needsImplicitMoveAssignment() const

Determine whether this class should get an implicit move assignment operator or if any existing speci...

bool needsImplicitCopyAssignment() const

Determine whether this class needs an implicit copy assignment operator to be lazily declared.

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.

bool isNotEmpty() const

A scope specifier is present, but may be valid or invalid.

SourceRange getRange() const

bool isSet() const

Deprecated.

NestedNameSpecifier * getScopeRep() const

Retrieve the representation of the nested-name-specifier.

bool isInvalid() const

An error occurred during parsing of the scope specifier.

bool isEmpty() const

No scope specifier.

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...

bool WantExpressionKeywords

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...

bool WantFunctionLikeCasts

bool WantRemainingKeywords

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

The results of name lookup within a DeclContext.

DeclListNode::iterator iterator

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

DeclContext * getParent()

getParent - Returns the containing DeclContext.

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.

bool isFileContext() const

bool isTransparentContext() const

isTransparentContext - Determines whether this context is a "transparent" context,...

ASTContext & getParentASTContext() const

bool isDependentContext() const

Determines whether this context is dependent on a template parameter.

DeclContext * getLexicalParent()

getLexicalParent - Returns the containing lexical DeclContext.

lookup_result lookup(DeclarationName Name) const

lookup - Find the declarations (if any) with the given Name in this context.

bool isTranslationUnit() const

DeclContext * getRedeclContext()

getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...

bool shouldUseQualifiedLookup() const

void setUseQualifiedLookup(bool use=true) const

DeclContext * getPrimaryContext()

getPrimaryContext - There may be many different declarations of the same entity (including forward de...

bool isInlineNamespace() const

bool isFunctionOrMethod() const

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 encloses the declaration context DC.

Decl - This represents one declaration (or definition), e.g.

Decl * getPreviousDecl()

Retrieve the previous declaration that declares the same entity as this declaration,...

Decl * getMostRecentDecl()

Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...

bool isModulePrivate() const

Whether this declaration was marked as being private to the module in which it was defined.

bool isTemplateDecl() const

returns true if this declaration is a template

FriendObjectKind getFriendObjectKind() const

Determines whether this declaration is the object of a friend declaration and, if so,...

bool isFunctionOrFunctionTemplate() const

Whether this declaration is a function or function template.

ASTContext & getASTContext() const LLVM_READONLY

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...

bool isInIdentifierNamespace(unsigned NS) const

bool isInvisibleOutsideTheOwningModule() const

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).

FunctionDecl * getAsFunction() LLVM_READONLY

Returns the function itself, or the templated function if this is a function template.

bool isTemplateParameter() const

isTemplateParameter - Determines whether this declaration is a template parameter.

bool isInvalidDecl() const

unsigned getIdentifierNamespace() const

SourceLocation getLocation() const

@ IDNS_NonMemberOperator

This declaration is a C++ operator declared in a non-class context.

@ IDNS_TagFriend

This declaration is a friend class.

@ IDNS_Ordinary

Ordinary names.

@ IDNS_Type

Types, declared with 'struct foo', typedefs, etc.

@ IDNS_OMPReduction

This declaration is an OpenMP user defined reduction construction.

@ IDNS_Label

Labels, declared with 'x:' and referenced with 'goto x'.

@ IDNS_Member

Members, declared with object declarations within tag definitions.

@ IDNS_OMPMapper

This declaration is an OpenMP user defined mapper.

@ IDNS_ObjCProtocol

Objective C @protocol.

@ IDNS_Namespace

Namespaces, declared with 'namespace foo {}'.

@ IDNS_OrdinaryFriend

This declaration is a friend function.

@ IDNS_Using

This declaration is a using declaration.

@ IDNS_LocalExtern

This declaration is a function-local extern declaration of a variable or function.

@ IDNS_Tag

Tags, declared with 'struct foo;' and referenced with 'struct foo'.

bool isDeprecated(std::string *Message=nullptr) const

Determine whether this declaration is marked 'deprecated'.

bool isTemplateParameterPack() const

isTemplateParameter - Determines whether this declaration is a template parameter pack.

void setImplicit(bool I=true)

redecl_range redecls() const

Returns an iterator range for all the redeclarations of the same decl.

bool isDefinedOutsideFunctionOrMethod() const

isDefinedOutsideFunctionOrMethod - This predicate returns true if this scoped decl is defined outside...

DeclContext * getDeclContext()

TranslationUnitDecl * getTranslationUnitDecl()

bool hasTagIdentifierNamespace() const

DeclContext * getLexicalDeclContext()

getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).

virtual Decl * getCanonicalDecl()

Retrieves the "canonical" declaration of the given declaration.

const LangOptions & getLangOpts() const LLVM_READONLY

Helper to get the language options from the ASTContext.

void setVisibleDespiteOwningModule()

Set that this declaration is globally visible, even if it came from a module that is not visible.

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...

@ CXXConversionFunctionName

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.

DiagnosticOptions & getDiagnosticOptions() const

Retrieve the diagnostic options.

bool hasFatalErrorOccurred() const

The return type of classify().

This represents one expression.

Classification Classify(ASTContext &Ctx) const

Classify - Classify this expression according to the C++11 expression taxonomy.

bool isFPConstrained() const

A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...

Cached information about one file (either on disk or in the virtual file system).

Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...

static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)

Create a code modification hint that replaces the given source range with the given code string.

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.

unsigned getMinRequiredArguments() const

Returns the minimum number of arguments needed to call this function.

FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const

Retrieve the function declaration from which this function could be instantiated, if it is an instant...

bool isDeleted() const

Whether this function has been deleted.

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, Expr *TrailingRequiresClause=nullptr)

unsigned getNumParams() const

Return the number of parameters this function must have based on its FunctionType.

Represents a prototype with parameter type info, e.g.

ExtProtoInfo getExtProtoInfo() const

ArrayRef< QualType > param_types() const

Declaration of a template function.

FunctionDecl * getTemplatedDecl() const

Get the underlying function declaration of the template.

ExtInfo withCallingConv(CallingConv cc) const

FunctionType - C99 6.7.5.3 - Function Declarators.

QualType getReturnType() const

Provides lookups to, and iteration over, IdentiferInfo objects.

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.

iterator begin(DeclarationName Name)

Returns an iterator over decls with the name 'Name'.

iterator end()

Returns the end iterator.

bool isDeclInScope(Decl *D, DeclContext *Ctx, Scope *S=nullptr, bool AllowInlineNamespace=false) const

isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true if 'D' is in Scope 'S',...

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.

static LabelDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II)

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.

void restart()

Restart the iteration.

void erase()

Erase the last element returned from this iterator.

Represents the results of name lookup.

void addAllDecls(const LookupResult &Other)

Add all the declarations from another set of lookup results.

@ FoundOverloaded

Name lookup found a set of overloaded functions that met the criteria.

@ FoundUnresolvedValue

Name lookup found an unresolvable value declaration and cannot yet complete.

@ Ambiguous

Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...

@ NotFound

No entity found met the criteria.

@ NotFoundInCurrentInstantiation

No entity found met the criteria within the current instantiation,, but there were dependent base cla...

@ Found

Name lookup found a single declaration that met the criteria.

void setShadowed()

Note that we found and ignored a declaration while performing lookup.

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.

void setFindLocalExtern(bool FindLocalExtern)

void setAllowHidden(bool AH)

Specify whether hidden declarations are visible, e.g., for recovery reasons.

DeclClass * getAsSingle() const

void setContextRange(SourceRange SR)

Sets a 'context' source range.

static bool isAcceptable(Sema &SemaRef, NamedDecl *D, Sema::AcceptableKind Kind)

void setAmbiguousQualifiedTagHiding()

Make these results show that the name was found in different contexts and a tag decl was hidden by an...

void addDecl(NamedDecl *D)

Add a declaration to these results with its natural access.

bool isTemplateNameLookup() const

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.

void setLookupName(DeclarationName Name)

Sets the name to look up.

bool empty() const

Return true if no decls were found.

void resolveKind()

Resolves the result kind of the lookup, possibly hiding decls.

SourceLocation getNameLoc() const

Gets the location of the identifier.

void setAmbiguousBaseSubobjectTypes(CXXBasePaths &P)

Make these results show that the name was found in base classes of different types.

Filter makeFilter()

Create a filter for this result set.

NamedDecl * getFoundDecl() const

Fetch the unique decl found by this lookup.

void setHideTags(bool Hide)

Sets whether tag declarations should be hidden by non-tag declarations during resolution.

NamedDecl * getAcceptableDecl(NamedDecl *D) const

Retrieve the accepted (re)declaration of the given declaration, if there is one.

bool isSingleResult() const

Determines if this names a single result which is not an unresolved value using decl.

unsigned getIdentifierNamespace() const

Returns the identifier namespace mask for this lookup.

Sema::LookupNameKind getLookupKind() const

Gets the kind of lookup to perform.

Sema & getSema() const

Get the Sema object that this lookup result is searching with.

void setNamingClass(CXXRecordDecl *Record)

Sets the 'naming class' for this lookup.

LookupResultKind getResultKind() const

void print(raw_ostream &)

static bool isReachable(Sema &SemaRef, NamedDecl *D)

void suppressDiagnostics()

Suppress the diagnostics that would normally fire because of this lookup.

bool isForRedeclaration() const

True if this lookup is just looking for an existing declaration.

DeclarationName getLookupName() const

Gets the name to look up.

@ AmbiguousTagHiding

Name lookup results in an ambiguity because an entity with a tag name was hidden by an entity with an...

@ AmbiguousBaseSubobjectTypes

Name lookup results in an ambiguity because multiple entities that meet the lookup criteria were foun...

@ AmbiguousReferenceToPlaceholderVariable

Name lookup results in an ambiguity because multiple placeholder variables were found in the same sco...

@ AmbiguousReference

Name lookup results in an ambiguity because multiple definitions of entity that meet the lookup crite...

@ AmbiguousBaseSubobjects

Name lookup results in an ambiguity because multiple nonstatic entities that meet the lookup criteria...

void setNotFoundInCurrentInstantiation()

Note that while no result was found in the current instantiation, there were dependent base classes t...

static bool isVisible(Sema &SemaRef, NamedDecl *D)

Determine whether the given declaration is visible to the program.

const DeclarationNameInfo & getLookupNameInfo() const

Gets the name info to look up.

MemberExpr - [C99 6.5.2.3] Structure and Union Members.

ValueDecl * getMemberDecl() const

Retrieve the member declaration to which this expression refers.

A pointer to member type per C++ 8.3.3 - Pointers to members.

QualType getPointeeType() const

const Type * getClass() const

virtual bool lookupMissingImports(StringRef Name, SourceLocation TriggerLoc)=0

Check global module index for missing imports.

Describes a module or submodule.

StringRef getTopLevelModuleName() const

Retrieve the name of the top-level module.

bool isPrivateModule() const

bool isModuleVisible(const Module *M) const

Determine whether the specified module would be visible to a lookup at the end of this module.

bool isModuleInterfaceUnit() const

bool isModuleMapModule() const

bool isHeaderLikeModule() const

Is this module have similar semantics as headers.

StringRef getPrimaryModuleInterfaceName() const

Get the primary module interface name from a partition.

bool isExplicitGlobalModule() const

bool isGlobalModule() const

Does this Module scope describe a fragment of the global module within some C++ module.

bool isImplicitGlobalModule() const

std::string getFullModuleName(bool AllowStringLiterals=false) const

Retrieve the full name of this module, including the path from its top-level module.

bool isNamedModule() const

Does this Module is a named module of a standard named module?

Module * getTopLevelModule()

Retrieve the top-level module for this (sub)module, which may be this module.

This represents a decl that may have a name.

NamedDecl * getUnderlyingDecl()

Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.

IdentifierInfo * getIdentifier() const

Get the identifier that names this declaration, if there is one.

DeclarationName getDeclName() const

Get the actual, stored name of the declaration, which may be a special name.

bool isExternallyDeclarable() const

Determine whether this declaration can be redeclared in a different translation unit.

Represent a C++ namespace.

bool isAnonymousNamespace() const

Returns true if this is an anonymous namespace declaration.

Represents a C++ nested name specifier, such as "\::std::vector<int>::".

SpecifierKind getKind() const

Determine what kind of nested name specifier is stored.

static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, const IdentifierInfo *II)

Builds a specifier combining a prefix and an identifier.

NamespaceAliasDecl * getAsNamespaceAlias() const

Retrieve the namespace alias stored in this nested name specifier.

IdentifierInfo * getAsIdentifier() const

Retrieve the identifier stored in this nested name specifier.

static NestedNameSpecifier * GlobalSpecifier(const ASTContext &Context)

Returns the nested name specifier representing the global scope.

NestedNameSpecifier * getPrefix() const

Return the prefix of this nested name specifier.

@ NamespaceAlias

A namespace alias, stored as a NamespaceAliasDecl*.

@ TypeSpec

A type, stored as a Type*.

@ TypeSpecWithTemplate

A type that was preceded by the 'template' keyword, stored as a Type*.

@ Super

Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.

@ Identifier

An identifier, stored as an IdentifierInfo*.

@ Global

The global specifier '::'. There is no stored value.

@ Namespace

A namespace, stored as a NamespaceDecl*.

NamespaceDecl * getAsNamespace() const

Retrieve the namespace stored in this nested name specifier.

void print(raw_ostream &OS, const PrintingPolicy &Policy, bool ResolveTemplateArguments=false) const

Print this nested name specifier to the given output stream.

const Type * getAsType() const

Retrieve the type stored in this nested name specifier.

ObjCCategoryDecl - Represents a category declaration.

Represents an ObjC class declaration.

ObjCIvarDecl - Represents an ObjC instance variable.

ObjCMethodDecl - Represents an instance or class method declaration.

Represents a pointer to an Objective C object.

Represents one property declaration in an Objective-C interface.

Represents an Objective-C protocol declaration.

OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.

OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....

@ CSK_Normal

Normal lookup.

SmallVectorImpl< OverloadCandidate >::iterator iterator

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.

static FindResult find(Expr *E)

Finds the overloaded expression in the given expression E of OverloadTy.

llvm::iterator_range< decls_iterator > decls() const

Represents a parameter to a function.

void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)

static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)

unsigned getDiagID() const

PointerType - C99 6.7.5.1 - Pointer Declarators.

Engages in a tight little dance with the lexer to efficiently preprocess tokens.

bool isMacroDefined(StringRef Id)

HeaderSearch & getHeaderSearchInfo() const

OptionalFileEntryRef getHeaderToIncludeForDiagnostics(SourceLocation IncLoc, SourceLocation MLoc)

We want to produce a diagnostic at location IncLoc concerning an unreachable effect at location MLoc ...

A (possibly-)qualified type.

const IdentifierInfo * getBaseTypeIdentifier() const

Retrieves a pointer to the name of the base type.

void addConst()

Add the const type qualifier to this QualType.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

const Type * getTypePtr() const

Retrieves a pointer to the underlying (unqualified) type.

void addVolatile()

Add the volatile type qualifier to this QualType.

Represents a struct/union/class.

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...

RecordDecl * getDecl() const

Scope - A scope is a transient data structure that is used while parsing the program.

const Scope * getFnParent() const

getFnParent - Return the closest scope that is a function body.

bool isDeclScope(const Decl *D) const

isDeclScope - Return true if this is the scope that the specified decl is declared in.

DeclContext * getEntity() const

Get the entity corresponding to this scope.

const Scope * getParent() const

getParent - Return the scope that this is nested in.

@ DeclScope

This is a scope that can contain a declaration.

SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)

Emit a diagnostic.

PartialDiagnostic PDiag(unsigned DiagID=0)

Build a partial diagnostic.

std::unique_ptr< sema::RISCVIntrinsicManager > IntrinsicManager

RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...

bool hasErrorOccurred() const

Determine whether any SFINAE errors have been trapped.

SpecialMemberOverloadResult - The overloading result for a special member function.

Sema - This implements semantic analysis and AST building for C.

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...

SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts

List of active code synthesis contexts.

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.

@ LookupLabel

Label name lookup.

@ LookupOrdinaryName

Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....

@ LookupUsingDeclName

Look up all declarations in a scope with the given name, including resolved using declarations.

@ LookupNestedNameSpecifierName

Look up of a name that precedes the '::' scope resolution operator in C++.

@ LookupOMPReductionName

Look up the name of an OpenMP user-defined reduction operation.

@ LookupLocalFriendName

Look up a friend of a local class.

@ LookupObjCProtocolName

Look up the name of an Objective-C protocol.

@ LookupRedeclarationWithLinkage

Look up an ordinary name that is going to be redeclared as a name with linkage.

@ LookupOperatorName

Look up of an operator name (e.g., operator+) for use with operator overloading.

@ LookupObjCImplicitSelfParam

Look up implicit 'self' parameter of an objective-c method.

@ LookupNamespaceName

Look up a namespace name within a C++ using directive or namespace alias definition,...

@ LookupMemberName

Member name lookup, which finds the names of class/struct/union members.

@ LookupDestructorName

Look up a name following ~ in a destructor name.

@ LookupTagName

Tag name lookup, which finds the names of enums, classes, structs, and unions.

@ LookupOMPMapperName

Look up the name of an OpenMP user-defined mapper.

@ LookupAnyName

Look up any declaration with any name.

bool hasReachableDeclarationSlow(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)

MissingImportKind

Kinds of missing import.

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.

Preprocessor & getPreprocessor() const

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.

IdentifierInfo * getSuperIdentifier() const

@ CTAK_Specified

The template argument was specified in the code or was instantiated with some deduced template argume...

bool DisableTypoCorrection

Tracks whether we are in a context where typo correction is disabled.

llvm::DenseMap< NamedDecl *, NamedDecl * > VisibleNamespaceCache

Map from the most recent declaration of a namespace to the most recent visible declaration of that na...

bool hasMergedDefinitionInCurrentModule(const NamedDecl *Def)

IdentifierSourceLocations TypoCorrectionFailures

A cache containing identifiers for which typo correction failed and their locations,...

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 HasMatchedPackOnParmToNonPackOnArg=false)

AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...

DiagnosticsEngine & getDiagnostics() const

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

CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)

Look for the destructor of the given class.

std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths)

Builds a string representing ambiguous paths from a specific derived class to different subobjects of...

unsigned TyposCorrected

The number of typos corrected by CorrectTypo.

PrintingPolicy getPrintingPolicy() const

Retrieve a suitable printing policy for diagnostics.

Module * getOwningModule(const Decl *Entity)

Get the module owning an entity.

ObjCMethodDecl * getCurMethodDecl()

getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...

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()

CXXConstructorDecl * LookupDefaultConstructor(CXXRecordDecl *Class)

Look up the default constructor for the given class.

const LangOptions & getLangOpts() const

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...

TypoExpr * CorrectTypoDelayed(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, TypoDiagnosticGenerator TDG, TypoRecoveryCallback TRC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr)

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...

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...

bool isReachable(const NamedDecl *D)

Determine whether a declaration is reachable.

CXXMethodDecl * DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl)

Declare the implicit move assignment operator for the given class.

NamedDecl * getCurFunctionOrMethodDecl() const

getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method or C function we're in,...

sema::FunctionScopeInfo * getCurFunction() const

bool isVisible(const NamedDecl *D)

Determine whether a declaration is visible to name lookup.

Module * getCurrentModule() const

Get the module unit whose scope we are currently within.

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.

void ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc, ArrayRef< Expr * > Args, ADLResult &Functions)

DeclContext * CurContext

CurContext - This is the current declaration context of parsing.

std::function< void(const TypoCorrection &)> TypoDiagnosticGenerator

CXXMethodDecl * LookupMovingAssignment(CXXRecordDecl *Class, unsigned Quals, bool RValueThis, unsigned ThisQuals)

Look up the moving assignment operator for the given class.

llvm::SmallVector< TypoExpr *, 2 > TypoExprs

Holds TypoExprs that are created from createDelayedTypo.

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).

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)

llvm::FoldingSet< SpecialMemberOverloadResultEntry > SpecialMemberCache

A cache of special member function overload resolution results for C++ records.

DeclContext * computeDeclContext(QualType T)

Compute the DeclContext that is associated with the given type.

LabelDecl * LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc, SourceLocation GnuLabelLoc=SourceLocation())

LookupOrCreateLabel - Do a name lookup of a label with the specified name.

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...

RedeclarationKind forRedeclarationInCurContext() const

CXXConstructorDecl * LookupCopyingConstructor(CXXRecordDecl *Class, unsigned Quals)

Look up the copying constructor for the given class.

ModuleLoader & getModuleLoader() const

Retrieve the module loader associated with the preprocessor.

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...

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.

SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts

A stack of expression evaluation contexts.

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

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...

std::function< ExprResult(Sema &, TypoExpr *, TypoCorrection)> TypoRecoveryCallback

DiagnosticsEngine & Diags

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.

AccessResult CheckMemberAccess(SourceLocation UseLoc, CXXRecordDecl *NamingClass, DeclAccessPair Found)

Checks access to a member.

SmallVector< Module *, 16 > CodeSynthesisContextLookupModules

Extra modules inspected when performing a lookup during a template instantiation.

llvm::BumpPtrAllocator BumpAlloc

TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, ArrayRef< TemplateArgument > TemplateArgs, sema::TemplateDeductionInfo &Info)

void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)

Run some code with "sufficient" stack space.

bool hasAcceptableDefinition(NamedDecl *D, NamedDecl **Suggested, AcceptableKind Kind, bool OnlyNeedComplete=false)

void clearDelayedTypo(TypoExpr *TE)

Clears the state of the given TypoExpr.

LiteralOperatorLookupResult

The possible outcomes of name lookup for a literal operator.

@ LOLR_ErrorNoDiagnostic

The lookup found no match but no diagnostic was issued.

@ LOLR_Raw

The lookup found a single 'raw' literal operator, which expects a string literal containing the spell...

@ LOLR_Error

The lookup resulted in an error.

@ LOLR_Cooked

The lookup found a single 'cooked' literal operator, which expects a normal literal to be built and p...

@ LOLR_StringTemplatePack

The lookup found an overload set of literal operator templates, which expect the character type and c...

@ LOLR_Template

The lookup found an overload set of literal operator templates, which expect the characters of the sp...

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

const TypoExprState & getTypoExprState(TypoExpr *TE) const

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.

FileID getFileID(SourceLocation SpellingLoc) const

Return the FileID for a SourceLocation.

const FileEntry * getFileEntryForID(FileID FID) const

Returns the FileEntry record for the provided FileID.

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.

Represents the declaration of a struct/union/class/enum.

bool isBeingDefined() const

Determines whether this type is in the process of being defined.

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.

Stores a list of template parameters for a TemplateDecl and its derived classes.

NamedDecl * getParam(unsigned Idx)

Represents a type template specialization; the template must be a class template, a type alias templa...

Represents a declaration of a type.

const Type * getTypeForDecl() const

The base class of the type hierarchy.

CXXRecordDecl * getAsCXXRecordDecl() const

Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...

const T * castAs() const

Member-template castAs<specific type>.

bool isReferenceType() const

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

bool isDependentType() const

Whether this type is a dependent type, meaning that its definition somehow depends on a template para...

DeducedType * getContainedDeducedType() const

Get the DeducedType whose type will be deduced for a variable with an initializer of this type.

QualType getCanonicalTypeInternal() const

bool isIncompleteType(NamedDecl **Def=nullptr) const

Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...

bool isAnyPointerType() const

TypeClass getTypeClass() const

const T * getAs() const

Member-template getAs<specific type>'.

Base class for declarations which introduce a typedef-name.

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)

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.

NestedNameSpecifier * getCorrectionSpecifier() const

Gets the NestedNameSpecifier needed to use the typo correction.

SmallVectorImpl< NamedDecl * >::iterator decl_iterator

void setRequiresImport(bool Req)

std::string getQuoted(const LangOptions &LO) const

NamedDecl * getFoundDecl() const

Get the correction declaration found by name lookup (before we looked through using shadow declaratio...

TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...

A set of unresolved declarations.

void append(iterator I, iterator E)

void truncate(unsigned N)

The iterator over UnresolvedSets.

Represents C++ using-directive.

NamespaceDecl * getNominatedNamespace()

Returns the namespace nominated by this using-directive.

Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...

Represents a variable declaration or definition.

VarDecl * getTemplateInstantiationPattern() const

Retrieve the variable declaration from which this variable could be instantiated, if it is an instant...

Consumes visible declarations found when searching for all visible names within a given scope or cont...

virtual bool includeHiddenDecls() const

Determine whether hidden declarations (from unimported modules) should be given to this consumer.

virtual ~VisibleDeclConsumer()

Destroys the visible declaration consumer.

bool isVisible(const Module *M) const

Determine whether a module is visible.

SmallVector< SwitchInfo, 8 > SwitchStack

SwitchStack - This is the current set of active switch statements in the block.

Provides information about an attempted template argument deduction, whose success or failure was des...

bool Load(InterpState &S, CodePtr OpPC)

The JSON file list parser is used to communicate input to InstallAPI.

OverloadedOperatorKind

Enumeration specifying the different kinds of C++ overloaded operators.

if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))

@ OR_Deleted

Succeeded, but refers to a deleted function.

@ OR_Success

Overload resolution succeeded.

@ OR_Ambiguous

Ambiguous candidates found.

@ OR_No_Viable_Function

No viable function found.

@ Specialization

We are substituting template parameters for template arguments in order to form a template specializa...

std::unique_ptr< sema::RISCVIntrinsicManager > CreateRISCVIntrinsicManager(Sema &S)

@ External

External linkage, which indicates that the entity can be referred to from other translation units.

TemplateDecl * getAsTypeTemplateDecl(Decl *D)

@ Result

The result type of a method or function.

std::pair< unsigned, unsigned > getDepthAndIndex(const NamedDecl *ND)

Retrieve the depth and index of a template parameter.

CXXSpecialMemberKind

Kinds of C++ special members.

ExprValueKind

The categorization of expression values, currently following the C++11 scheme.

@ VK_PRValue

A pr-value expression (in the C++11 taxonomy) produces a temporary value.

@ VK_LValue

An l-value expression is a reference to an object with independent storage.

const FunctionProtoType * T

@ Success

Template argument deduction was successful.

@ TSK_ExplicitSpecialization

This template specialization was declared or defined by an explicit specialization (C++ [temp....

ConstructorInfo getConstructorInfo(NamedDecl *ND)

@ Class

The "class" keyword introduces the elaborated-type-specifier.

@ Enum

The "enum" keyword introduces the elaborated-type-specifier.

@ EST_None

no exception specification

AccessSpecifier

A C++ access specifier (public, private, protected), plus the special value "none" which means differ...

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.

ExceptionSpecInfo ExceptionSpec

FunctionType::ExtInfo ExtInfo

OverloadExpr * Expression

Describes how types, statements, expressions, and declarations should be printed.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4