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

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

clang: lib/Sema/HeuristicResolver.cpp Source File

HeuristicResolverImpl {

HeuristicResolverImpl(ASTContext &Ctx) : Ctx(Ctx) {}

std::vector<const NamedDecl *>

resolveMemberExpr(

CXXDependentScopeMemberExpr *ME);

std::vector<const NamedDecl *>

resolveDeclRefExpr(

DependentScopeDeclRefExpr *RE);

std::vector<const NamedDecl *> resolveTypeOfCallExpr(

CallExpr *CE);

std::vector<const NamedDecl *> resolveCalleeOfCallExpr(

CallExpr *CE);

std::vector<const NamedDecl *>

resolveUsingValueDecl(

UnresolvedUsingValueDecl *UUVD);

std::vector<const NamedDecl *>

resolveDependentNameType(

DependentNameType *DNT);

std::vector<const NamedDecl *> resolveTemplateSpecializationType(

DependentTemplateSpecializationType *DTST);

QualType resolveNestedNameSpecifierToType(

NestedNameSpecifier *NNS);

llvm::SmallSet<const DependentNameType *, 4> SeenDependentNameTypes;

std::vector<const NamedDecl *>

resolveDependentMember(QualType

, DeclarationName Name,

llvm::function_ref<

(

NamedDecl *ND)> Filter);

QualType resolveExprToType(

Expr *

);

std::vector<const NamedDecl *> resolveExprToDecls(

Expr *

);

TagDecl *resolveTypeToTagDecl(

Type *

);

QualType simplifyType(QualType Type,

Expr *

,

UnwrapPointer);

std::vector<const NamedDecl *>

lookupDependentName(CXXRecordDecl *RD, DeclarationName Name,

llvm::function_ref<

(

NamedDecl *ND)> Filter);

DeclarationName Name);

NoFilter = [](

NamedDecl *

) {

; };

NonStaticFilter = [](

NamedDecl *

) {

->isCXXInstanceMember();

StaticFilter = [](

NamedDecl *

) {

!

->isCXXInstanceMember();

ValueFilter = [](

NamedDecl *

) {

isa<ValueDecl>(

); };

TypeFilter = [](

NamedDecl *

) {

isa<TypeDecl>(

); };

TemplateFilter = [](

NamedDecl *

) {

isa<TemplateDecl>(

);

QualType resolveDeclsToType(

std::vector<const NamedDecl *> &Decls,

(Decls.size() != 1)

(

*TD = dyn_cast<TypeDecl>(Decls[0])) {

(

*VD = dyn_cast<ValueDecl>(Decls[0])) {

VD->getType();

TemplateName getReferencedTemplateName(

Type *

) {

(

*TST =

->

<TemplateSpecializationType>()) {

TST->getTemplateName();

(

*DTST =

->

<DeducedTemplateSpecializationType>()) {

DTST->getTemplateName();

TemplateName();

TagDecl *HeuristicResolverImpl::resolveTypeToTagDecl(

Type *

) {

(

*DNT =

->

<DependentNameType>()) {

= resolveDeclsToType(resolveDependentNameType(DNT), Ctx)

(

*TT =

->

<TagType>()) {

TT->getDecl();

(

*ICNT =

->

<InjectedClassNameType>())

= ICNT->getInjectedSpecializationType().getTypePtrOrNull();

TemplateName TN = getReferencedTemplateName(

);

ClassTemplateDecl *TD =

dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl());

TD->getTemplatedDecl();

QualType HeuristicResolverImpl::getPointeeType(QualType

) {

ArrowOps = resolveDependentMember(

(ArrowOps.empty())

*TST =

->

<TemplateSpecializationType>();

(TST->template_arguments().size() == 0)

TemplateArgument &FirstArg = TST->template_arguments()[0];

FirstArg.getAsType();

QualType HeuristicResolverImpl::simplifyType(QualType Type,

Expr *

,

UnwrapPointer) {

DidUnwrapPointer =

;

SimplifyOneStep = [&](QualType

) {

DidUnwrapPointer =

;

(

*RT =

->

<ReferenceType>()) {

RT->getPointeeType();

(

*BT =

->

<BuiltinType>()) {

(

&& BT->getKind() == BuiltinType::Dependent) {

resolveExprToType(

);

(

&& AT->isUndeducedAutoType()) {

(

*DRE = dyn_cast<DeclRefExpr>(

)) {

(

*VD = dyn_cast<VarDecl>(DRE->getDecl())) {

resolveExprToType(VD->getInit());

(!

.isNull()) {

QualType New = SimplifyOneStep(Type);

(UnwrapPointer && !DidUnwrapPointer)

std::vector<const NamedDecl *> HeuristicResolverImpl::resolveMemberExpr(

CXXDependentScopeMemberExpr *ME) {

(NestedNameSpecifier *NNS = ME->getQualifier()) {

(QualType QualifierType = resolveNestedNameSpecifierToType(NNS);

!QualifierType.isNull()) {

resolveDependentMember(QualifierType, ME->getMember(), NoFilter);

Expr *

= ME->isImplicitAccess() ? nullptr : ME->getBase();

QualType BaseType = ME->getBaseType();

BaseType = simplifyType(BaseType,

, ME->isArrow());

resolveDependentMember(BaseType, ME->getMember(), NoFilter);

std::vector<const NamedDecl *>

HeuristicResolverImpl::resolveDeclRefExpr(

DependentScopeDeclRefExpr *RE) {

resolveDependentMember(

resolveNestedNameSpecifierToType(RE->getQualifier()), RE->getDeclName(),

std::vector<const NamedDecl *>

HeuristicResolverImpl::resolveTypeOfCallExpr(

CallExpr *CE) {

QualType CalleeType = resolveExprToType(CE->getCallee());

(CalleeType.isNull())

(

*FnTypePtr = CalleeType->getAs<PointerType>())

CalleeType = FnTypePtr->getPointeeType();

(

FunctionType *FnType = CalleeType->getAs<FunctionType>()) {

(

*

=

resolveTypeToTagDecl(FnType->getReturnType().getTypePtr())) {

std::vector<const NamedDecl *>

HeuristicResolverImpl::resolveCalleeOfCallExpr(

CallExpr *CE) {

(

*ND = dyn_cast_or_null<NamedDecl>(CE->getCalleeDecl())) {

resolveExprToDecls(CE->getCallee());

std::vector<const NamedDecl *> HeuristicResolverImpl::resolveUsingValueDecl(

UnresolvedUsingValueDecl *UUVD) {

resolveDependentMember(QualType(UUVD->getQualifier()->getAsType(), 0),

UUVD->getNameInfo().getName(), ValueFilter);

std::vector<const NamedDecl *>

HeuristicResolverImpl::resolveDependentNameType(

DependentNameType *DNT) {

(

[_, inserted] = SeenDependentNameTypes.insert(DNT); !inserted)

resolveDependentMember(

resolveNestedNameSpecifierToType(DNT->getQualifier()),

DNT->getIdentifier(), TypeFilter);

std::vector<const NamedDecl *>

HeuristicResolverImpl::resolveTemplateSpecializationType(

DependentTemplateSpecializationType *DTST) {

resolveDependentMember(

resolveNestedNameSpecifierToType(DTST->getQualifier()),

DTST->getIdentifier(), TemplateFilter);

std::vector<const NamedDecl *>

HeuristicResolverImpl::resolveExprToDecls(

Expr *

) {

(

*ME = dyn_cast<CXXDependentScopeMemberExpr>(

)) {

resolveMemberExpr(ME);

(

*RE = dyn_cast<DependentScopeDeclRefExpr>(

)) {

resolveDeclRefExpr(RE);

(

*OE = dyn_cast<OverloadExpr>(

)) {

{OE->decls_begin(), OE->decls_end()};

(

*CE = dyn_cast<CallExpr>(

)) {

resolveTypeOfCallExpr(CE);

(

*ME = dyn_cast<MemberExpr>(

))

{ME->getMemberDecl()};

QualType HeuristicResolverImpl::resolveExprToType(

Expr *

) {

std::vector<const NamedDecl *> Decls = resolveExprToDecls(

);

resolveDeclsToType(Decls, Ctx);

QualType HeuristicResolverImpl::resolveNestedNameSpecifierToType(

NestedNameSpecifier *NNS) {

(NNS->getKind()) {

QualType(NNS->getAsType(), 0);

resolveDeclsToType(

resolveDependentMember(

resolveNestedNameSpecifierToType(NNS->getPrefix()),

NNS->getAsIdentifier(), TypeFilter),

DeclarationName Name) {

.Decls = RD->lookup(Name).begin();

HeuristicResolverImpl::findOrdinaryMemberInDependentClasses(

DeclarationName Name) {

TagDecl *TD = resolveTypeToTagDecl(

->getType().getTypePtr());

(

*RD = dyn_cast_if_present<CXXRecordDecl>(TD)) {

std::vector<const NamedDecl *> HeuristicResolverImpl::lookupDependentName(

CXXRecordDecl *RD, DeclarationName Name,

llvm::function_ref<

(

NamedDecl *ND)> Filter) {

std::vector<const NamedDecl *> Results;

AnyOrdinaryMembers =

;

(

NamedDecl *ND : RD->lookup(Name)) {

AnyOrdinaryMembers =

;

Results.push_back(ND);

(AnyOrdinaryMembers)

(!RD->lookupInBases(

[&](

CXXBaseSpecifier *

, CXXBasePath &

) {

return findOrdinaryMemberInDependentClasses(Specifier, Path, Name);

Results.push_back(*I);

std::vector<const NamedDecl *> HeuristicResolverImpl::resolveDependentMember(

QualType QT, DeclarationName Name,

llvm::function_ref<

(

NamedDecl *ND)> Filter) {

*

= QT.getTypePtrOrNull();

TagDecl *TD = resolveTypeToTagDecl(

);

(

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

= ED->lookup(Name);

(

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

(!RD->hasDefinition())

RD = RD->getDefinition();

lookupDependentName(RD, Name, [&](

NamedDecl *ND) {

(

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

!MD->isInstance() ||

MD->getMethodQualifiers().compatiblyIncludes(QT.getQualifiers(),

HeuristicResolverImpl(Ctx).resolveMemberExpr(ME);

HeuristicResolverImpl(Ctx).resolveDeclRefExpr(RE);

std::vector<const NamedDecl *>

HeuristicResolverImpl(Ctx).resolveTypeOfCallExpr(CE);

std::vector<const NamedDecl *>

HeuristicResolverImpl(Ctx).resolveCalleeOfCallExpr(CE);

HeuristicResolverImpl(Ctx).resolveUsingValueDecl(UUVD);

HeuristicResolverImpl(Ctx).resolveDependentNameType(DNT);

std::vector<const NamedDecl *>

HeuristicResolverImpl(Ctx).resolveTemplateSpecializationType(DTST);

HeuristicResolverImpl(Ctx).resolveNestedNameSpecifierToType(NNS);

HeuristicResolverImpl(Ctx).getPointeeType(

);

Defines the clang::ASTContext interface.

static bool findOrdinaryMemberInDependentClasses(const CXXBaseSpecifier *Specifier, CXXBasePath &Path, DeclarationName Name)

static bool isOrdinaryMember(const NamedDecl *ND)

static bool findOrdinaryMember(const CXXRecordDecl *RD, CXXBasePath &Path, DeclarationName Name)

Defines the C++ template declaration subclasses.

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

static QualType getPointeeType(const MemRegion *R)

C Language Family Type Representation.

const NestedNameSpecifier * Specifier

DeclarationNameTable DeclarationNames

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

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

Represents a C++ member access expression where the actual member referenced could not be resolved be...

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

lookup_result::iterator lookup_iterator

@ IDNS_Ordinary

Ordinary names.

@ IDNS_Member

Members, declared with object declarations within tag definitions.

@ IDNS_Tag

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

Represents a qualified type name for which the type name is dependent.

A qualified reference to a name whose declaration cannot yet be resolved.

Represents a template specialization type whose template cannot be resolved, e.g.

std::vector< const NamedDecl * > resolveDeclRefExpr(const DependentScopeDeclRefExpr *RE) const

const QualType getPointeeType(QualType T) const

std::vector< const NamedDecl * > resolveMemberExpr(const CXXDependentScopeMemberExpr *ME) const

QualType resolveNestedNameSpecifierToType(const NestedNameSpecifier *NNS) const

std::vector< const NamedDecl * > resolveCalleeOfCallExpr(const CallExpr *CE) const

std::vector< const NamedDecl * > resolveTypeOfCallExpr(const CallExpr *CE) const

std::vector< const NamedDecl * > resolveUsingValueDecl(const UnresolvedUsingValueDecl *UUVD) const

std::vector< const NamedDecl * > resolveTemplateSpecializationType(const DependentTemplateSpecializationType *DTST) const

std::vector< const NamedDecl * > resolveDependentNameType(const DependentNameType *DNT) const

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

@ TypeSpec

A type, stored as a Type*.

@ TypeSpecWithTemplate

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

@ Identifier

An identifier, stored as an IdentifierInfo*.

A (possibly-)qualified type.

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.

@ Type

The template argument is a type.

bool isPointerType() const

const T * castAs() const

Member-template castAs<specific type>.

AutoType * getContainedAutoType() const

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

QualType getCanonicalTypeInternal() const

const T * getAs() const

Member-template getAs<specific type>'.

Represents a dependent using declaration which was not marked with typename.

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

@ Result

The result type of a method or function.

const FunctionProtoType * T

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