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:
~UnwrappedLineConsumer()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 {
PPBranchPPBranch244 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 {
UnwrappedLineNodeUnwrappedLineNode300 UnwrappedLineNode() : Tok(nullptr) {}
UnwrappedLineNodeUnwrappedLineNode301 UnwrappedLineNode(FormatToken *Tok) : Tok(Tok) {}
302
303 FormatToken *Tok;
304 SmallVector<UnwrappedLine, 0> Children;
305 };
306
UnwrappedLine()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