1 //===--- UnwrappedLineParser.h - Format C++ code ----------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 /// 9 /// \file 10 /// This file contains the declaration of the UnwrappedLineParser, 11 /// which turns a stream of tokens into UnwrappedLines. 12 /// 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_CLANG_LIB_FORMAT_UNWRAPPEDLINEPARSER_H 16 #define LLVM_CLANG_LIB_FORMAT_UNWRAPPEDLINEPARSER_H 17 18 #include "FormatToken.h" 19 #include "clang/Basic/IdentifierTable.h" 20 #include "clang/Format/Format.h" 21 #include "llvm/ADT/BitVector.h" 22 #include "llvm/Support/Regex.h" 23 #include <list> 24 #include <stack> 25 #include <vector> 26 27 namespace clang { 28 namespace format { 29 30 struct UnwrappedLineNode; 31 32 /// An unwrapped line is a sequence of \c Token, that we would like to 33 /// put on a single line if there was no column limit. 34 /// 35 /// This is used as a main interface between the \c UnwrappedLineParser and the 36 /// \c UnwrappedLineFormatter. The key property is that changing the formatting 37 /// within an unwrapped line does not affect any other unwrapped lines. 38 struct UnwrappedLine { 39 UnwrappedLine(); 40 41 /// The \c Tokens comprising this \c UnwrappedLine. 42 std::list<UnwrappedLineNode> Tokens; 43 44 /// The indent level of the \c UnwrappedLine. 45 unsigned Level; 46 47 /// The \c PPBranchLevel (adjusted for header guards) if this line is a 48 /// \c InMacroBody line, and 0 otherwise. 49 unsigned PPLevel; 50 51 /// Whether this \c UnwrappedLine is part of a preprocessor directive. 52 bool InPPDirective; 53 /// Whether this \c UnwrappedLine is part of a pramga directive. 54 bool InPragmaDirective; 55 /// Whether it is part of a macro body. 56 bool InMacroBody; 57 58 bool MustBeDeclaration; 59 60 /// \c True if this line should be indented by ContinuationIndent in 61 /// addition to the normal indention level. 62 bool IsContinuation = false; 63 64 /// If this \c UnwrappedLine closes a block in a sequence of lines, 65 /// \c MatchingOpeningBlockLineIndex stores the index of the corresponding 66 /// opening line. Otherwise, \c MatchingOpeningBlockLineIndex must be 67 /// \c kInvalidIndex. 68 size_t MatchingOpeningBlockLineIndex = kInvalidIndex; 69 70 /// If this \c UnwrappedLine opens a block, stores the index of the 71 /// line with the corresponding closing brace. 72 size_t MatchingClosingBlockLineIndex = kInvalidIndex; 73 74 static const size_t kInvalidIndex = -1; 75 76 unsigned FirstStartColumn = 0; 77 }; 78 79 class UnwrappedLineConsumer { 80 public: 81 virtual ~UnwrappedLineConsumer() {} 82 virtual void consumeUnwrappedLine(const UnwrappedLine &Line) = 0; 83 virtual void finishRun() = 0; 84 }; 85 86 class FormatTokenSource; 87 88 class UnwrappedLineParser { 89 public: 90 UnwrappedLineParser(const FormatStyle &Style, 91 const AdditionalKeywords &Keywords, 92 unsigned FirstStartColumn, ArrayRef<FormatToken *> Tokens, 93 UnwrappedLineConsumer &Callback); 94 95 void parse(); 96 97 private: 98 enum class IfStmtKind { 99 NotIf, // Not an if statement. 100 IfOnly, // An if statement without the else clause. 101 IfElse, // An if statement followed by else but not else if. 102 IfElseIf // An if statement followed by else if. 103 }; 104 105 void reset(); 106 void parseFile(); 107 bool precededByCommentOrPPDirective() const; 108 bool parseLevel(const FormatToken *OpeningBrace = nullptr, 109 bool CanContainBracedList = true, 110 TokenType NextLBracesType = TT_Unknown, 111 IfStmtKind *IfKind = nullptr, 112 FormatToken **IfLeftBrace = nullptr); 113 bool mightFitOnOneLine(UnwrappedLine &Line, 114 const FormatToken *OpeningBrace = nullptr) const; 115 FormatToken *parseBlock(bool MustBeDeclaration = false, 116 unsigned AddLevels = 1u, bool MunchSemi = true, 117 bool KeepBraces = true, IfStmtKind *IfKind = nullptr, 118 bool UnindentWhitesmithsBraces = false, 119 bool CanContainBracedList = true, 120 TokenType NextLBracesType = TT_Unknown); 121 void parseChildBlock(bool CanContainBracedList = true, 122 TokenType NextLBracesType = TT_Unknown); 123 void parsePPDirective(); 124 void parsePPDefine(); 125 void parsePPIf(bool IfDef); 126 void parsePPElse(); 127 void parsePPEndIf(); 128 void parsePPPragma(); 129 void parsePPUnknown(); 130 void readTokenWithJavaScriptASI(); 131 void parseStructuralElement(bool IsTopLevel = false, 132 TokenType NextLBracesType = TT_Unknown, 133 IfStmtKind *IfKind = nullptr, 134 FormatToken **IfLeftBrace = nullptr, 135 bool *HasDoWhile = nullptr, 136 bool *HasLabel = nullptr); 137 bool tryToParseBracedList(); 138 bool parseBracedList(bool ContinueOnSemicolons = false, bool IsEnum = false, 139 tok::TokenKind ClosingBraceKind = tok::r_brace); 140 void parseParens(TokenType AmpAmpTokenType = TT_Unknown); 141 void parseSquare(bool LambdaIntroducer = false); 142 void keepAncestorBraces(); 143 void parseUnbracedBody(bool CheckEOF = false); 144 void handleAttributes(); 145 bool handleCppAttributes(); 146 bool isBlockBegin(const FormatToken &Tok) const; 147 FormatToken *parseIfThenElse(IfStmtKind *IfKind, bool KeepBraces = false); 148 void parseTryCatch(); 149 void parseLoopBody(bool KeepBraces, bool WrapRightBrace); 150 void parseForOrWhileLoop(); 151 void parseDoWhile(); 152 void parseLabel(bool LeftAlignLabel = false); 153 void parseCaseLabel(); 154 void parseSwitch(); 155 void parseNamespace(); 156 bool parseModuleImport(); 157 void parseNew(); 158 void parseAccessSpecifier(); 159 bool parseEnum(); 160 bool parseStructLike(); 161 bool parseRequires(); 162 void parseRequiresClause(FormatToken *RequiresToken); 163 void parseRequiresExpression(FormatToken *RequiresToken); 164 void parseConstraintExpression(); 165 void parseJavaEnumBody(); 166 // Parses a record (aka class) as a top level element. If ParseAsExpr is true, 167 // parses the record as a child block, i.e. if the class declaration is an 168 // expression. 169 void parseRecord(bool ParseAsExpr = false); 170 void parseObjCLightweightGenerics(); 171 void parseObjCMethod(); 172 void parseObjCProtocolList(); 173 void parseObjCUntilAtEnd(); 174 void parseObjCInterfaceOrImplementation(); 175 bool parseObjCProtocol(); 176 void parseJavaScriptEs6ImportExport(); 177 void parseStatementMacro(); 178 void parseCSharpAttribute(); 179 // Parse a C# generic type constraint: `where T : IComparable<T>`. 180 // See: 181 // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/where-generic-type-constraint 182 void parseCSharpGenericTypeConstraint(); 183 bool tryToParseLambda(); 184 bool tryToParseChildBlock(); 185 bool tryToParseLambdaIntroducer(); 186 bool tryToParsePropertyAccessor(); 187 void tryToParseJSFunction(); 188 bool tryToParseSimpleAttribute(); 189 void parseVerilogHierarchyIdentifier(); 190 void parseVerilogSensitivityList(); 191 // Returns the number of levels of indentation in addition to the normal 1 192 // level for a block, used for indenting case labels. 193 unsigned parseVerilogHierarchyHeader(); 194 void parseVerilogTable(); 195 void parseVerilogCaseLabel(); 196 197 // Used by addUnwrappedLine to denote whether to keep or remove a level 198 // when resetting the line state. 199 enum class LineLevel { Remove, Keep }; 200 201 void addUnwrappedLine(LineLevel AdjustLevel = LineLevel::Remove); 202 bool eof() const; 203 // LevelDifference is the difference of levels after and before the current 204 // token. For example: 205 // - if the token is '{' and opens a block, LevelDifference is 1. 206 // - if the token is '}' and closes a block, LevelDifference is -1. 207 void nextToken(int LevelDifference = 0); 208 void readToken(int LevelDifference = 0); 209 210 // Decides which comment tokens should be added to the current line and which 211 // should be added as comments before the next token. 212 // 213 // Comments specifies the sequence of comment tokens to analyze. They get 214 // either pushed to the current line or added to the comments before the next 215 // token. 216 // 217 // NextTok specifies the next token. A null pointer NextTok is supported, and 218 // signifies either the absence of a next token, or that the next token 219 // shouldn't be taken into account for the analysis. 220 void distributeComments(const SmallVectorImpl<FormatToken *> &Comments, 221 const FormatToken *NextTok); 222 223 // Adds the comment preceding the next token to unwrapped lines. 224 void flushComments(bool NewlineBeforeNext); 225 void pushToken(FormatToken *Tok); 226 void calculateBraceTypes(bool ExpectClassBody = false); 227 228 // Marks a conditional compilation edge (for example, an '#if', '#ifdef', 229 // '#else' or merge conflict marker). If 'Unreachable' is true, assumes 230 // this branch either cannot be taken (for example '#if false'), or should 231 // not be taken in this round. 232 void conditionalCompilationCondition(bool Unreachable); 233 void conditionalCompilationStart(bool Unreachable); 234 void conditionalCompilationAlternative(); 235 void conditionalCompilationEnd(); 236 237 bool isOnNewLine(const FormatToken &FormatTok); 238 239 // Compute hash of the current preprocessor branch. 240 // This is used to identify the different branches, and thus track if block 241 // open and close in the same branch. 242 size_t computePPHash() const; 243 244 // FIXME: We are constantly running into bugs where Line.Level is incorrectly 245 // subtracted from beyond 0. Introduce a method to subtract from Line.Level 246 // and use that everywhere in the Parser. 247 std::unique_ptr<UnwrappedLine> Line; 248 249 // Comments are sorted into unwrapped lines by whether they are in the same 250 // line as the previous token, or not. If not, they belong to the next token. 251 // Since the next token might already be in a new unwrapped line, we need to 252 // store the comments belonging to that token. 253 SmallVector<FormatToken *, 1> CommentsBeforeNextToken; 254 FormatToken *FormatTok; 255 bool MustBreakBeforeNextToken; 256 257 // The parsed lines. Only added to through \c CurrentLines. 258 SmallVector<UnwrappedLine, 8> Lines; 259 260 // Preprocessor directives are parsed out-of-order from other unwrapped lines. 261 // Thus, we need to keep a list of preprocessor directives to be reported 262 // after an unwrapped line that has been started was finished. 263 SmallVector<UnwrappedLine, 4> PreprocessorDirectives; 264 265 // New unwrapped lines are added via CurrentLines. 266 // Usually points to \c &Lines. While parsing a preprocessor directive when 267 // there is an unfinished previous unwrapped line, will point to 268 // \c &PreprocessorDirectives. 269 SmallVectorImpl<UnwrappedLine> *CurrentLines; 270 271 // We store for each line whether it must be a declaration depending on 272 // whether we are in a compound statement or not. 273 llvm::BitVector DeclarationScopeStack; 274 275 const FormatStyle &Style; 276 const AdditionalKeywords &Keywords; 277 278 llvm::Regex CommentPragmasRegex; 279 280 FormatTokenSource *Tokens; 281 UnwrappedLineConsumer &Callback; 282 283 // FIXME: This is a temporary measure until we have reworked the ownership 284 // of the format tokens. The goal is to have the actual tokens created and 285 // owned outside of and handed into the UnwrappedLineParser. 286 ArrayRef<FormatToken *> AllTokens; 287 288 // Keeps a stack of the states of nested control statements (true if the 289 // statement contains more than some predefined number of nested statements). 290 SmallVector<bool, 8> NestedTooDeep; 291 292 // Represents preprocessor branch type, so we can find matching 293 // #if/#else/#endif directives. 294 enum PPBranchKind { 295 PP_Conditional, // Any #if, #ifdef, #ifndef, #elif, block outside #if 0 296 PP_Unreachable // #if 0 or a conditional preprocessor block inside #if 0 297 }; 298 299 struct PPBranch { 300 PPBranch(PPBranchKind Kind, size_t Line) : Kind(Kind), Line(Line) {} 301 PPBranchKind Kind; 302 size_t Line; 303 }; 304 305 // Keeps a stack of currently active preprocessor branching directives. 306 SmallVector<PPBranch, 16> PPStack; 307 308 // The \c UnwrappedLineParser re-parses the code for each combination 309 // of preprocessor branches that can be taken. 310 // To that end, we take the same branch (#if, #else, or one of the #elif 311 // branches) for each nesting level of preprocessor branches. 312 // \c PPBranchLevel stores the current nesting level of preprocessor 313 // branches during one pass over the code. 314 int PPBranchLevel; 315 316 // Contains the current branch (#if, #else or one of the #elif branches) 317 // for each nesting level. 318 SmallVector<int, 8> PPLevelBranchIndex; 319 320 // Contains the maximum number of branches at each nesting level. 321 SmallVector<int, 8> PPLevelBranchCount; 322 323 // Contains the number of branches per nesting level we are currently 324 // in while parsing a preprocessor branch sequence. 325 // This is used to update PPLevelBranchCount at the end of a branch 326 // sequence. 327 std::stack<int> PPChainBranchIndex; 328 329 // Include guard search state. Used to fixup preprocessor indent levels 330 // so that include guards do not participate in indentation. 331 enum IncludeGuardState { 332 IG_Inited, // Search started, looking for #ifndef. 333 IG_IfNdefed, // #ifndef found, IncludeGuardToken points to condition. 334 IG_Defined, // Matching #define found, checking other requirements. 335 IG_Found, // All requirements met, need to fix indents. 336 IG_Rejected, // Search failed or never started. 337 }; 338 339 // Current state of include guard search. 340 IncludeGuardState IncludeGuard; 341 342 // Points to the #ifndef condition for a potential include guard. Null unless 343 // IncludeGuardState == IG_IfNdefed. 344 FormatToken *IncludeGuardToken; 345 346 // Contains the first start column where the source begins. This is zero for 347 // normal source code and may be nonzero when formatting a code fragment that 348 // does not start at the beginning of the file. 349 unsigned FirstStartColumn; 350 351 friend class ScopedLineState; 352 friend class CompoundStatementIndenter; 353 }; 354 355 struct UnwrappedLineNode { 356 UnwrappedLineNode() : Tok(nullptr) {} 357 UnwrappedLineNode(FormatToken *Tok) : Tok(Tok) {} 358 359 FormatToken *Tok; 360 SmallVector<UnwrappedLine, 0> Children; 361 }; 362 363 inline UnwrappedLine::UnwrappedLine() 364 : Level(0), PPLevel(0), InPPDirective(false), InPragmaDirective(false), 365 InMacroBody(false), MustBeDeclaration(false), 366 MatchingOpeningBlockLineIndex(kInvalidIndex) {} 367 368 } // end namespace format 369 } // end namespace clang 370 371 #endif 372