17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/Support/Debug.h"
19 #include "llvm/Support/raw_ostream.h"
21 #define DEBUG_TYPE "format-parser"
37 class ScopedDeclarationState {
39 ScopedDeclarationState(UnwrappedLine &
Line, std::vector<bool> &
Stack,
40 bool MustBeDeclaration)
41 : Line(Line), Stack(Stack) {
42 Line.MustBeDeclaration = MustBeDeclaration;
43 Stack.push_back(MustBeDeclaration);
45 ~ScopedDeclarationState() {
48 Line.MustBeDeclaration = Stack.back();
50 Line.MustBeDeclaration =
true;
58 static bool isLineComment(
const FormatToken &FormatTok) {
59 return FormatTok.is(tok::comment) &&
60 FormatTok.TokenText.startswith(
"//");
66 static bool continuesLineComment(
const FormatToken &FormatTok,
68 const FormatToken *MinColumnToken) {
69 if (!Previous || !MinColumnToken)
71 unsigned MinContinueColumn =
72 MinColumnToken->OriginalColumn + (isLineComment(*MinColumnToken) ? 0 : 1);
73 return isLineComment(FormatTok) && FormatTok.NewlinesBefore == 1 &&
74 isLineComment(*Previous) &&
75 FormatTok.OriginalColumn >= MinContinueColumn;
78 class ScopedMacroState :
public FormatTokenSource {
80 ScopedMacroState(UnwrappedLine &Line, FormatTokenSource *&
TokenSource,
82 : Line(Line), TokenSource(TokenSource), ResetToken(ResetToken),
87 Line.InPPDirective =
true;
90 ~ScopedMacroState()
override {
93 Line.InPPDirective =
false;
97 FormatToken *getNextToken()
override {
110 FormatToken *setPosition(
unsigned Position)
override {
123 FormatToken *getFakeEOF() {
124 static bool EOFInitialized =
false;
125 static FormatToken FormatTok;
126 if (!EOFInitialized) {
127 FormatTok.Tok.startToken();
129 EOFInitialized =
true;
149 bool SwitchToPreprocessorLines =
false)
150 : Parser(Parser), OriginalLines(Parser.CurrentLines) {
151 if (SwitchToPreprocessorLines)
152 Parser.CurrentLines = &Parser.PreprocessorDirectives;
153 else if (!Parser.Line->Tokens.empty())
154 Parser.CurrentLines = &Parser.Line->Tokens.back().Children;
155 PreBlockLine = std::move(Parser.Line);
156 Parser.Line = llvm::make_unique<UnwrappedLine>();
157 Parser.Line->Level = PreBlockLine->Level;
158 Parser.Line->InPPDirective = PreBlockLine->InPPDirective;
162 if (!
Parser.Line->Tokens.empty()) {
163 Parser.addUnwrappedLine();
165 assert(
Parser.Line->Tokens.empty());
166 Parser.Line = std::move(PreBlockLine);
167 if (
Parser.CurrentLines == &
Parser.PreprocessorDirectives)
168 Parser.MustBreakBeforeNextToken =
true;
169 Parser.CurrentLines = OriginalLines;
175 std::unique_ptr<UnwrappedLine> PreBlockLine;
183 : LineLevel(LineLevel), OldLineLevel(LineLevel) {
185 Parser->addUnwrappedLine();
193 unsigned OldLineLevel;
198 class IndexedTokenSource :
public FormatTokenSource {
201 : Tokens(Tokens), Position(-1) {}
203 FormatToken *getNextToken()
override {
208 unsigned getPosition()
override {
209 assert(Position >= 0);
213 FormatToken *setPosition(
unsigned P)
override {
218 void reset() { Position = -1; }
232 CurrentLines(&Lines), Style(Style), Keywords(Keywords),
233 CommentPragmasRegex(Style.CommentPragmas), Tokens(nullptr),
234 Callback(Callback), AllTokens(Tokens), PPBranchLevel(-1) {}
236 void UnwrappedLineParser::reset() {
239 CommentsBeforeNextToken.clear();
241 MustBreakBeforeNextToken =
false;
242 PreprocessorDirectives.clear();
243 CurrentLines = &Lines;
244 DeclarationScopeStack.clear();
251 DEBUG(llvm::dbgs() <<
"----\n");
259 pushToken(FormatTok);
269 while (!PPLevelBranchIndex.empty() &&
270 PPLevelBranchIndex.back() + 1 >= PPLevelBranchCount.back()) {
271 PPLevelBranchIndex.resize(PPLevelBranchIndex.size() - 1);
272 PPLevelBranchCount.resize(PPLevelBranchCount.size() - 1);
274 if (!PPLevelBranchIndex.empty()) {
275 ++PPLevelBranchIndex.back();
276 assert(PPLevelBranchIndex.size() == PPLevelBranchCount.size());
277 assert(PPLevelBranchIndex.back() <= PPLevelBranchCount.back());
279 }
while (!PPLevelBranchIndex.empty());
282 void UnwrappedLineParser::parseFile() {
285 bool MustBeDeclaration =
287 ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
298 void UnwrappedLineParser::parseLevel(
bool HasOpeningBrace) {
299 bool SwitchLabelEncountered =
false;
302 if (FormatTok->Type == TT_MacroBlockBegin) {
304 }
else if (FormatTok->Type == TT_MacroBlockEnd) {
316 if (!FormatTok->is(TT_MacroBlockBegin) && tryToParseBracedList())
327 case tok::kw_default:
329 if (!SwitchLabelEncountered &&
332 SwitchLabelEncountered =
true;
333 parseStructuralElement();
336 parseStructuralElement();
342 void UnwrappedLineParser::calculateBraceTypes(
bool ExpectClassBody) {
348 FormatToken *Tok = FormatTok;
349 const FormatToken *PrevTok = getPreviousToken();
353 SmallVector<FormatToken *, 8> LBraceStack;
354 assert(Tok->Tok.is(tok::l_brace));
357 FormatToken *NextTok;
358 unsigned ReadTokens = 0;
362 }
while (NextTok->is(tok::comment));
364 switch (Tok->Tok.getKind()) {
367 if (PrevTok->is(tok::colon))
375 else if (PrevTok->is(tok::r_paren))
381 LBraceStack.push_back(Tok);
384 if (LBraceStack.empty())
386 if (LBraceStack.back()->BlockKind ==
BK_Unknown) {
387 bool ProbablyBracedList =
false;
389 ProbablyBracedList = NextTok->isOneOf(tok::comma, tok::r_square);
393 bool NextIsObjCMethod = NextTok->isOneOf(tok::plus, tok::minus) &&
394 NextTok->OriginalColumn == 0;
406 NextTok->isOneOf(Keywords.
kw_of, Keywords.
kw_in,
408 (Style.
isCpp() && NextTok->is(tok::l_paren)) ||
409 NextTok->isOneOf(tok::comma, tok::period, tok::colon,
410 tok::r_paren, tok::r_square, tok::l_brace,
411 tok::l_square, tok::ellipsis) ||
412 (NextTok->is(tok::identifier) &&
413 !PrevTok->isOneOf(tok::semi, tok::r_brace, tok::l_brace)) ||
414 (NextTok->is(tok::semi) &&
415 (!ExpectClassBody || LBraceStack.size() != 1)) ||
416 (NextTok->isBinaryOperator() && !NextIsObjCMethod);
418 if (ProbablyBracedList) {
423 LBraceStack.back()->BlockKind =
BK_Block;
426 LBraceStack.pop_back();
436 if (!LBraceStack.empty() && LBraceStack.back()->BlockKind ==
BK_Unknown)
437 LBraceStack.back()->BlockKind =
BK_Block;
444 }
while (Tok->Tok.isNot(
tok::eof) && !LBraceStack.empty());
447 for (
unsigned i = 0, e = LBraceStack.size(); i != e; ++i) {
449 LBraceStack[i]->BlockKind =
BK_Block;
455 void UnwrappedLineParser::parseBlock(
bool MustBeDeclaration,
bool AddLevel,
457 assert(FormatTok->isOneOf(tok::l_brace, TT_MacroBlockBegin) &&
458 "'{' or macro block token expected");
459 const bool MacroBlock = FormatTok->
is(TT_MacroBlockBegin);
462 unsigned InitialLevel = Line->Level;
465 if (MacroBlock && FormatTok->is(tok::l_paren))
469 size_t OpeningLineIndex = CurrentLines->empty()
471 : (CurrentLines->size() - 1);
473 ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
482 if (MacroBlock ? !FormatTok->is(TT_MacroBlockEnd)
483 : !FormatTok->is(tok::r_brace)) {
484 Line->Level = InitialLevel;
491 if (MacroBlock && FormatTok->is(tok::l_paren))
494 if (MunchSemi && FormatTok->Tok.is(tok::semi))
496 Line->Level = InitialLevel;
497 Line->MatchingOpeningBlockLineIndex = OpeningLineIndex;
500 (*CurrentLines)[OpeningLineIndex].MatchingOpeningBlockLineIndex =
501 CurrentLines->size() - 1;
508 if (Line.
Tokens.size() < 4)
511 if (
I->Tok->TokenText !=
"goog")
514 if (
I->Tok->isNot(tok::period))
517 if (
I->Tok->TokenText !=
"scope")
520 return I->Tok->is(tok::l_paren);
529 if (Line.
Tokens.size() < 3)
532 if (
I->Tok->isNot(tok::l_paren))
538 return I->Tok->is(tok::l_paren);
543 if (InitialToken.
is(tok::kw_namespace))
545 if (InitialToken.
is(tok::kw_class))
547 if (InitialToken.
is(tok::kw_union))
549 if (InitialToken.
is(tok::kw_struct))
554 void UnwrappedLineParser::parseChildBlock() {
562 ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
564 Line->Level += SkipIndent ? 0 : 1;
566 flushComments(isOnNewLine(*FormatTok));
567 Line->Level -= SkipIndent ? 0 : 1;
572 void UnwrappedLineParser::parsePPDirective() {
573 assert(FormatTok->Tok.is(tok::hash) &&
"'#' expected");
574 ScopedMacroState MacroState(*Line, Tokens, FormatTok);
577 if (!FormatTok->Tok.getIdentifierInfo()) {
582 switch (FormatTok->Tok.getIdentifierInfo()->getPPKeywordID()) {
608 void UnwrappedLineParser::conditionalCompilationCondition(
bool Unreachable) {
609 if (Unreachable || (!PPStack.empty() && PPStack.back() == PP_Unreachable))
610 PPStack.push_back(PP_Unreachable);
612 PPStack.push_back(PP_Conditional);
615 void UnwrappedLineParser::conditionalCompilationStart(
bool Unreachable) {
617 assert(PPBranchLevel >= 0 && PPBranchLevel <= (
int)PPLevelBranchIndex.size());
618 if (PPBranchLevel == (
int)PPLevelBranchIndex.size()) {
619 PPLevelBranchIndex.push_back(0);
620 PPLevelBranchCount.push_back(0);
622 PPChainBranchIndex.push(0);
623 bool Skip = PPLevelBranchIndex[PPBranchLevel] > 0;
624 conditionalCompilationCondition(Unreachable || Skip);
627 void UnwrappedLineParser::conditionalCompilationAlternative() {
628 if (!PPStack.empty())
630 assert(PPBranchLevel < (
int)PPLevelBranchIndex.size());
631 if (!PPChainBranchIndex.empty())
632 ++PPChainBranchIndex.top();
633 conditionalCompilationCondition(
634 PPBranchLevel >= 0 && !PPChainBranchIndex.empty() &&
635 PPLevelBranchIndex[PPBranchLevel] != PPChainBranchIndex.top());
638 void UnwrappedLineParser::conditionalCompilationEnd() {
639 assert(PPBranchLevel < (
int)PPLevelBranchIndex.size());
640 if (PPBranchLevel >= 0 && !PPChainBranchIndex.empty()) {
641 if (PPChainBranchIndex.top() + 1 > PPLevelBranchCount[PPBranchLevel]) {
642 PPLevelBranchCount[PPBranchLevel] = PPChainBranchIndex.top() + 1;
646 if (PPBranchLevel > 0)
648 if (!PPChainBranchIndex.empty())
649 PPChainBranchIndex.pop();
650 if (!PPStack.empty())
654 void UnwrappedLineParser::parsePPIf(
bool IfDef) {
655 bool IfNDef = FormatTok->is(tok::pp_ifndef);
657 bool Unreachable =
false;
658 if (!IfDef && (FormatTok->is(tok::kw_false) || FormatTok->TokenText ==
"0"))
660 if (IfDef && !IfNDef && FormatTok->TokenText ==
"SWIG")
662 conditionalCompilationStart(Unreachable);
666 void UnwrappedLineParser::parsePPElse() {
667 conditionalCompilationAlternative();
671 void UnwrappedLineParser::parsePPElIf() { parsePPElse(); }
673 void UnwrappedLineParser::parsePPEndIf() {
674 conditionalCompilationEnd();
678 void UnwrappedLineParser::parsePPDefine() {
681 if (FormatTok->Tok.getKind() != tok::identifier) {
686 if (FormatTok->Tok.getKind() == tok::l_paren &&
687 FormatTok->WhitespaceRange.getBegin() ==
688 FormatTok->WhitespaceRange.getEnd()) {
702 void UnwrappedLineParser::parsePPUnknown() {
715 return Tok.
isNot(tok::semi) && Tok.
isNot(tok::l_brace) &&
716 Tok.
isNot(tok::l_square) &&
719 Tok.
isNot(tok::period) && Tok.
isNot(tok::periodstar) &&
720 Tok.
isNot(tok::arrow) && Tok.
isNot(tok::arrowstar) &&
721 Tok.
isNot(tok::less) && Tok.
isNot(tok::greater) &&
722 Tok.
isNot(tok::slash) && Tok.
isNot(tok::percent) &&
723 Tok.
isNot(tok::lessless) && Tok.
isNot(tok::greatergreater) &&
724 Tok.
isNot(tok::equal) && Tok.
isNot(tok::plusequal) &&
725 Tok.
isNot(tok::minusequal) && Tok.
isNot(tok::starequal) &&
726 Tok.
isNot(tok::slashequal) && Tok.
isNot(tok::percentequal) &&
727 Tok.
isNot(tok::ampequal) && Tok.
isNot(tok::pipeequal) &&
728 Tok.
isNot(tok::caretequal) && Tok.
isNot(tok::greatergreaterequal) &&
729 Tok.
isNot(tok::lesslessequal) &&
733 Tok.
isNot(tok::colon) &&
735 Tok.
isNot(tok::kw_noexcept);
741 return FormatTok->
is(tok::identifier) &&
756 FormatTok->
isOneOf(tok::kw_true, tok::kw_false) ||
767 tok::kw_if, tok::kw_else,
769 tok::kw_for, tok::kw_while, tok::kw_do, tok::kw_continue, tok::kw_break,
771 tok::kw_switch, tok::kw_case,
773 tok::kw_throw, tok::kw_try, tok::kw_catch, Keywords.
kw_finally,
775 tok::kw_const, tok::kw_class, Keywords.
kw_var, Keywords.
kw_let,
788 void UnwrappedLineParser::readTokenWithJavaScriptASI() {
789 FormatToken *Previous = FormatTok;
791 FormatToken *
Next = FormatTok;
794 CommentsBeforeNextToken.empty()
795 ? Next->NewlinesBefore == 0
796 : CommentsBeforeNextToken.front()->NewlinesBefore == 0;
801 bool PreviousStartsTemplateExpr =
802 Previous->is(TT_TemplateString) && Previous->TokenText.endswith(
"${");
803 if (PreviousMustBeValue && Line && Line->Tokens.size() > 1) {
806 const FormatToken *PrePrevious = std::prev(Line->Tokens.end(), 2)->Tok;
807 if (PrePrevious->is(tok::at))
810 if (Next->is(tok::exclaim) && PreviousMustBeValue)
811 return addUnwrappedLine();
813 bool NextEndsTemplateExpr =
814 Next->is(TT_TemplateString) && Next->TokenText.startswith(
"}");
815 if (NextMustBeValue && !NextEndsTemplateExpr && !PreviousStartsTemplateExpr &&
816 (PreviousMustBeValue ||
817 Previous->isOneOf(tok::r_square, tok::r_paren, tok::plusplus,
819 return addUnwrappedLine();
821 return addUnwrappedLine();
824 void UnwrappedLineParser::parseStructuralElement() {
825 assert(!FormatTok->is(tok::l_brace));
827 FormatTok->is(tok::pp_include)) {
829 if (FormatTok->is(tok::string_literal))
834 switch (FormatTok->Tok.getKind()) {
837 if (FormatTok->Tok.is(tok::l_brace)) {
842 switch (FormatTok->Tok.getObjCKeywordID()) {
843 case tok::objc_public:
844 case tok::objc_protected:
845 case tok::objc_package:
846 case tok::objc_private:
847 return parseAccessSpecifier();
848 case tok::objc_interface:
849 case tok::objc_implementation:
850 return parseObjCInterfaceOrImplementation();
851 case tok::objc_protocol:
852 return parseObjCProtocol();
855 case tok::objc_optional:
856 case tok::objc_required:
860 case tok::objc_autoreleasepool:
862 if (FormatTok->Tok.is(tok::l_brace)) {
880 if (FormatTok->is(tok::l_brace)) {
881 FormatTok->Type = TT_InlineASMBrace;
883 while (FormatTok && FormatTok->isNot(
tok::eof)) {
884 if (FormatTok->is(tok::r_brace)) {
885 FormatTok->Type = TT_InlineASMBrace;
890 FormatTok->Finalized =
true;
895 case tok::kw_namespace:
900 if (FormatTok->Tok.is(tok::kw_namespace)) {
906 case tok::kw_protected:
907 case tok::kw_private:
912 parseAccessSpecifier();
919 parseForOrWhileLoop();
927 case tok::kw_default:
940 if (FormatTok->Tok.is(tok::string_literal)) {
942 if (FormatTok->Tok.is(tok::l_brace)) {
943 parseBlock(
true,
false);
951 parseJavaScriptEs6ImportExport();
955 case tok::identifier:
956 if (FormatTok->is(TT_ForEachMacro)) {
957 parseForOrWhileLoop();
960 if (FormatTok->is(TT_MacroBlockBegin)) {
961 parseBlock(
false,
true,
967 parseJavaScriptEs6ImportExport();
972 if (FormatTok->is(tok::kw_public))
974 if (!FormatTok->is(tok::string_literal))
977 if (FormatTok->is(tok::semi))
987 if (FormatTok->is(tok::colon)) {
999 const FormatToken *Previous = getPreviousToken();
1000 switch (FormatTok->Tok.getKind()) {
1003 if (FormatTok->Tok.is(tok::l_brace)) {
1010 if (Previous && Previous->is(tok::less)) {
1020 if (!Style.
isCpp()) {
1025 case tok::kw_typedef:
1031 case tok::kw_struct:
1040 if (FormatTok->is(tok::semi))
1050 FormatTok->is(tok::kw_class))
1053 FormatTok->Tok.getIdentifierInfo())
1068 case tok::kw_operator:
1070 if (FormatTok->isBinaryOperator())
1075 if (FormatTok->Tok.isAnyIdentifier() ||
1076 FormatTok->isSimpleTypeSpecifier())
1078 if (FormatTok->is(tok::l_paren))
1080 if (FormatTok->is(tok::l_brace))
1084 if (!tryToParseBracedList()) {
1091 FormatTok->Type = TT_FunctionLBrace;
1103 case tok::identifier: {
1104 if (FormatTok->is(TT_MacroBlockEnd)) {
1113 size_t TokenCount = Line->Tokens.size();
1116 (TokenCount > 1 || (TokenCount == 1 && !Line->Tokens.front().Tok->is(
1118 tryToParseJSFunction();
1143 StringRef
Text = FormatTok->TokenText;
1145 if (Line->Tokens.size() == 1 &&
1149 if (FormatTok->Tok.is(tok::colon) && !Line->MustBeDeclaration) {
1150 Line->Tokens.begin()->Tok->MustBreakBefore =
true;
1156 bool FunctionLike = FormatTok->is(tok::l_paren);
1160 bool FollowedByNewline =
1161 CommentsBeforeNextToken.empty()
1162 ? FormatTok->NewlinesBefore > 0
1163 : CommentsBeforeNextToken.front()->NewlinesBefore > 0;
1165 if (FollowedByNewline && (Text.size() >= 5 || FunctionLike) &&
1177 if (FormatTok->is(TT_JsFatArrow)) {
1179 if (FormatTok->is(tok::l_brace))
1185 if (FormatTok->Tok.is(tok::l_brace)) {
1189 FormatTok->Tok.is(tok::less)) {
1191 parseBracedList(
false,
1208 bool UnwrappedLineParser::tryToParseLambda() {
1209 if (!Style.
isCpp()) {
1213 const FormatToken* Previous = getPreviousToken();
1215 (Previous->isOneOf(tok::identifier, tok::kw_operator, tok::kw_new,
1217 Previous->closesScope() || Previous->isSimpleTypeSpecifier())) {
1221 assert(FormatTok->is(tok::l_square));
1222 FormatToken &LSquare = *FormatTok;
1223 if (!tryToParseLambdaIntroducer())
1226 while (FormatTok->isNot(tok::l_brace)) {
1227 if (FormatTok->isSimpleTypeSpecifier()) {
1231 switch (FormatTok->Tok.getKind()) {
1243 case tok::identifier:
1244 case tok::numeric_constant:
1245 case tok::coloncolon:
1246 case tok::kw_mutable:
1250 FormatTok->Type = TT_LambdaArrow;
1257 LSquare.Type = TT_LambdaLSquare;
1262 bool UnwrappedLineParser::tryToParseLambdaIntroducer() {
1264 if (FormatTok->is(tok::equal)) {
1266 if (FormatTok->is(tok::r_square)) {
1270 if (FormatTok->isNot(tok::comma))
1273 }
else if (FormatTok->is(tok::amp)) {
1275 if (FormatTok->is(tok::r_square)) {
1279 if (!FormatTok->isOneOf(tok::comma, tok::identifier)) {
1282 if (FormatTok->is(tok::comma))
1284 }
else if (FormatTok->is(tok::r_square)) {
1289 if (FormatTok->is(tok::amp))
1291 if (!FormatTok->isOneOf(tok::identifier, tok::kw_this))
1294 if (FormatTok->is(tok::ellipsis))
1296 if (FormatTok->is(tok::comma)) {
1298 }
else if (FormatTok->is(tok::r_square)) {
1308 void UnwrappedLineParser::tryToParseJSFunction() {
1311 if (FormatTok->is(Keywords.
kw_async))
1317 if (FormatTok->is(tok::star)) {
1318 FormatTok->Type = TT_OverloadedOperator;
1323 if (FormatTok->is(tok::identifier))
1326 if (FormatTok->isNot(tok::l_paren))
1332 if (FormatTok->is(tok::colon)) {
1338 if (FormatTok->is(tok::l_brace))
1339 tryToParseBracedList();
1341 while (!FormatTok->isOneOf(tok::l_brace, tok::semi) && !eof())
1345 if (FormatTok->is(tok::semi))
1351 bool UnwrappedLineParser::tryToParseBracedList() {
1353 calculateBraceTypes();
1355 if (FormatTok->BlockKind ==
BK_Block)
1362 bool UnwrappedLineParser::parseBracedList(
bool ContinueOnSemicolons,
1364 bool HasError =
false;
1372 tryToParseJSFunction();
1375 if (FormatTok->is(TT_JsFatArrow)) {
1379 if (FormatTok->is(tok::l_brace)) {
1384 if (FormatTok->is(tok::l_brace)) {
1386 if (tryToParseBracedList())
1391 if (FormatTok->Tok.getKind() == ClosingBraceKind) {
1395 switch (FormatTok->Tok.getKind()) {
1398 if (FormatTok->is(tok::l_brace)) {
1410 if (FormatTok->is(tok::l_brace))
1432 if (!ContinueOnSemicolons)
1447 void UnwrappedLineParser::parseParens() {
1448 assert(FormatTok->Tok.is(tok::l_paren) &&
"'(' expected.");
1451 switch (FormatTok->Tok.getKind()) {
1467 if (!tryToParseBracedList())
1472 if (FormatTok->Tok.is(tok::l_brace)) {
1483 case tok::identifier:
1487 tryToParseJSFunction();
1498 void UnwrappedLineParser::parseSquare() {
1499 assert(FormatTok->Tok.is(tok::l_square) &&
"'[' expected.");
1500 if (tryToParseLambda())
1503 switch (FormatTok->Tok.getKind()) {
1516 case tok::l_brace: {
1517 if (!tryToParseBracedList())
1523 if (FormatTok->Tok.is(tok::l_brace)) {
1535 void UnwrappedLineParser::parseIfThenElse() {
1536 assert(FormatTok->Tok.is(tok::kw_if) &&
"'if' expected");
1538 if (FormatTok->Tok.is(tok::kw_constexpr))
1540 if (FormatTok->Tok.is(tok::l_paren))
1542 bool NeedsUnwrappedLine =
false;
1543 if (FormatTok->Tok.is(tok::l_brace)) {
1549 NeedsUnwrappedLine =
true;
1553 parseStructuralElement();
1556 if (FormatTok->Tok.is(tok::kw_else)) {
1558 if (FormatTok->Tok.is(tok::l_brace)) {
1562 }
else if (FormatTok->Tok.is(tok::kw_if)) {
1567 parseStructuralElement();
1572 }
else if (NeedsUnwrappedLine) {
1577 void UnwrappedLineParser::parseTryCatch() {
1578 assert(FormatTok->isOneOf(tok::kw_try, tok::kw___try) &&
"'try' expected");
1580 bool NeedsUnwrappedLine =
false;
1581 if (FormatTok->is(tok::colon)) {
1584 while (FormatTok->is(tok::identifier)) {
1586 if (FormatTok->is(tok::l_paren))
1588 if (FormatTok->is(tok::comma))
1596 if (FormatTok->is(tok::l_brace)) {
1602 NeedsUnwrappedLine =
true;
1604 }
else if (!FormatTok->is(tok::kw_catch)) {
1610 parseStructuralElement();
1614 if (FormatTok->is(tok::at))
1616 if (!(FormatTok->isOneOf(tok::kw_catch, Keywords.
kw___except,
1617 tok::kw___finally) ||
1621 (FormatTok->Tok.isObjCAtKeyword(tok::objc_catch) ||
1622 FormatTok->Tok.isObjCAtKeyword(tok::objc_finally))))
1625 while (FormatTok->isNot(tok::l_brace)) {
1626 if (FormatTok->is(tok::l_paren)) {
1630 if (FormatTok->isOneOf(tok::semi, tok::r_brace,
tok::eof))
1634 NeedsUnwrappedLine =
false;
1640 NeedsUnwrappedLine =
true;
1642 if (NeedsUnwrappedLine)
1646 void UnwrappedLineParser::parseNamespace() {
1647 assert(FormatTok->Tok.is(tok::kw_namespace) &&
"'namespace' expected");
1649 const FormatToken &InitialToken = *FormatTok;
1651 while (FormatTok->isOneOf(tok::identifier, tok::coloncolon))
1653 if (FormatTok->Tok.is(tok::l_brace)) {
1659 DeclarationScopeStack.size() > 1);
1660 parseBlock(
true, AddLevel);
1663 if (FormatTok->Tok.is(tok::semi))
1670 void UnwrappedLineParser::parseNew() {
1671 assert(FormatTok->is(tok::kw_new) &&
"'new' expected");
1679 if (FormatTok->isOneOf(tok::semi, tok::l_brace, tok::r_brace))
1683 if (FormatTok->is(tok::l_paren)) {
1687 if (FormatTok->is(tok::l_brace))
1695 void UnwrappedLineParser::parseForOrWhileLoop() {
1696 assert(FormatTok->isOneOf(tok::kw_for, tok::kw_while, TT_ForEachMacro) &&
1697 "'for', 'while' or foreach macro expected");
1703 if (FormatTok->Tok.is(tok::l_paren))
1705 if (FormatTok->Tok.is(tok::l_brace)) {
1712 parseStructuralElement();
1717 void UnwrappedLineParser::parseDoWhile() {
1718 assert(FormatTok->Tok.is(tok::kw_do) &&
"'do' expected");
1720 if (FormatTok->Tok.is(tok::l_brace)) {
1728 parseStructuralElement();
1733 if (!FormatTok->Tok.is(tok::kw_while)) {
1739 parseStructuralElement();
1742 void UnwrappedLineParser::parseLabel() {
1744 unsigned OldLineLevel = Line->Level;
1745 if (Line->Level > 1 || (!Line->InPPDirective && Line->Level > 0))
1747 if (CommentsBeforeNextToken.empty() && FormatTok->Tok.is(tok::l_brace)) {
1750 if (FormatTok->Tok.is(tok::kw_break)) {
1753 parseStructuralElement();
1757 if (FormatTok->is(tok::semi))
1761 Line->Level = OldLineLevel;
1762 if (FormatTok->isNot(tok::l_brace)) {
1763 parseStructuralElement();
1768 void UnwrappedLineParser::parseCaseLabel() {
1769 assert(FormatTok->Tok.is(tok::kw_case) &&
"'case' expected");
1773 }
while (!eof() && !FormatTok->Tok.is(tok::colon));
1777 void UnwrappedLineParser::parseSwitch() {
1778 assert(FormatTok->Tok.is(tok::kw_switch) &&
"'switch' expected");
1780 if (FormatTok->Tok.is(tok::l_paren))
1782 if (FormatTok->Tok.is(tok::l_brace)) {
1789 parseStructuralElement();
1794 void UnwrappedLineParser::parseAccessSpecifier() {
1800 if (FormatTok->Tok.is(tok::colon))
1805 bool UnwrappedLineParser::parseEnum() {
1807 if (FormatTok->Tok.is(tok::kw_enum))
1814 FormatTok->isOneOf(tok::colon, tok::question))
1818 if (FormatTok->Tok.is(tok::kw_class) || FormatTok->Tok.is(tok::kw_struct))
1821 while (FormatTok->Tok.getIdentifierInfo() ||
1822 FormatTok->isOneOf(tok::colon, tok::coloncolon, tok::less,
1823 tok::greater, tok::comma, tok::question)) {
1826 if (FormatTok->is(tok::l_paren))
1828 if (FormatTok->is(tok::identifier)) {
1832 if (Style.
isCpp() && FormatTok->is(tok::identifier))
1838 if (FormatTok->isNot(tok::l_brace))
1844 parseJavaEnumBody();
1854 bool HasError = !parseBracedList(
true);
1856 if (FormatTok->is(tok::semi))
1867 void UnwrappedLineParser::parseJavaEnumBody() {
1872 bool IsSimple =
true;
1875 if (Tok->is(tok::r_brace))
1877 if (Tok->isOneOf(tok::l_brace, tok::semi)) {
1902 if (FormatTok->is(tok::l_brace)) {
1904 parseBlock(
true,
true,
1906 }
else if (FormatTok->is(tok::l_paren)) {
1908 }
else if (FormatTok->is(tok::comma)) {
1911 }
else if (FormatTok->is(tok::semi)) {
1915 }
else if (FormatTok->is(tok::r_brace)) {
1930 void UnwrappedLineParser::parseRecord(
bool ParseAsExpr) {
1931 const FormatToken &InitialToken = *FormatTok;
1936 while (FormatTok->isOneOf(tok::identifier, tok::coloncolon, tok::hashhash,
1937 tok::kw___attribute, tok::kw___declspec,
1941 FormatTok->isOneOf(tok::period, tok::comma))) {
1942 bool IsNonMacroIdentifier =
1943 FormatTok->is(tok::identifier) &&
1944 FormatTok->TokenText != FormatTok->TokenText.upper();
1947 if (!IsNonMacroIdentifier && FormatTok->Tok.is(tok::l_paren))
1961 if (FormatTok->isOneOf(tok::colon, tok::less)) {
1963 if (FormatTok->is(tok::l_brace)) {
1964 calculateBraceTypes(
true);
1965 if (!tryToParseBracedList())
1968 if (FormatTok->Tok.is(tok::semi))
1973 if (FormatTok->Tok.is(tok::l_brace)) {
1980 parseBlock(
true,
true,
1989 void UnwrappedLineParser::parseObjCProtocolList() {
1990 assert(FormatTok->Tok.is(tok::less) &&
"'<' expected.");
1993 while (!eof() && FormatTok->Tok.isNot(tok::greater));
1997 void UnwrappedLineParser::parseObjCUntilAtEnd() {
1999 if (FormatTok->Tok.isObjCAtKeyword(tok::objc_end)) {
2004 if (FormatTok->is(tok::l_brace)) {
2008 }
else if (FormatTok->is(tok::r_brace)) {
2013 parseStructuralElement();
2018 void UnwrappedLineParser::parseObjCInterfaceOrImplementation() {
2023 if (FormatTok->Tok.is(tok::colon)) {
2026 }
else if (FormatTok->Tok.is(tok::l_paren))
2030 if (FormatTok->Tok.is(tok::less))
2031 parseObjCProtocolList();
2033 if (FormatTok->Tok.is(tok::l_brace)) {
2043 parseObjCUntilAtEnd();
2046 void UnwrappedLineParser::parseObjCProtocol() {
2050 if (FormatTok->Tok.is(tok::less))
2051 parseObjCProtocolList();
2054 if (FormatTok->Tok.is(tok::semi)) {
2056 return addUnwrappedLine();
2060 parseObjCUntilAtEnd();
2063 void UnwrappedLineParser::parseJavaScriptEs6ImportExport() {
2064 bool IsImport = FormatTok->is(Keywords.
kw_import);
2065 assert(IsImport || FormatTok->is(tok::kw_export));
2069 if (FormatTok->is(tok::kw_default))
2075 if (FormatTok->is(Keywords.
kw_async))
2086 if (!IsImport && !FormatTok->isOneOf(tok::l_brace, tok::star) &&
2087 !FormatTok->isStringLiteral())
2091 if (FormatTok->is(tok::semi))
2093 if (Line->Tokens.size() == 0) {
2098 if (FormatTok->is(tok::l_brace)) {
2109 StringRef Prefix =
"") {
2110 llvm::dbgs() << Prefix <<
"Line(" << Line.
Level <<
")"
2112 for (std::list<UnwrappedLineNode>::const_iterator
I = Line.
Tokens.begin(),
2115 llvm::dbgs() <<
I->Tok->Tok.getName() <<
"["
2116 <<
"T=" <<
I->Tok->Type
2117 <<
", OC=" <<
I->Tok->OriginalColumn <<
"] ";
2119 for (std::list<UnwrappedLineNode>::const_iterator
I = Line.
Tokens.begin(),
2130 llvm::dbgs() <<
"\n";
2133 void UnwrappedLineParser::addUnwrappedLine() {
2134 if (Line->Tokens.empty())
2137 if (CurrentLines == &Lines)
2140 CurrentLines->push_back(std::move(*Line));
2141 Line->Tokens.clear();
2143 if (CurrentLines == &Lines && !PreprocessorDirectives.empty()) {
2144 CurrentLines->append(
2145 std::make_move_iterator(PreprocessorDirectives.begin()),
2146 std::make_move_iterator(PreprocessorDirectives.end()));
2147 PreprocessorDirectives.clear();
2151 bool UnwrappedLineParser::eof()
const {
return FormatTok->Tok.is(
tok::eof); }
2153 bool UnwrappedLineParser::isOnNewLine(
const FormatToken &FormatTok) {
2154 return (Line->InPPDirective || FormatTok.HasUnescapedNewline) &&
2155 FormatTok.NewlinesBefore > 0;
2162 llvm::Regex &CommentPragmasRegex) {
2166 StringRef IndentContent = FormatTok.
TokenText;
2167 if (FormatTok.
TokenText.startswith(
"//") ||
2169 IndentContent = FormatTok.
TokenText.substr(2);
2170 if (CommentPragmasRegex.match(IndentContent))
2245 if (PreviousToken && PreviousToken->
is(tok::l_brace) &&
2246 isLineComment(*Node.
Tok)) {
2250 PreviousToken = Node.
Tok;
2254 MinColumnToken = Node.
Tok;
2257 if (PreviousToken && PreviousToken->
is(tok::l_brace)) {
2261 return continuesLineComment(FormatTok, Line.
Tokens.back().Tok,
2265 void UnwrappedLineParser::flushComments(
bool NewlineBeforeNext) {
2266 bool JustComments = Line->Tokens.empty();
2268 I = CommentsBeforeNextToken.begin(),
2269 E = CommentsBeforeNextToken.end();
2281 if (isOnNewLine(**
I) && JustComments && !(*I)->ContinuesLineCommentSection)
2285 if (NewlineBeforeNext && JustComments)
2287 CommentsBeforeNextToken.clear();
2290 void UnwrappedLineParser::nextToken() {
2293 flushComments(isOnNewLine(*FormatTok));
2294 pushToken(FormatTok);
2298 readTokenWithJavaScriptASI();
2301 const FormatToken *UnwrappedLineParser::getPreviousToken() {
2304 if (!Line || Line->Tokens.empty())
2306 return Line->Tokens.back().Tok;
2309 void UnwrappedLineParser::distributeComments(
2310 const SmallVectorImpl<FormatToken *> &Comments,
2311 const FormatToken *NextTok) {
2330 if (Comments.empty())
2332 bool ShouldPushCommentsInCurrentLine =
true;
2333 bool HasTrailAlignedWithNextToken =
false;
2334 unsigned StartOfTrailAlignedWithNextToken = 0;
2337 for (
unsigned i = Comments.size() - 1; i > 0; --i) {
2338 if (Comments[i]->OriginalColumn == NextTok->OriginalColumn) {
2339 HasTrailAlignedWithNextToken =
true;
2340 StartOfTrailAlignedWithNextToken = i;
2344 for (
unsigned i = 0, e = Comments.size(); i < e; ++i) {
2345 FormatToken *FormatTok = Comments[i];
2346 if (HasTrailAlignedWithNextToken &&
2347 i == StartOfTrailAlignedWithNextToken) {
2348 FormatTok->ContinuesLineCommentSection =
false;
2350 FormatTok->ContinuesLineCommentSection =
2353 if (!FormatTok->ContinuesLineCommentSection &&
2354 (isOnNewLine(*FormatTok) || FormatTok->IsFirst)) {
2355 ShouldPushCommentsInCurrentLine =
false;
2357 if (ShouldPushCommentsInCurrentLine) {
2358 pushToken(FormatTok);
2360 CommentsBeforeNextToken.push_back(FormatTok);
2365 void UnwrappedLineParser::readToken() {
2366 SmallVector<FormatToken *, 1> Comments;
2370 while (!Line->InPPDirective && FormatTok->Tok.is(tok::hash) &&
2371 (FormatTok->HasUnescapedNewline || FormatTok->IsFirst)) {
2372 distributeComments(Comments, FormatTok);
2376 bool SwitchToPreprocessorLines = !Line->Tokens.empty();
2381 flushComments(isOnNewLine(*FormatTok));
2384 while (FormatTok->Type == TT_ConflictStart ||
2385 FormatTok->Type == TT_ConflictEnd ||
2386 FormatTok->Type == TT_ConflictAlternative) {
2387 if (FormatTok->Type == TT_ConflictStart) {
2388 conditionalCompilationStart(
false);
2389 }
else if (FormatTok->Type == TT_ConflictAlternative) {
2390 conditionalCompilationAlternative();
2391 }
else if (FormatTok->Type == TT_ConflictEnd) {
2392 conditionalCompilationEnd();
2398 if (!PPStack.empty() && (PPStack.back() == PP_Unreachable) &&
2399 !Line->InPPDirective) {
2403 if (!FormatTok->Tok.is(tok::comment)) {
2404 distributeComments(Comments, FormatTok);
2409 Comments.push_back(FormatTok);
2412 distributeComments(Comments,
nullptr);
2416 void UnwrappedLineParser::pushToken(FormatToken *Tok) {
2417 Line->Tokens.push_back(UnwrappedLineNode(Tok));
2418 if (MustBreakBeforeNextToken) {
2419 Line->Tokens.back().Tok->MustBreakBefore =
true;
2420 MustBreakBeforeNextToken =
false;
Parser - This implements a parser for the C family of languages.
FormatToken *& ResetToken
Token - This structure provides full information about a lexed token.
detail::InMemoryDirectory::const_iterator I
std::vector< bool > & Stack
FormatTokenSource *& TokenSource
MatchFinder::MatchCallback * Callback
bool isNot(tok::TokenKind K) const
ArrayRef< FormatToken * > Tokens
This file contains the declaration of the UnwrappedLineParser, which turns a stream of tokens into Un...
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
ast_type_traits::DynTypedNode Node
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
detail::InMemoryDirectory::const_iterator E
FormatToken * PreviousToken
bool isLiteral() const
Return true if this is a "literal", like a numeric constant, string, etc.
unsigned kind
All of the diagnostics that can be emitted by the frontend.
unsigned PreviousLineLevel
FormatTokenSource * PreviousTokenSource
IdentifierInfo * getIdentifierInfo() const