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