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

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

clang: lib/Tooling/Syntax/BuildTree.cpp Source File

;

(

*

= dyn_cast<CXXConstructExpr>(

)) {

NumArgs =

->getNumArgs();

(NumArgs == 1 || (NumArgs > 1 && isa<CXXDefaultArgExpr>(

->getArg(1)))) {

*A =

->getArg(0);

(

->getParenOrBraceRange().isInvalid())

(

*F = dyn_cast<CXXFunctionalCastExpr>(

)) {

(F->getCastKind() == CK_ConstructorConversion)

F->getSubExpr();

GetStartLoc :

<GetStartLoc, SourceLocation> {

L =

(

.getInnerLoc());

.getLParenLoc();

HandlePointer(

);

HandlePointer(

);

HandlePointer(

);

HandlePointer(

);

HandlePointer(

);

N =

.getNextTypeLoc();

L =

(

.getPointeeLoc());

.getLocalSourceRange().getBegin();

FirstDefaultArg =

llvm::find_if(Args, [](

It) {

isa<CXXDefaultArgExpr>(It); });

llvm::make_range(Args.begin(), FirstDefaultArg);

(

.getOperator()) {

OO_ExclaimEqual:

OO_GreaterEqual:

OO_PercentEqual:

OO_LessLessEqual:

OO_GreaterGreaterEqual:

OO_GreaterGreater:

syntax::NodeKind::BinaryOperatorExpression;

syntax::NodeKind::PrefixUnaryOperatorExpression;

(

.getNumArgs()) {

syntax::NodeKind::PrefixUnaryOperatorExpression;

syntax::NodeKind::PostfixUnaryOperatorExpression;

llvm_unreachable(

);

(

.getNumArgs()) {

syntax::NodeKind::PrefixUnaryOperatorExpression;

syntax::NodeKind::BinaryOperatorExpression;

llvm_unreachable(

);

syntax::NodeKind::BinaryOperatorExpression;

OO_Array_Delete:

syntax::NodeKind::UnknownExpression;

syntax::NodeKind::CallExpression;

llvm_unreachable(

);

llvm_unreachable(

);

assert((isa<DeclaratorDecl, TypedefNameDecl>(

)) &&

);

DN =

->getDeclName();

IsAnonymous = DN.isIdentifier() && !DN.getAsIdentifierInfo();

(

*DD = dyn_cast<DeclaratorDecl>(

)) {

(DD->getQualifierLoc()) {

DD->getQualifierLoc().getBeginLoc();

(

*

= dyn_cast<VarDecl>(

)) {

*I =

->getInit();

(I && !

->isCXXForRangeDecl())

I->getSourceRange();

(Name.isValid()) {

(End.isInvalid() ||

.isBeforeInTranslationUnit(End, Name))

assert(

.isBeforeInTranslationUnit(End, InitializerEnd) ||

End == InitializerEnd);

End = InitializerEnd;

ASTPtr = llvm::PointerUnion<Stmt *, Decl *>;

ASTToSyntaxMapping {

assert(To !=

);

assert(!From.isNull());

Added =

.insert({From, To}).second;

assert(Added &&

);

assert(To !=

);

Added = NNSNodes.insert({From, To}).second;

assert(Added &&

);

NNSNodes.lookup(

);

llvm::DenseMap<ASTPtr, syntax::Tree *>

;

llvm::DenseMap<NestedNameSpecifierLoc, syntax::Tree *> NNSNodes;

Pending(

, TBTM.tokenBuffer()) {

LocationToToken.insert({

.location(), &

});

Mapping.add(From, New);

Mapping.add(From, New);

ListRange = Pending.shrinkToFitList(SuperRange);

Pending.foldChildren(TBTM.

(), ListRange, New);

Mapping.add(From, New);

assert(!Tokens.empty());

assert(Tokens.back().kind() == tok::eof);

Pending.foldChildren(TBTM.

(), Tokens.drop_back(),

*TU = cast<syntax::TranslationUnit>(std::move(Pending).

());

TU->assertInvariantsRecursive();

assert(

.isValid());

assert(

.isValid());

maybeAppendSemicolon(Tokens,

);

assert((isa<DeclaratorDecl, TypedefNameDecl>(

)) &&

);

(Next ==

) {

(

->

() != Next->getKind()) {

(

*S = dyn_cast<TagDecl>(

))

Tokens =

(S->TypeDecl::getBeginLoc(), S->getEndLoc());

maybeAppendSemicolon(Tokens,

);

Tokens =

(S->getSourceRange());

(isa<CompoundStmt>(S))

(Tokens.back().kind() == tok::semi)

withTrailingSemicolon(Tokens);

*

)

{

(isa<NamespaceDecl>(

))

(DeclsWithoutSemicolons.count(

))

withTrailingSemicolon(Tokens);

assert(!Tokens.empty());

assert(Tokens.back().kind() != tok::eof);

(Tokens.back().kind() != tok::semi && Tokens.end()->kind() == tok::semi)

Trees.insert(Trees.end(), {&

, L});

assert(!

.empty());

It = Trees.lower_bound(

.begin());

assert(It != Trees.end() &&

);

assert(It->first ==

.begin() &&

);

assert((std::next(It) == Trees.end() ||

std::next(It)->first ==

.end()) &&

);

);

It->second->setRole(Role);

BeginChildren = Trees.lower_bound(

.begin());

assert((BeginChildren == Trees.end() ||

BeginChildren->first ==

.begin()) &&

);

EndChildren = Trees.lower_bound(

.end());

(EndChildren == Trees.end() || EndChildren->first ==

.end()) &&

);

BelongsToList = [](

(Trees)::value_type KV) {

Role = KV.second->getRole();

BeginListChildren =

std::find_if(BeginChildren, EndChildren, BelongsToList);

EndListChildren =

std::find_if_not(BeginListChildren, EndChildren, BelongsToList);

EndListChildren->first);

assert(

->getFirstChild() ==

&&

);

*FirstToken = Tokens.begin();

BeginChildren = Trees.lower_bound(FirstToken);

assert((BeginChildren == Trees.end() ||

BeginChildren->first == FirstToken) &&

);

EndChildren = Trees.lower_bound(Tokens.end());

(EndChildren == Trees.end() || EndChildren->first == Tokens.end()) &&

);

(

It = BeginChildren; It != EndChildren; ++It) {

*

= It->second;

->appendChildLowLevel(

);

->Original =

;

Trees.erase(BeginChildren, EndChildren);

Trees.insert({FirstToken,

});

assert(Trees.size() == 1);

*Root = Trees.begin()->second;

(

It = Trees.begin(); It != Trees.end(); ++It) {

CoveredTokens =

? (std::next(It)->first - It->first)

formatv(

, It->second->getKind(),

R += It->second->dump(STM);

std::map<const syntax::Token *, syntax::Node *> Trees;

std::string str() {

Pending.str(TBTM); }

TokenBufferTokenManager& TBTM;

llvm::DenseMap<SourceLocation, const syntax::Token *> LocationToToken;

llvm::DenseSet<Decl *> DeclsWithoutSemicolons;

ASTToSyntaxMapping Mapping;

: Builder(Builder), Context(Context) {}

processDeclaratorAndDeclaration(DD);

processDeclaratorAndDeclaration(TD);

Builder.foldNode(Builder.getDeclarationRange(

),

(!RecursiveASTVisitor::TraverseClassTemplateSpecializationDecl(

))

(

->isExplicitSpecialization())

cast<syntax::SimpleDeclaration>(handleFreeStandingTagDecl(

));

foldExplicitTemplateInstantiation(

Builder.getTemplateRange(

),

Builder.findToken(

->getExternKeywordLoc()),

Builder.findToken(

->getTemplateKeywordLoc()),

,

);

foldTemplateDeclaration(

Builder.getDeclarationRange(S),

Builder.findToken(S->getTemplateParameters()->getTemplateLoc()),

Builder.getDeclarationRange(S->getTemplatedDecl()), S);

WalkUpFromTagDecl(

*

) {

(!

->isFreeStanding()) {

assert(

->getNumTemplateParameterLists() == 0);

handleFreeStandingTagDecl(

);

assert(

->isFreeStanding());

DeclarationRange = Builder.getDeclarationRange(

);

Builder.foldNode(DeclarationRange, Result,

);

*TemplateKW = Builder.findToken(L.getTemplateLoc());

foldTemplateDeclaration(R, TemplateKW, DeclarationRange,

);

DeclarationRange = R;

(

*S = dyn_cast<ClassTemplatePartialSpecializationDecl>(

))

ConsumeTemplateParameters(*S->getTemplateParameters());

(

I =

->getNumTemplateParameterLists(); 0 < I; --I)

ConsumeTemplateParameters(*

->getTemplateParameterList(I - 1));

Builder.markChildToken(S->getLBracLoc(), NodeRole::OpenParen);

(

*Child : S->body())

Builder.markStmtChild(Child, NodeRole::Statement);

Builder.markChildToken(S->getRBracLoc(), NodeRole::CloseParen);

Builder.foldNode(Builder.getStmtRange(S),

Builder.foldNode(Builder.getStmtRange(S),

TraverseIfStmt(

*S) {

Result = [&,

]() {

(S->hasVarStorage()) {

}

(S->getCond() && !

(S->getCond()))

Result = [&,

]() {

(S->getLoopVariable() && !

(S->getLoopVariable()))

(S->getRangeInit() && !

(S->getRangeInit()))

WalkUpFromCXXForRangeStmt(S);

(

*DS = dyn_cast_or_null<DeclStmt>(S)) {

(

*

: DS->decls())

Builder.noticeDeclWithoutSemicolon(

);

}

(

*

= dyn_cast_or_null<Expr>(S)) {

WalkUpFromExpr(

*

) {

assert(!

(

) &&

);

Builder.foldNode(Builder.getExprRange(

),

WalkUpFromUserDefinedLiteral(S);

syntax::UserDefinedLiteralExpression *

(S->getLiteralOperatorKind()) {

(allocator()) syntax::IntegerUserDefinedLiteralExpression;

(allocator()) syntax::FloatUserDefinedLiteralExpression;

(allocator()) syntax::CharUserDefinedLiteralExpression;

(allocator()) syntax::StringUserDefinedLiteralExpression;

TokLoc = S->getBeginLoc();

(

.isIntegerLiteral())

(allocator()) syntax::IntegerUserDefinedLiteralExpression;

assert(

.isFloatingLiteral());

(allocator()) syntax::FloatUserDefinedLiteralExpression;

llvm_unreachable(

);

Builder.markChildToken(S->getBeginLoc(), syntax::NodeRole::LiteralToken);

Builder.foldNode(Builder.getExprRange(S), buildUserDefinedLiteral(S), S);

(

DependentTL =

SR.

(DependentTL.getTemplateKeywordLoc());

syntax::NodeKind::GlobalNameSpecifier;

syntax::NodeKind::IdentifierNameSpecifier;

syntax::NodeKind::SimpleTemplateNameSpecifier;

(isa<DecltypeType>(NNSType))

syntax::NodeKind::DecltypeNameSpecifier;

(isa<TemplateSpecializationType, DependentTemplateSpecializationType>(

syntax::NodeKind::SimpleTemplateNameSpecifier;

syntax::NodeKind::IdentifierNameSpecifier;

llvm::report_fatal_error(

,

syntax::NameSpecifier *

NameSpecifierTokens =

Builder.getRange(getLocalSourceRange(NNSLoc)).drop_back();

syntax::NodeKind::GlobalNameSpecifier:

(allocator()) syntax::GlobalNameSpecifier;

syntax::NodeKind::IdentifierNameSpecifier: {

assert(NameSpecifierTokens.size() == 1);

Builder.markChildToken(NameSpecifierTokens.begin(),

syntax::NodeRole::Unknown);

*NS =

(allocator()) syntax::IdentifierNameSpecifier;

Builder.foldNode(NameSpecifierTokens, NS,

);

syntax::NodeKind::SimpleTemplateNameSpecifier: {

*NS =

(allocator()) syntax::SimpleTemplateNameSpecifier;

Builder.foldNode(NameSpecifierTokens, NS,

);

syntax::NodeKind::DecltypeNameSpecifier: {

(!RecursiveASTVisitor::TraverseDecltypeTypeLoc(TL))

*NS =

(allocator()) syntax::DecltypeNameSpecifier;

Builder.foldNode(NameSpecifierTokens, NS,

);

llvm_unreachable(

);

(

It = QualifierLoc; It; It = It.getPrefix()) {

*NS = buildNameSpecifier(It);

Builder.markChild(NS, syntax::NodeRole::ListElement);

Builder.markChildToken(It.getEndLoc(), syntax::NodeRole::ListDelimiter);

Builder.foldNode(Builder.getRange(QualifierLoc.

()),

Builder.markChild(QualifierLoc, syntax::NodeRole::Qualifier);

(TemplateKeywordLoc.

())

Builder.markChildToken(TemplateKeywordLoc,

syntax::NodeRole::TemplateKeyword);

Builder.foldNode(Builder.getRange(UnqualifiedIdLoc), TheUnqualifiedId,

Builder.markChild(TheUnqualifiedId, syntax::NodeRole::UnqualifiedId);

IdExpressionBeginLoc =

*TheIdExpression =

(allocator()) syntax::IdExpression;

Builder.getRange(IdExpressionBeginLoc, UnqualifiedIdLoc.

()),

TheIdExpression, From);

TheIdExpression;

(S->isImplicitAccess()) {

buildIdExpression(S->getQualifierLoc(), S->getTemplateKeywordLoc(),

(S->getMemberLoc(), S->getEndLoc()), S);

*TheIdExpression = buildIdExpression(

S->getQualifierLoc(), S->getTemplateKeywordLoc(),

(S->getMemberLoc(), S->getEndLoc()),

);

Builder.markChild(TheIdExpression, syntax::NodeRole::Member);

Builder.markExprChild(S->getBase(), syntax::NodeRole::Object);

Builder.markChildToken(S->getOperatorLoc(), syntax::NodeRole::AccessToken);

Builder.foldNode(Builder.getExprRange(S),

new (allocator()) syntax::MemberExpression, S);

buildIdExpression(S->getQualifierLoc(), S->getTemplateKeywordLoc(),

(S->getLocation(), S->getEndLoc()), S);

buildIdExpression(S->getQualifierLoc(), S->getTemplateKeywordLoc(),

(S->getLocation(), S->getEndLoc()), S);

(!S->isImplicit()) {

Builder.markChildToken(S->getLocation(),

syntax::NodeRole::IntroducerKeyword);

Builder.foldNode(Builder.getExprRange(S),

new (allocator()) syntax::ThisExpression, S);

WalkUpFromParenExpr(

*S) {

Builder.markChildToken(S->getLParen(), syntax::NodeRole::OpenParen);

Builder.markExprChild(S->getSubExpr(), syntax::NodeRole::SubExpression);

Builder.markChildToken(S->getRParen(), syntax::NodeRole::CloseParen);

Builder.foldNode(Builder.getExprRange(S),

new (allocator()) syntax::ParenExpression, S);

Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);

Builder.foldNode(Builder.getExprRange(S),

new (allocator()) syntax::IntegerLiteralExpression, S);

Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);

Builder.foldNode(Builder.getExprRange(S),

new (allocator()) syntax::CharacterLiteralExpression, S);

Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);

Builder.foldNode(Builder.getExprRange(S),

new (allocator()) syntax::FloatingLiteralExpression, S);

Builder.markChildToken(S->getBeginLoc(), syntax::NodeRole::LiteralToken);

Builder.foldNode(Builder.getExprRange(S),

new (allocator()) syntax::StringLiteralExpression, S);

Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);

Builder.foldNode(Builder.getExprRange(S),

new (allocator()) syntax::BoolLiteralExpression, S);

Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);

Builder.foldNode(Builder.getExprRange(S),

new (allocator()) syntax::CxxNullPtrExpression, S);

Builder.markChildToken(S->getOperatorLoc(),

syntax::NodeRole::OperatorToken);

Builder.markExprChild(S->getSubExpr(), syntax::NodeRole::Operand);

Builder.foldNode(Builder.getExprRange(S),

Builder.foldNode(Builder.getExprRange(S),

Builder.markExprChild(S->getLHS(), syntax::NodeRole::LeftHandSide);

Builder.markChildToken(S->getOperatorLoc(),

syntax::NodeRole::OperatorToken);

Builder.markExprChild(S->getRHS(), syntax::NodeRole::RightHandSide);

Builder.foldNode(Builder.getExprRange(S),

(

*Arg : Args) {

Builder.markExprChild(Arg, syntax::NodeRole::ListElement);

*DelimiterToken =

std::next(Builder.findToken(Arg->getEndLoc()));

(DelimiterToken->kind() == clang::tok::TokenKind::comma)

Builder.markChildToken(DelimiterToken, syntax::NodeRole::ListDelimiter);

Builder.foldNode(Builder.getRange((*Args.begin())->getBeginLoc(),

(*(Args.end() - 1))->getEndLoc()),

WalkUpFromCallExpr(

*S) {

Builder.markExprChild(S->getCallee(), syntax::NodeRole::Callee);

*LParenToken =

std::next(Builder.findToken(S->getCallee()->getEndLoc()));

(LParenToken->kind() == clang::tok::l_paren)

Builder.markChildToken(LParenToken, syntax::NodeRole::OpenParen);

Builder.markChild(buildCallArguments(S->arguments()),

syntax::NodeRole::Arguments);

Builder.markChildToken(S->getRParenLoc(), syntax::NodeRole::CloseParen);

Builder.foldNode(Builder.getRange(S->getSourceRange()),

new (allocator()) syntax::CallExpression, S);

((S->getNumArgs() == 0 || isa<CXXDefaultArgExpr>(S->getArg(0))) &&

S->getParenOrBraceRange().isInvalid())

RecursiveASTVisitor::WalkUpFromCXXConstructExpr(S);

(

*child : S->arguments()) {

(child->getSourceRange().isInvalid()) {

syntax::NodeKind::PostfixUnaryOperatorExpression);

WalkUpFromCXXOperatorCallExpr(S);

syntax::NodeKind::BinaryOperatorExpression:

Builder.markExprChild(S->getArg(0), syntax::NodeRole::LeftHandSide);

Builder.markChildToken(S->getOperatorLoc(),

syntax::NodeRole::OperatorToken);

Builder.markExprChild(S->getArg(1), syntax::NodeRole::RightHandSide);

Builder.foldNode(Builder.getExprRange(S),

syntax::NodeKind::PrefixUnaryOperatorExpression:

Builder.markChildToken(S->getOperatorLoc(),

syntax::NodeRole::OperatorToken);

Builder.markExprChild(S->getArg(0), syntax::NodeRole::Operand);

Builder.foldNode(Builder.getExprRange(S),

syntax::NodeKind::PostfixUnaryOperatorExpression:

Builder.markChildToken(S->getOperatorLoc(),

syntax::NodeRole::OperatorToken);

Builder.markExprChild(S->getArg(0), syntax::NodeRole::Operand);

Builder.foldNode(Builder.getExprRange(S),

syntax::NodeKind::CallExpression: {

Builder.markExprChild(S->getArg(0), syntax::NodeRole::Callee);

*LParenToken =

std::next(Builder.findToken(S->getArg(0)->getEndLoc()));

(LParenToken->kind() == clang::tok::l_paren)

Builder.markChildToken(LParenToken, syntax::NodeRole::OpenParen);

S->arg_begin() + 1, S->arg_end())),

syntax::NodeRole::Arguments);

Builder.markChildToken(S->getRParenLoc(), syntax::NodeRole::CloseParen);

Builder.foldNode(Builder.getRange(S->getSourceRange()),

new (allocator()) syntax::CallExpression, S);

syntax::NodeKind::UnknownExpression:

WalkUpFromExpr(S);

llvm_unreachable(

);

Tokens = Builder.getDeclarationRange(S);

(Tokens.front().kind() == tok::coloncolon) {

(!WalkUpFromParenTypeLoc(L))

Builder.markChildToken(L.

(), syntax::NodeRole::OpenParen);

Builder.markChildToken(L.

(), syntax::NodeRole::CloseParen);

Builder.markChildToken(L.

(), syntax::NodeRole::OpenParen);

Builder.markExprChild(L.

(), syntax::NodeRole::Size);

Builder.markChildToken(L.

(), syntax::NodeRole::CloseParen);

(

*

: Params) {

Builder.markChild(

, syntax::NodeRole::ListElement);

*DelimiterToken = std::next(Builder.findToken(

->getEndLoc()));

(DelimiterToken->kind() == clang::tok::TokenKind::comma)

Builder.markChildToken(DelimiterToken, syntax::NodeRole::ListDelimiter);

(!Params.empty())

Builder.foldNode(Builder.getRange(Params.front()->getBeginLoc(),

Params.back()->getEndLoc()),

Builder.markChildToken(L.

(), syntax::NodeRole::OpenParen);

Builder.markChild(buildParameterDeclarationList(L.

()),

syntax::NodeRole::Parameters);

Builder.markChildToken(L.

(), syntax::NodeRole::CloseParen);

WalkUpFromFunctionTypeLoc(L);

*TrailingReturnTokens = buildTrailingReturn(L);

Builder.markChild(TrailingReturnTokens, syntax::NodeRole::TrailingReturn);

WalkUpFromFunctionTypeLoc(L);

(!WalkUpFromMemberPointerTypeLoc(L))

Builder.foldNode(Builder.getRange(SR),

WalkUpFromDeclStmt(

*S) {

Builder.foldNode(Builder.getStmtRange(S),

WalkUpFromNullStmt(

*S) {

Builder.foldNode(Builder.getStmtRange(S),

Builder.markChildToken(S->getSwitchLoc(),

syntax::NodeRole::IntroducerKeyword);

Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement);

Builder.foldNode(Builder.getStmtRange(S),

WalkUpFromCaseStmt(

*S) {

Builder.markChildToken(S->getKeywordLoc(),

syntax::NodeRole::IntroducerKeyword);

Builder.markExprChild(S->getLHS(), syntax::NodeRole::CaseValue);

Builder.markStmtChild(S->getSubStmt(), syntax::NodeRole::BodyStatement);

Builder.foldNode(Builder.getStmtRange(S),

Builder.markChildToken(S->getKeywordLoc(),

syntax::NodeRole::IntroducerKeyword);

Builder.markStmtChild(S->getSubStmt(), syntax::NodeRole::BodyStatement);

Builder.foldNode(Builder.getStmtRange(S),

WalkUpFromIfStmt(

*S) {

Builder.markChildToken(S->getIfLoc(), syntax::NodeRole::IntroducerKeyword);

*ConditionStatement = S->getCond();

(S->hasVarStorage())

ConditionStatement = S->getConditionVariableDeclStmt();

Builder.markStmtChild(ConditionStatement, syntax::NodeRole::Condition);

Builder.markStmtChild(S->getThen(), syntax::NodeRole::ThenStatement);

Builder.markChildToken(S->getElseLoc(), syntax::NodeRole::ElseKeyword);

Builder.markStmtChild(S->getElse(), syntax::NodeRole::ElseStatement);

Builder.foldNode(Builder.getStmtRange(S),

WalkUpFromForStmt(

*S) {

Builder.markChildToken(S->getForLoc(), syntax::NodeRole::IntroducerKeyword);

Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement);

Builder.foldNode(Builder.getStmtRange(S),

WalkUpFromWhileStmt(

*S) {

Builder.markChildToken(S->getWhileLoc(),

syntax::NodeRole::IntroducerKeyword);

Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement);

Builder.foldNode(Builder.getStmtRange(S),

Builder.markChildToken(S->getContinueLoc(),

syntax::NodeRole::IntroducerKeyword);

Builder.foldNode(Builder.getStmtRange(S),

WalkUpFromBreakStmt(

*S) {

Builder.markChildToken(S->getBreakLoc(),

syntax::NodeRole::IntroducerKeyword);

Builder.foldNode(Builder.getStmtRange(S),

Builder.markChildToken(S->getReturnLoc(),

syntax::NodeRole::IntroducerKeyword);

Builder.markExprChild(S->getRetValue(), syntax::NodeRole::ReturnValue);

Builder.foldNode(Builder.getStmtRange(S),

Builder.markChildToken(S->getForLoc(), syntax::NodeRole::IntroducerKeyword);

Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement);

Builder.foldNode(Builder.getStmtRange(S),

WalkUpFromEmptyDecl(

*S) {

Builder.foldNode(Builder.getDeclarationRange(S),

Builder.markExprChild(S->getAssertExpr(), syntax::NodeRole::Condition);

Builder.markExprChild(S->getMessage(), syntax::NodeRole::Message);

Builder.foldNode(Builder.getDeclarationRange(S),

Builder.foldNode(Builder.getDeclarationRange(S),

Builder.foldNode(Builder.getDeclarationRange(S),

Builder.foldNode(Builder.getDeclarationRange(S),

WalkUpFromUsingDecl(

*S) {

Builder.foldNode(Builder.getDeclarationRange(S),

Builder.foldNode(Builder.getDeclarationRange(S),

Builder.foldNode(Builder.getDeclarationRange(S),

Builder.foldNode(Builder.getDeclarationRange(S),

<

T>

processDeclaratorAndDeclaration(

*

) {

Builder.sourceManager(),

->getTypeSourceInfo()->getTypeLoc(),

syntax::NodeRole::Declarators);

Builder.foldNode(Builder.getDeclarationRange(

),

Builder.foldNode(Builder.getRange(

), N,

);

Builder.markChild(N, syntax::NodeRole::ListElement);

(!Builder.isResponsibleForCreatingDeclaration(

)) {

*DelimiterToken = std::next(Builder.findToken(

.

()));

(DelimiterToken->kind() == clang::tok::TokenKind::comma)

Builder.markChildToken(DelimiterToken, syntax::NodeRole::ListDelimiter);

DeclarationRange = Builder.getDeclarationRange(

);

Builder.foldList(DeclarationRange, DL,

);

Builder.markChild(DL, syntax::NodeRole::Declarators);

Builder.foldNode(DeclarationRange,

ReturnDeclaratorRange =

(GetStartLoc().Visit(ReturnedType),

ReturnedType.getEndLoc());

(ReturnDeclaratorRange.isValid()) {

Builder.foldNode(Builder.getRange(ReturnDeclaratorRange),

ReturnDeclarator,

);

Return = Builder.getRange(ReturnedType.getSourceRange());

*Arrow = Return.begin() - 1;

assert(Arrow->kind() == tok::arrow);

Builder.markChildToken(Arrow, syntax::NodeRole::ArrowToken);

(ReturnDeclarator)

Builder.markChild(ReturnDeclarator, syntax::NodeRole::Declarator);

Builder.foldNode(Tokens, R, L);

foldExplicitTemplateInstantiation(

assert(!ExternKW || ExternKW->

() == tok::kw_extern);

assert(TemplateKW && TemplateKW->

() == tok::kw_template);

Builder.markChildToken(ExternKW, syntax::NodeRole::ExternKeyword);

Builder.markChildToken(TemplateKW, syntax::NodeRole::IntroducerKeyword);

Builder.markChild(InnerDeclaration, syntax::NodeRole::Declaration);

assert(TemplateKW && TemplateKW->

() == tok::kw_template);

Builder.markChildToken(TemplateKW, syntax::NodeRole::IntroducerKeyword);

Builder.foldNode(

, N, From);

Builder.markChild(N, syntax::NodeRole::Declaration);

llvm::BumpPtrAllocator &allocator() {

Builder.allocator(); }

DeclsWithoutSemicolons.insert(

);

Pending.assignRole(*findToken(

), Role);

Pending.assignRole(*

, R);

*SN = Mapping.find(N);

assert(SN !=

);

*SN = Mapping.find(NNSLoc);

assert(SN !=

);

(

*ChildExpr = dyn_cast<Expr>(Child)) {

Pending.foldChildren(TBTM.tokenBuffer(), getStmtRange(Child), ChildNode);

ChildNode = Mapping.find(Child);

assert(ChildNode !=

);

setRole(ChildNode, Role);

assert(ChildNode !=

);

setRole(ChildNode, Role);

It = LocationToToken.find(L);

assert(It != LocationToToken.end());

BuildTreeVisitor(Context, Builder).TraverseAST(Context);

std::move(Builder).finalize();

Forward declaration of all AST node types.

BoundNodesTreeBuilder Nodes

static SourceRange getDeclaratorRange(const SourceManager &SM, TypeLoc T, SourceLocation Name, SourceRange Initializer)

Gets the range of declarator as defined by the C++ grammar.

static Expr * IgnoreImplicit(Expr *E)

static CallExpr::arg_range dropDefaultArgs(CallExpr::arg_range Args)

static LLVM_ATTRIBUTE_UNUSED bool isImplicitExpr(Expr *E)

static Expr * IgnoreCXXFunctionalCastExprWrappingConstructor(Expr *E)

static syntax::NodeKind getOperatorNodeKind(const CXXOperatorCallExpr &E)

static SourceLocation getQualifiedNameStart(NamedDecl *D)

Get the start of the qualified name.

static SourceRange getInitializerRange(Decl *D)

Gets the range of the initializer inside an init-declarator C++ [dcl.decl].

static Expr * IgnoreImplicitConstructorSingleStep(Expr *E)

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

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

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

Defines the clang::SourceLocation class and associated facilities.

Defines the SourceManager interface.

Defines various enumerations that describe declaration and type specifiers.

Defines the clang::TokenKind enum and support functions.

Defines the clang::TypeLoc interface and its subclasses.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

SourceManager & getSourceManager()

const LangOptions & getLangOpts() const

DiagnosticsEngine & getDiagnostics() const

const TargetInfo & getTargetInfo() const

Wrapper for source info for arrays.

SourceLocation getLBracketLoc() const

Expr * getSizeExpr() const

SourceLocation getRBracketLoc() const

A builtin binary operation expression such as "x + y" or "x <= y".

Wrapper for source info for block pointers.

BreakStmt - This represents a break.

A boolean literal, per ([C++ lex.bool] Boolean literals).

Represents a call to a C++ constructor.

A default argument (C++ [dcl.fct.default]).

CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...

The null pointer literal (C++11 [lex.nullptr])

A call to an overloaded operator written using operator syntax.

Represents the this expression in C++.

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

llvm::iterator_range< arg_iterator > arg_range

CaseStmt - Represent a case statement.

Represents a class template specialization, which refers to a class template with a given set of temp...

CompoundStmt - This represents a group of statements like { stmt stmt }.

ContinueStmt - This represents a continue.

A reference to a declared variable, function, enum, etc.

DeclStmt - Adaptor class for mixing declarations with statements and expressions.

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

bool isImplicit() const

isImplicit - Indicates whether the declaration was implicitly generated by the implementation.

Decl * getNextDeclInContext()

SourceLocation getLocation() const

SourceLocation getBeginLoc() const LLVM_READONLY

virtual SourceRange getSourceRange() const LLVM_READONLY

Source range that this declaration covers.

Represents a ValueDecl that came out of a declarator.

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

Represents an empty-declaration.

This represents one expression.

ForStmt - This represents a 'for (init;cond;inc)' stmt.

bool hasTrailingReturn() const

Whether this function prototype has a trailing return type.

Wrapper for source info for functions.

ArrayRef< ParmVarDecl * > getParams() const

TypeLoc getReturnLoc() const

SourceLocation getLParenLoc() const

SourceLocation getRParenLoc() const

IfStmt - This represents an if/then/else.

const TypeClass * getTypePtr() const

Represents a linkage specification.

MemberExpr - [C99 6.5.2.3] Structure and Union Members.

Wrapper for source info for member pointers.

SourceRange getLocalSourceRange() const

This represents a decl that may have a name.

Represents a C++ namespace alias.

Represent a C++ namespace.

A C++ nested-name-specifier augmented with source location information.

SourceLocation getBeginLoc() const

Retrieve the location of the beginning of this nested-name-specifier.

TypeLoc getTypeLoc() const

For a nested-name-specifier that refers to a type, retrieve the type with source-location information...

SourceRange getLocalSourceRange() const

Retrieve the source range covering just the last part of this nested-name-specifier,...

bool hasQualifier() const

Evaluates true when this nested-name-specifier location is non-empty.

NestedNameSpecifier * getNestedNameSpecifier() const

Retrieve the nested-name-specifier to which this instance refers.

SourceRange getSourceRange() const LLVM_READONLY

Retrieve the source range covering the entirety of this nested-name-specifier.

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

SpecifierKind getKind() const

Determine what kind of nested name specifier is stored.

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

@ Identifier

An identifier, stored as an IdentifierInfo*.

@ Global

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

@ Namespace

A namespace, stored as a NamespaceDecl*.

const Type * getAsType() const

Retrieve the type stored in this nested name specifier.

NullStmt - This is the null statement ";": C99 6.8.3p3.

NumericLiteralParser - This performs strict semantic analysis of the content of a ppnumber,...

Wraps an ObjCPointerType with source location information.

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

ParenExpr - This represents a parenthesized expression, e.g.

SourceLocation getRParenLoc() const

SourceLocation getLParenLoc() const

TypeLoc getInnerLoc() const

TypeLoc getPointeeLoc() const

Wrapper for source info for pointers.

A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...

bool TraverseStmt(Stmt *S, DataRecursionQueue *Queue=nullptr)

Recursively visit a statement or expression, by dispatching to Traverse*() based on the argument's dy...

bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS)

Recursively visit a C++ nested-name-specifier with location information.

bool TraverseDecl(Decl *D)

Recursively visit a declaration, by dispatching to Traverse*Decl() based on the argument's dynamic ty...

bool WalkUpFromStmt(Stmt *S)

bool TraverseTypeLoc(TypeLoc TL)

Recursively visit a type with location, by dispatching to Traverse*TypeLoc() based on the argument ty...

bool shouldTraversePostOrder() const

Return whether this visitor should traverse post-order.

ReturnStmt - This represents a return, optionally of an expression: return; return 4;.

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

This class handles loading and caching of source files into memory.

bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const

Determines the order of 2 source locations in the translation unit.

A trivial tuple used to represent a source range.

void setBegin(SourceLocation b)

SourceLocation getEnd() const

SourceLocation getBegin() const

Represents a C++11 static_assert declaration.

Stmt - This represents one statement.

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...

StringLiteral - This represents a string literal expression, e.g.

SwitchStmt - This represents a 'switch' stmt.

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

The base class of all kinds of template declarations (e.g., class, function, etc.).

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

The top declaration context.

Represents the declaration of a typedef-name via a C++11 alias-declaration.

RetTy Visit(TypeLoc TyLoc)

RetTy VisitTypeLoc(TypeLoc TyLoc)

Base wrapper for a particular "section" of type source info.

T castAs() const

Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.

SourceLocation getEndLoc() const

Get the end source location.

Base class for declarations which introduce a typedef-name.

UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...

Represents a dependent using declaration which was marked with typename.

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

A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit....

@ LOK_String

operator "" X (const CharT *, size_t)

@ LOK_Raw

Raw form: operator "" X (const char *)

@ LOK_Floating

operator "" X (long double)

@ LOK_Integer

operator "" X (unsigned long long)

@ LOK_Template

Raw form: operator "" X<cs...> ()

@ LOK_Character

operator "" X (CharT)

Represents a C++ using-declaration.

Represents C++ using-directive.

WhileStmt - This represents a 'while' stmt.

A memory arena for syntax trees.

llvm::BumpPtrAllocator & getAllocator()

Array size specified inside a declarator.

Models arguments of a function call.

{ statement1; statement2; … }

A declaration that can appear at the top-level.

A semicolon in the top-level context. Does not declare anything.

The no-op statement, i.e. ';'.

template <declaration> Examples: template struct X<int> template void foo<int>() template int var<dou...

Expression in a statement position, e.g.

for (<init>; <cond>; <increment>) <body>

if (cond) <then-statement> else <else-statement> FIXME: add condition that models 'expression or vari...

A leaf node points to a single token.

extern <string-literal> declaration extern <string-literal> { <decls> }

A list of Elements separated or terminated by a fixed token.

Member pointer inside a declarator E.g.

namespace <name> = <namespace-reference>

namespace <name> { <decls> }

Models a nested-name-specifier.

Models a parameter-declaration-list which appears within parameters-and-qualifiers.

Parameter list for a function type and a trailing return type, if the function has one.

Declarator inside parentheses.

for (<decl> : <init>) <body>

Groups multiple declarators (e.g.

A top-level declarator without parentheses.

static_assert(<condition>, <message>) static_assert(<condition>)

template <template-parameters> <declaration>

A TokenBuffer-powered token manager.

const TokenBuffer & tokenBuffer() const

SourceManager & sourceManager()

A list of tokens obtained by preprocessing a text buffer and operations to map between the expanded a...

llvm::ArrayRef< syntax::Token > expandedTokens() const

All tokens produced by the preprocessor after all macro replacements, directives, etc.

std::optional< llvm::ArrayRef< syntax::Token > > spelledForExpanded(llvm::ArrayRef< syntax::Token > Expanded) const

Returns the subrange of spelled tokens corresponding to AST node spanning Expanded.

uintptr_t Key

A key to identify a specific token.

A token coming directly from a file or from a macro invocation.

tok::TokenKind kind() const

Trailing return type after the parameter list, including the arrow token.

A node that has children and represents a syntactic language construct.

Declaration of an unknown kind, e.g. not yet supported in syntax trees.

An expression of an unknown kind, i.e.

A statement of an unknown kind, i.e.

Models an unqualified-id.

using <scope>::<name> using typename <scope>::<name>

A helper class for constructing the syntax tree while traversing a clang AST.

ArrayRef< syntax::Token > getRange(SourceLocation First, SourceLocation Last) const

Finds the syntax tokens corresponding to the passed source locations.

ArrayRef< syntax::Token > getStmtRange(const Stmt *S) const

Find the adjusted range for the statement, consuming the trailing semicolon when needed.

void foldList(ArrayRef< syntax::Token > SuperRange, syntax::List *New, ASTPtr From)

Populate children for New list, assuming it covers tokens from a subrange of SuperRange.

void markExprChild(Expr *Child, NodeRole Role)

Should be called for expressions in non-statement position to avoid wrapping into expression statemen...

const SourceManager & sourceManager() const

void markChildToken(SourceLocation Loc, NodeRole R)

Set role for a token starting at Loc.

ArrayRef< syntax::Token > getDeclarationRange(Decl *D)

void markChild(syntax::Node *N, NodeRole R)

Set role for N.

void foldNode(ArrayRef< syntax::Token > Range, syntax::Tree *New, TypeLoc L)

const syntax::Token * findToken(SourceLocation L) const

Finds a token starting at L. The token must exist if L is valid.

void noticeDeclWithoutSemicolon(Decl *D)

Notifies that we should not consume trailing semicolon when computing token range of D.

ArrayRef< syntax::Token > getRange(SourceRange Range) const

Finds the syntax tokens corresponding to the SourceRange.

bool isResponsibleForCreatingDeclaration(const Decl *D) const

Returns true if D is the last declarator in a chain and is thus reponsible for creating SimpleDeclara...

syntax::TranslationUnit * finalize() &&

Finish building the tree and consume the root node.

void foldNode(ArrayRef< syntax::Token > Range, syntax::Tree *New, ASTPtr From)

Populate children for New node, assuming it covers tokens from Range.

TreeBuilder(syntax::Arena &Arena, TokenBufferTokenManager &TBTM)

ArrayRef< syntax::Token > getTemplateRange(const ClassTemplateSpecializationDecl *D) const

void foldNode(llvm::ArrayRef< syntax::Token > Range, syntax::Tree *New, NestedNameSpecifierLoc From)

ArrayRef< syntax::Token > getExprRange(const Expr *E) const

void markStmtChild(Stmt *Child, NodeRole Role)

Mark the Child node with a corresponding Role.

llvm::BumpPtrAllocator & allocator()

uint32_t Literal

Literals are represented as positive integers.

NodeRole

A relation between a parent and child node, e.g.

@ ListElement

List API roles.

@ Detached

A node without a parent.

@ Unknown

Children of an unknown semantic nature, e.g. skipped tokens, comments.

syntax::TranslationUnit * buildSyntaxTree(Arena &A, TokenBufferTokenManager &TBTM, ASTContext &Context)

Build a syntax tree for the main file.

NodeKind

A kind of a syntax node, used for implementing casts.

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

@ OO_None

Not an overloaded operator.

@ NUM_OVERLOADED_OPERATORS

Expr * IgnoreExprNodes(Expr *E, FnTys &&... Fns)

Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *, Recursively apply each of the f...

@ Result

The result type of a method or function.

Expr * IgnoreImplicitSingleStep(Expr *E)

const FunctionProtoType * T

void finalize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)

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