Debian Codegraph @

llvm-project/clang/lib/Format/TokenAnnotator.h

raw
1 //===--- TokenAnnotator.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 implements a token annotator, i.e. creates
11 /// \c AnnotatedTokens out of \c FormatTokens with required extra information.
12 ///
13 //===----------------------------------------------------------------------===//
14
15 #ifndef LLVM_CLANG_LIB_FORMAT_TOKENANNOTATOR_H
16 #define LLVM_CLANG_LIB_FORMAT_TOKENANNOTATOR_H
17
18 #include "UnwrappedLineParser.h"
19 #include "clang/Format/Format.h"
20
21 namespace clang {
22 namespace format {
23
24 enum LineType {
25 LT_Invalid,
26 LT_ImportStatement,
27 LT_ObjCDecl, // An @interface, @implementation, or @protocol line.
28 LT_ObjCMethodDecl,
29 LT_ObjCProperty, // An @property line.
30 LT_Other,
31 LT_PreprocessorDirective,
32 LT_VirtualFunctionDecl,
33 LT_ArrayOfStructInitializer,
34 LT_CommentAbovePPDirective,
35 };
36
37 class AnnotatedLine {
38 public:
39 AnnotatedLine(const UnwrappedLine &Line)
40 : First(Line.Tokens.front().Tok), Level(Line.Level),
41 PPLevel(Line.PPLevel),
42 MatchingOpeningBlockLineIndex(Line.MatchingOpeningBlockLineIndex),
43 MatchingClosingBlockLineIndex(Line.MatchingClosingBlockLineIndex),
44 InPPDirective(Line.InPPDirective),
45 InPragmaDirective(Line.InPragmaDirective),
46 InMacroBody(Line.InMacroBody),
47 MustBeDeclaration(Line.MustBeDeclaration), MightBeFunctionDecl(false),
48 IsMultiVariableDeclStmt(false), Affected(false),
49 LeadingEmptyLinesAffected(false), ChildrenAffected(false),
50 ReturnTypeWrapped(false), IsContinuation(Line.IsContinuation),
51 FirstStartColumn(Line.FirstStartColumn) {
52 assert(!Line.Tokens.empty());
53
54 // Calculate Next and Previous for all tokens. Note that we must overwrite
55 // Next and Previous for every token, as previous formatting runs might have
56 // left them in a different state.
57 First->Previous = nullptr;
58 FormatToken *Current = First;
59 for (const UnwrappedLineNode &Node : llvm::drop_begin(Line.Tokens)) {
60 Current->Next = Node.Tok;
61 Node.Tok->Previous = Current;
62 Current = Current->Next;
63 Current->Children.clear();
64 for (const auto &Child : Node.Children) {
65 Children.push_back(new AnnotatedLine(Child));
66 Current->Children.push_back(Children.back());
67 }
68 }
69 Last = Current;
70 Last->Next = nullptr;
71 }
72
73 ~AnnotatedLine() {
74 for (AnnotatedLine *Child : Children)
75 delete Child;
76 FormatToken *Current = First;
77 while (Current) {
78 Current->Children.clear();
79 Current->Role.reset();
80 Current = Current->Next;
81 }
82 }
83
84 bool isComment() const {
85 return First && First->is(tok::comment) && !First->getNextNonComment();
86 }
87
88 /// \c true if this line starts with the given tokens in order, ignoring
89 /// comments.
90 template <typename... Ts> bool startsWith(Ts... Tokens) const {
91 return First && First->startsSequence(Tokens...);
92 }
93
94 /// \c true if this line ends with the given tokens in reversed order,
95 /// ignoring comments.
96 /// For example, given tokens [T1, T2, T3, ...], the function returns true if
97 /// this line is like "... T3 T2 T1".
98 template <typename... Ts> bool endsWith(Ts... Tokens) const {
99 return Last && Last->endsSequence(Tokens...);
100 }
101
102 /// \c true if this line looks like a function definition instead of a
103 /// function declaration. Asserts MightBeFunctionDecl.
104 bool mightBeFunctionDefinition() const {
105 assert(MightBeFunctionDecl);
106 // Try to determine if the end of a stream of tokens is either the
107 // Definition or the Declaration for a function. It does this by looking for
108 // the ';' in foo(); and using that it ends with a ; to know this is the
109 // Definition, however the line could end with
110 // foo(); /* comment */
111 // or
112 // foo(); // comment
113 // or
114 // foo() // comment
115 // endsWith() ignores the comment.
116 return !endsWith(tok::semi);
117 }
118
119 /// \c true if this line starts a namespace definition.
120 bool startsWithNamespace() const {
121 return startsWith(tok::kw_namespace) || startsWith(TT_NamespaceMacro) ||
122 startsWith(tok::kw_inline, tok::kw_namespace) ||
123 startsWith(tok::kw_export, tok::kw_namespace);
124 }
125
126 FormatToken *First;
127 FormatToken *Last;
128
129 SmallVector<AnnotatedLine *, 0> Children;
130
131 LineType Type;
132 unsigned Level;
133 unsigned PPLevel;
134 size_t MatchingOpeningBlockLineIndex;
135 size_t MatchingClosingBlockLineIndex;
136 bool InPPDirective;
137 bool InPragmaDirective;
138 bool InMacroBody;
139 bool MustBeDeclaration;
140 bool MightBeFunctionDecl;
141 bool IsMultiVariableDeclStmt;
142
143 /// \c True if this line should be formatted, i.e. intersects directly or
144 /// indirectly with one of the input ranges.
145 bool Affected;
146
147 /// \c True if the leading empty lines of this line intersect with one of the
148 /// input ranges.
149 bool LeadingEmptyLinesAffected;
150
151 /// \c True if one of this line's children intersects with an input range.
152 bool ChildrenAffected;
153
154 /// \c True if breaking after last attribute group in function return type.
155 bool ReturnTypeWrapped;
156
157 /// \c True if this line should be indented by ContinuationIndent in addition
158 /// to the normal indention level.
159 bool IsContinuation;
160
161 unsigned FirstStartColumn;
162
163 private:
164 // Disallow copying.
165 AnnotatedLine(const AnnotatedLine &) = delete;
166 void operator=(const AnnotatedLine &) = delete;
167 };
168
169 /// Determines extra information about the tokens comprising an
170 /// \c UnwrappedLine.
171 class TokenAnnotator {
172 public:
173 TokenAnnotator(const FormatStyle &Style, const AdditionalKeywords &Keywords)
174 : Style(Style), Keywords(Keywords) {}
175
176 /// Adapts the indent levels of comment lines to the indent of the
177 /// subsequent line.
178 // FIXME: Can/should this be done in the UnwrappedLineParser?
179 void setCommentLineLevels(SmallVectorImpl<AnnotatedLine *> &Lines) const;
180
181 void annotate(AnnotatedLine &Line) const;
182 void calculateFormattingInformation(AnnotatedLine &Line) const;
183
184 private:
185 /// Calculate the penalty for splitting before \c Tok.
186 unsigned splitPenalty(const AnnotatedLine &Line, const FormatToken &Tok,
187 bool InFunctionDecl) const;
188
189 bool spaceRequiredBeforeParens(const FormatToken &Right) const;
190
191 bool spaceRequiredBetween(const AnnotatedLine &Line, const FormatToken &Left,
192 const FormatToken &Right) const;
193
194 bool spaceRequiredBefore(const AnnotatedLine &Line,
195 const FormatToken &Right) const;
196
197 bool mustBreakBefore(const AnnotatedLine &Line,
198 const FormatToken &Right) const;
199
200 bool canBreakBefore(const AnnotatedLine &Line,
201 const FormatToken &Right) const;
202
203 bool mustBreakForReturnType(const AnnotatedLine &Line) const;
204
205 void printDebugInfo(const AnnotatedLine &Line) const;
206
207 void calculateUnbreakableTailLengths(AnnotatedLine &Line) const;
208
209 void calculateArrayInitializerColumnList(AnnotatedLine &Line) const;
210
211 FormatToken *calculateInitializerColumnList(AnnotatedLine &Line,
212 FormatToken *CurrentToken,
213 unsigned Depth) const;
214 FormatStyle::PointerAlignmentStyle
215 getTokenReferenceAlignment(const FormatToken &PointerOrReference) const;
216
217 FormatStyle::PointerAlignmentStyle getTokenPointerOrReferenceAlignment(
218 const FormatToken &PointerOrReference) const;
219
220 const FormatStyle &Style;
221
222 const AdditionalKeywords &Keywords;
223 };
224
225 } // end namespace format
226 } // end namespace clang
227
228 #endif