Lines Matching defs:S
249 /// `int ^a::S::f(){}`
290 /// `int S::f(){}` -> range of `S::f()`.
512 if (const auto *S = dyn_cast<TagDecl>(D))
513 Tokens = getRange(S->TypeDecl::getBeginLoc(), S->getEndLoc());
525 ArrayRef<syntax::Token> getStmtRange(const Stmt *S) const {
526 auto Tokens = getRange(S->getSourceRange());
527 if (isa<CompoundStmt>(S))
744 bool WalkUpFromTemplateDecl(TemplateDecl *S) {
746 Builder.getDeclarationRange(S),
747 Builder.findToken(S->getTemplateParameters()->getTemplateLoc()),
748 Builder.getDeclarationRange(S->getTemplatedDecl()), S);
777 if (auto *S = dyn_cast<ClassTemplatePartialSpecializationDecl>(C))
778 ConsumeTemplateParameters(*S->getTemplateParameters());
790 bool WalkUpFromCompoundStmt(CompoundStmt *S) {
793 Builder.markChildToken(S->getLBracLoc(), NodeRole::OpenParen);
794 for (auto *Child : S->body())
796 Builder.markChildToken(S->getRBracLoc(), NodeRole::CloseParen);
798 Builder.foldNode(Builder.getStmtRange(S),
799 new (allocator()) syntax::CompoundStatement, S);
804 bool WalkUpFromStmt(Stmt *S) {
805 Builder.foldNode(Builder.getStmtRange(S),
806 new (allocator()) syntax::UnknownStatement, S);
810 bool TraverseIfStmt(IfStmt *S) {
812 if (S->getInit() && !TraverseStmt(S->getInit())) {
818 if (S->hasVarStorage()) {
819 if (!TraverseStmt(S->getConditionVariableDeclStmt()))
821 } else if (S->getCond() && !TraverseStmt(S->getCond()))
824 if (S->getThen() && !TraverseStmt(S->getThen()))
826 if (S->getElse() && !TraverseStmt(S->getElse()))
830 WalkUpFromIfStmt(S);
834 bool TraverseCXXForRangeStmt(CXXForRangeStmt *S) {
840 if (S->getInit() && !TraverseStmt(S->getInit()))
842 if (S->getLoopVariable() && !TraverseDecl(S->getLoopVariable()))
844 if (S->getRangeInit() && !TraverseStmt(S->getRangeInit()))
846 if (S->getBody() && !TraverseStmt(S->getBody()))
850 WalkUpFromCXXForRangeStmt(S);
854 bool TraverseStmt(Stmt *S) {
855 if (auto *DS = dyn_cast_or_null<DeclStmt>(S)) {
859 } else if (auto *E = dyn_cast_or_null<Expr>(S)) {
862 return RecursiveASTVisitor::TraverseStmt(S);
878 bool TraverseUserDefinedLiteral(UserDefinedLiteral *S) {
884 return WalkUpFromUserDefinedLiteral(S);
888 buildUserDefinedLiteral(UserDefinedLiteral *S) {
889 switch (S->getLiteralOperatorKind()) {
904 auto TokLoc = S->getBeginLoc();
921 bool WalkUpFromUserDefinedLiteral(UserDefinedLiteral *S) {
922 Builder.markChildToken(S->getBeginLoc(), syntax::NodeRole::LiteralToken);
923 Builder.foldNode(Builder.getExprRange(S), buildUserDefinedLiteral(S), S);
1071 bool WalkUpFromMemberExpr(MemberExpr *S) {
1075 if (S->isImplicitAccess()) {
1076 buildIdExpression(S->getQualifierLoc(), S->getTemplateKeywordLoc(),
1077 SourceRange(S->getMemberLoc(), S->getEndLoc()), S);
1082 S->getQualifierLoc(), S->getTemplateKeywordLoc(),
1083 SourceRange(S->getMemberLoc(), S->getEndLoc()), nullptr);
1087 Builder.markExprChild(S->getBase(), syntax::NodeRole::Object);
1088 Builder.markChildToken(S->getOperatorLoc(), syntax::NodeRole::AccessToken);
1090 Builder.foldNode(Builder.getExprRange(S),
1091 new (allocator()) syntax::MemberExpression, S);
1095 bool WalkUpFromDeclRefExpr(DeclRefExpr *S) {
1096 buildIdExpression(S->getQualifierLoc(), S->getTemplateKeywordLoc(),
1097 SourceRange(S->getLocation(), S->getEndLoc()), S);
1103 bool WalkUpFromDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *S) {
1104 buildIdExpression(S->getQualifierLoc(), S->getTemplateKeywordLoc(),
1105 SourceRange(S->getLocation(), S->getEndLoc()), S);
1110 bool WalkUpFromCXXThisExpr(CXXThisExpr *S) {
1111 if (!S->isImplicit()) {
1112 Builder.markChildToken(S->getLocation(),
1114 Builder.foldNode(Builder.getExprRange(S),
1115 new (allocator()) syntax::ThisExpression, S);
1120 bool WalkUpFromParenExpr(ParenExpr *S) {
1121 Builder.markChildToken(S->getLParen(), syntax::NodeRole::OpenParen);
1122 Builder.markExprChild(S->getSubExpr(), syntax::NodeRole::SubExpression);
1123 Builder.markChildToken(S->getRParen(), syntax::NodeRole::CloseParen);
1124 Builder.foldNode(Builder.getExprRange(S),
1125 new (allocator()) syntax::ParenExpression, S);
1129 bool WalkUpFromIntegerLiteral(IntegerLiteral *S) {
1130 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
1131 Builder.foldNode(Builder.getExprRange(S),
1132 new (allocator()) syntax::IntegerLiteralExpression, S);
1136 bool WalkUpFromCharacterLiteral(CharacterLiteral *S) {
1137 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
1138 Builder.foldNode(Builder.getExprRange(S),
1139 new (allocator()) syntax::CharacterLiteralExpression, S);
1143 bool WalkUpFromFloatingLiteral(FloatingLiteral *S) {
1144 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
1145 Builder.foldNode(Builder.getExprRange(S),
1146 new (allocator()) syntax::FloatingLiteralExpression, S);
1150 bool WalkUpFromStringLiteral(StringLiteral *S) {
1151 Builder.markChildToken(S->getBeginLoc(), syntax::NodeRole::LiteralToken);
1152 Builder.foldNode(Builder.getExprRange(S),
1153 new (allocator()) syntax::StringLiteralExpression, S);
1157 bool WalkUpFromCXXBoolLiteralExpr(CXXBoolLiteralExpr *S) {
1158 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
1159 Builder.foldNode(Builder.getExprRange(S),
1160 new (allocator()) syntax::BoolLiteralExpression, S);
1164 bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {
1165 Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
1166 Builder.foldNode(Builder.getExprRange(S),
1167 new (allocator()) syntax::CxxNullPtrExpression, S);
1171 bool WalkUpFromUnaryOperator(UnaryOperator *S) {
1172 Builder.markChildToken(S->getOperatorLoc(),
1174 Builder.markExprChild(S->getSubExpr(), syntax::NodeRole::Operand);
1176 if (S->isPostfix())
1177 Builder.foldNode(Builder.getExprRange(S),
1179 S);
1181 Builder.foldNode(Builder.getExprRange(S),
1183 S);
1188 bool WalkUpFromBinaryOperator(BinaryOperator *S) {
1189 Builder.markExprChild(S->getLHS(), syntax::NodeRole::LeftHandSide);
1190 Builder.markChildToken(S->getOperatorLoc(),
1192 Builder.markExprChild(S->getRHS(), syntax::NodeRole::RightHandSide);
1193 Builder.foldNode(Builder.getExprRange(S),
1194 new (allocator()) syntax::BinaryOperatorExpression, S);
1220 bool WalkUpFromCallExpr(CallExpr *S) {
1221 Builder.markExprChild(S->getCallee(), syntax::NodeRole::Callee);
1224 std::next(Builder.findToken(S->getCallee()->getEndLoc()));
1230 Builder.markChild(buildCallArguments(S->arguments()),
1233 Builder.markChildToken(S->getRParenLoc(), syntax::NodeRole::CloseParen);
1235 Builder.foldNode(Builder.getRange(S->getSourceRange()),
1236 new (allocator()) syntax::CallExpression, S);
1240 bool WalkUpFromCXXConstructExpr(CXXConstructExpr *S) {
1242 if ((S->getNumArgs() == 0 || isa<CXXDefaultArgExpr>(S->getArg(0))) &&
1243 S->getParenOrBraceRange().isInvalid())
1245 return RecursiveASTVisitor::WalkUpFromCXXConstructExpr(S);
1248 bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr *S) {
1253 for (auto *child : S->arguments()) {
1261 assert(getOperatorNodeKind(*S) ==
1268 return WalkUpFromCXXOperatorCallExpr(S);
1271 bool WalkUpFromCXXOperatorCallExpr(CXXOperatorCallExpr *S) {
1272 switch (getOperatorNodeKind(*S)) {
1274 Builder.markExprChild(S->getArg(0), syntax::NodeRole::LeftHandSide);
1275 Builder.markChildToken(S->getOperatorLoc(),
1277 Builder.markExprChild(S->getArg(1), syntax::NodeRole::RightHandSide);
1278 Builder.foldNode(Builder.getExprRange(S),
1279 new (allocator()) syntax::BinaryOperatorExpression, S);
1282 Builder.markChildToken(S->getOperatorLoc(),
1284 Builder.markExprChild(S->getArg(0), syntax::NodeRole::Operand);
1285 Builder.foldNode(Builder.getExprRange(S),
1287 S);
1290 Builder.markChildToken(S->getOperatorLoc(),
1292 Builder.markExprChild(S->getArg(0), syntax::NodeRole::Operand);
1293 Builder.foldNode(Builder.getExprRange(S),
1295 S);
1298 Builder.markExprChild(S->getArg(0), syntax::NodeRole::Callee);
1301 std::next(Builder.findToken(S->getArg(0)->getEndLoc()));
1308 S->arg_begin() + 1, S->arg_end())),
1311 Builder.markChildToken(S->getRParenLoc(), syntax::NodeRole::CloseParen);
1313 Builder.foldNode(Builder.getRange(S->getSourceRange()),
1314 new (allocator()) syntax::CallExpression, S);
1318 return WalkUpFromExpr(S);
1324 bool WalkUpFromCXXDefaultArgExpr(CXXDefaultArgExpr *S) { return true; }
1326 bool WalkUpFromNamespaceDecl(NamespaceDecl *S) {
1327 auto Tokens = Builder.getDeclarationRange(S);
1334 Builder.foldNode(Tokens, new (allocator()) syntax::NamespaceDefinition, S);
1423 bool WalkUpFromDeclStmt(DeclStmt *S) {
1424 Builder.foldNode(Builder.getStmtRange(S),
1425 new (allocator()) syntax::DeclarationStatement, S);
1429 bool WalkUpFromNullStmt(NullStmt *S) {
1430 Builder.foldNode(Builder.getStmtRange(S),
1431 new (allocator()) syntax::EmptyStatement, S);
1435 bool WalkUpFromSwitchStmt(SwitchStmt *S) {
1436 Builder.markChildToken(S->getSwitchLoc(),
1438 Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement);
1439 Builder.foldNode(Builder.getStmtRange(S),
1440 new (allocator()) syntax::SwitchStatement, S);
1444 bool WalkUpFromCaseStmt(CaseStmt *S) {
1445 Builder.markChildToken(S->getKeywordLoc(),
1447 Builder.markExprChild(S->getLHS(), syntax::NodeRole::CaseValue);
1448 Builder.markStmtChild(S->getSubStmt(), syntax::NodeRole::BodyStatement);
1449 Builder.foldNode(Builder.getStmtRange(S),
1450 new (allocator()) syntax::CaseStatement, S);
1454 bool WalkUpFromDefaultStmt(DefaultStmt *S) {
1455 Builder.markChildToken(S->getKeywordLoc(),
1457 Builder.markStmtChild(S->getSubStmt(), syntax::NodeRole::BodyStatement);
1458 Builder.foldNode(Builder.getStmtRange(S),
1459 new (allocator()) syntax::DefaultStatement, S);
1463 bool WalkUpFromIfStmt(IfStmt *S) {
1464 Builder.markChildToken(S->getIfLoc(), syntax::NodeRole::IntroducerKeyword);
1465 Stmt *ConditionStatement = S->getCond();
1466 if (S->hasVarStorage())
1467 ConditionStatement = S->getConditionVariableDeclStmt();
1469 Builder.markStmtChild(S->getThen(), syntax::NodeRole::ThenStatement);
1470 Builder.markChildToken(S->getElseLoc(), syntax::NodeRole::ElseKeyword);
1471 Builder.markStmtChild(S->getElse(), syntax::NodeRole::ElseStatement);
1472 Builder.foldNode(Builder.getStmtRange(S),
1473 new (allocator()) syntax::IfStatement, S);
1477 bool WalkUpFromForStmt(ForStmt *S) {
1478 Builder.markChildToken(S->getForLoc(), syntax::NodeRole::IntroducerKeyword);
1479 Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement);
1480 Builder.foldNode(Builder.getStmtRange(S),
1481 new (allocator()) syntax::ForStatement, S);
1485 bool WalkUpFromWhileStmt(WhileStmt *S) {
1486 Builder.markChildToken(S->getWhileLoc(),
1488 Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement);
1489 Builder.foldNode(Builder.getStmtRange(S),
1490 new (allocator()) syntax::WhileStatement, S);
1494 bool WalkUpFromContinueStmt(ContinueStmt *S) {
1495 Builder.markChildToken(S->getContinueLoc(),
1497 Builder.foldNode(Builder.getStmtRange(S),
1498 new (allocator()) syntax::ContinueStatement, S);
1502 bool WalkUpFromBreakStmt(BreakStmt *S) {
1503 Builder.markChildToken(S->getBreakLoc(),
1505 Builder.foldNode(Builder.getStmtRange(S),
1506 new (allocator()) syntax::BreakStatement, S);
1510 bool WalkUpFromReturnStmt(ReturnStmt *S) {
1511 Builder.markChildToken(S->getReturnLoc(),
1513 Builder.markExprChild(S->getRetValue(), syntax::NodeRole::ReturnValue);
1514 Builder.foldNode(Builder.getStmtRange(S),
1515 new (allocator()) syntax::ReturnStatement, S);
1519 bool WalkUpFromCXXForRangeStmt(CXXForRangeStmt *S) {
1520 Builder.markChildToken(S->getForLoc(), syntax::NodeRole::IntroducerKeyword);
1521 Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement);
1522 Builder.foldNode(Builder.getStmtRange(S),
1523 new (allocator()) syntax::RangeBasedForStatement, S);
1527 bool WalkUpFromEmptyDecl(EmptyDecl *S) {
1528 Builder.foldNode(Builder.getDeclarationRange(S),
1529 new (allocator()) syntax::EmptyDeclaration, S);
1533 bool WalkUpFromStaticAssertDecl(StaticAssertDecl *S) {
1534 Builder.markExprChild(S->getAssertExpr(), syntax::NodeRole::Condition);
1535 Builder.markExprChild(S->getMessage(), syntax::NodeRole::Message);
1536 Builder.foldNode(Builder.getDeclarationRange(S),
1537 new (allocator()) syntax::StaticAssertDeclaration, S);
1541 bool WalkUpFromLinkageSpecDecl(LinkageSpecDecl *S) {
1542 Builder.foldNode(Builder.getDeclarationRange(S),
1544 S);
1548 bool WalkUpFromNamespaceAliasDecl(NamespaceAliasDecl *S) {
1549 Builder.foldNode(Builder.getDeclarationRange(S),
1550 new (allocator()) syntax::NamespaceAliasDefinition, S);
1554 bool WalkUpFromUsingDirectiveDecl(UsingDirectiveDecl *S) {
1555 Builder.foldNode(Builder.getDeclarationRange(S),
1556 new (allocator()) syntax::UsingNamespaceDirective, S);
1560 bool WalkUpFromUsingDecl(UsingDecl *S) {
1561 Builder.foldNode(Builder.getDeclarationRange(S),
1562 new (allocator()) syntax::UsingDeclaration, S);
1566 bool WalkUpFromUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *S) {
1567 Builder.foldNode(Builder.getDeclarationRange(S),
1568 new (allocator()) syntax::UsingDeclaration, S);
1572 bool WalkUpFromUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *S) {
1573 Builder.foldNode(Builder.getDeclarationRange(S),
1574 new (allocator()) syntax::UsingDeclaration, S);
1578 bool WalkUpFromTypeAliasDecl(TypeAliasDecl *S) {
1579 Builder.foldNode(Builder.getDeclarationRange(S),
1580 new (allocator()) syntax::TypeAliasDeclaration, S);