clang 10.0.0git

TokenAnnotator.h
Go to the documentation of this file.
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 class SourceManager;
23
24 namespace format {
25
26 enum LineType {
27 LT_Invalid,
28 LT_ImportStatement,
29 LT_ObjCDecl, // An @interface, @implementation, or @protocol line.
30 LT_ObjCMethodDecl,
31 LT_ObjCProperty, // An @property line.
32 LT_Other,
33 LT_PreprocessorDirective,
34 LT_VirtualFunctionDecl
35 };
36
37 class AnnotatedLine {
38 public:
39 AnnotatedLine(const UnwrappedLine &Line)
40 : First(Line.Tokens.front().Tok), Level(Line.Level),
41 MatchingOpeningBlockLineIndex(Line.MatchingOpeningBlockLineIndex),
42 MatchingClosingBlockLineIndex(Line.MatchingClosingBlockLineIndex),
43 InPPDirective(Line.InPPDirective),
44 MustBeDeclaration(Line.MustBeDeclaration), MightBeFunctionDecl(false),
45 IsMultiVariableDeclStmt(false), Affected(false),
46 LeadingEmptyLinesAffected(false), ChildrenAffected(false),
47 FirstStartColumn(Line.FirstStartColumn) {
48 assert(!Line.Tokens.empty());
49
50 // Calculate Next and Previous for all tokens. Note that we must overwrite
51 // Next and Previous for every token, as previous formatting runs might have
52 // left them in a different state.
53 First->Previous = nullptr;
54 FormatToken *Current = First;
55 for (std::list<UnwrappedLineNode>::const_iterator I = ++Line.Tokens.begin(),
56 E = Line.Tokens.end();
57 I != E; ++I) {
58 const UnwrappedLineNode &Node = *I;
59 Current->Next = I->Tok;
60 I->Tok->Previous = Current;
61 Current = Current->Next;
62 Current->Children.clear();
63 for (const auto &Child : Node.Children) {
64 Children.push_back(new AnnotatedLine(Child));
65 Current->Children.push_back(Children.back());
66 }
67 }
68 Last = Current;
69 Last->Next = nullptr;
70 }
71
72 ~AnnotatedLine() {
73 for (unsigned i = 0, e = Children.size(); i != e; ++i) {
74 delete Children[i];
75 }
76 FormatToken *Current = First;
77 while (Current) {
78 Current->Children.clear();
79 Current->Role.reset();
80 Current = Current->Next;
81 }
82 }
83
84 /// \c true if this line starts with the given tokens in order, ignoring
85 /// comments.
86 template <typename... Ts> bool startsWith(Ts... Tokens) const {
87 return First && First->startsSequence(Tokens...);
88 }
89
90 /// \c true if this line ends with the given tokens in reversed order,
91 /// ignoring comments.
92 /// For example, given tokens [T1, T2, T3, ...], the function returns true if
93 /// this line is like "... T3 T2 T1".
94 template <typename... Ts> bool endsWith(Ts... Tokens) const {
95 return Last && Last->endsSequence(Tokens...);
96 }
97
98 /// \c true if this line looks like a function definition instead of a
99 /// function declaration. Asserts MightBeFunctionDecl.
100 bool mightBeFunctionDefinition() const {
101 assert(MightBeFunctionDecl);
102 // Try to determine if the end of a stream of tokens is either the
103 // Definition or the Declaration for a function. It does this by looking for
104 // the ';' in foo(); and using that it ends with a ; to know this is the
105 // Definition, however the line could end with
106 // foo(); /* comment */
107 // or
108 // foo(); // comment
109 // or
110 // foo() // comment
111 // endsWith() ignores the comment.
112 return !endsWith(tok::semi);
113 }
114
115 /// \c true if this line starts a namespace definition.
116 bool startsWithNamespace() const {
117 return startsWith(tok::kw_namespace) || startsWith(TT_NamespaceMacro) ||
118 startsWith(tok::kw_inline, tok::kw_namespace) ||
119 startsWith(tok::kw_export, tok::kw_namespace);
120 }
121
122 FormatToken *First;
123 FormatToken *Last;
124
125 SmallVector<AnnotatedLine *, 0> Children;
126
127 LineType Type;
128 unsigned Level;
129 size_t MatchingOpeningBlockLineIndex;
130 size_t MatchingClosingBlockLineIndex;
131 bool InPPDirective;
132 bool MustBeDeclaration;
133 bool MightBeFunctionDecl;
134 bool IsMultiVariableDeclStmt;
135
136 /// \c True if this line should be formatted, i.e. intersects directly or
137 /// indirectly with one of the input ranges.
138 bool Affected;
139
140 /// \c True if the leading empty lines of this line intersect with one of the
141 /// input ranges.
142 bool LeadingEmptyLinesAffected;
143
144 /// \c True if one of this line's children intersects with an input range.
145 bool ChildrenAffected;
146
147 unsigned FirstStartColumn;
148
149 private:
150 // Disallow copying.
151 AnnotatedLine(const AnnotatedLine &) = delete;
152 void operator=(const AnnotatedLine &) = delete;
153 };
154
155 /// Determines extra information about the tokens comprising an
156 /// \c UnwrappedLine.
157 class TokenAnnotator {
158 public:
159 TokenAnnotator(const FormatStyle &Style, const AdditionalKeywords &Keywords)
160 : Style(Style), Keywords(Keywords) {}
161
162 /// Adapts the indent levels of comment lines to the indent of the
163 /// subsequent line.
164 // FIXME: Can/should this be done in the UnwrappedLineParser?
165 void setCommentLineLevels(SmallVectorImpl<AnnotatedLine *> &Lines);
166
167 void annotate(AnnotatedLine &Line);
168 void calculateFormattingInformation(AnnotatedLine &Line);
169
170 private:
171 /// Calculate the penalty for splitting before \c Tok.
172 unsigned splitPenalty(const AnnotatedLine &Line, const FormatToken &Tok,
173 bool InFunctionDecl);
174
175 bool spaceRequiredBeforeParens(const FormatToken &Right) const;
176
177 bool spaceRequiredBetween(const AnnotatedLine &Line, const FormatToken &Left,
178 const FormatToken &Right);
179
180 bool spaceRequiredBefore(const AnnotatedLine &Line, const FormatToken &Right);
181
182 bool mustBreakBefore(const AnnotatedLine &Line, const FormatToken &Right);
183
184 bool canBreakBefore(const AnnotatedLine &Line, const FormatToken &Right);
185
186 bool mustBreakForReturnType(const AnnotatedLine &Line) const;
187
188 void printDebugInfo(const AnnotatedLine &Line);
189
190 void calculateUnbreakableTailLengths(AnnotatedLine &Line);
191
192 const FormatStyle &Style;
193
194 const AdditionalKeywords &Keywords;
195 };
196
197 } // end namespace format
198 } // end namespace clang
199
200 #endif
clang::format::FormatToken::endsSequence
bool endsSequence(A K1, Ts... Tokens) const
true if this token ends a sequence with the given tokens in order, following the Previous pointers...
Definition: FormatToken.h:359
clang::format::AnnotatedLine::FirstStartColumn
unsigned FirstStartColumn
Definition: TokenAnnotator.h:147
clang::format::UnwrappedLineNode::Children
SmallVector< UnwrappedLine, 0 > Children
Definition: UnwrappedLineParser.h:286
clang::format::AnnotatedLine::endsWith
bool endsWith(Ts... Tokens) const
true if this line ends with the given tokens in reversed order, ignoring comments.
Definition: TokenAnnotator.h:94
clang::format::FormatToken::Tok
Token Tok
The Token.
Definition: FormatToken.h:135
clang::format::FormatToken::Role
std::unique_ptr< TokenRole > Role
A token can have a special role that can carry extra information about the token&#39;s formatting...
Definition: FormatToken.h:211
clang::format::AnnotatedLine::MustBeDeclaration
bool MustBeDeclaration
Definition: TokenAnnotator.h:132
clang::format::printDebugInfo
static LLVM_ATTRIBUTE_UNUSED void printDebugInfo(const UnwrappedLine &Line, StringRef Prefix="")
Definition: UnwrappedLineParser.cpp:2445
clang::format::AnnotatedLine::LeadingEmptyLinesAffected
bool LeadingEmptyLinesAffected
True if the leading empty lines of this line intersect with one of the input ranges.
Definition: TokenAnnotator.h:142
clang::format::AnnotatedLine::InPPDirective
bool InPPDirective
Definition: TokenAnnotator.h:131
clang::format::AnnotatedLine::Last
FormatToken * Last
Definition: TokenAnnotator.h:123
clang::format::FormatToken::Next
FormatToken * Next
The next token in the unwrapped line.
Definition: FormatToken.h:300
clang::format::AnnotatedLine::MatchingOpeningBlockLineIndex
size_t MatchingOpeningBlockLineIndex
Definition: TokenAnnotator.h:129
clang::format::AnnotatedLine::MatchingClosingBlockLineIndex
size_t MatchingClosingBlockLineIndex
Definition: TokenAnnotator.h:130
clang::format::FormatToken::Previous
FormatToken * Previous
The previous token in the unwrapped line.
Definition: FormatToken.h:297
llvm::SmallVectorImpl
Definition: LLVM.h:36
clang::format::LineType
LineType
Definition: TokenAnnotator.h:26
clang::format::Tok
const FormatToken & Tok
Definition: BreakableToken.h:239
clang::format::AnnotatedLine::ChildrenAffected
bool ChildrenAffected
True if one of this line&#39;s children intersects with an input range.
Definition: TokenAnnotator.h:145
clang::format::AnnotatedLine::~AnnotatedLine
~AnnotatedLine()
Definition: TokenAnnotator.h:72
clang::format::LT_ObjCMethodDecl
Definition: TokenAnnotator.h:30
clang::format::UnwrappedLine
An unwrapped line is a sequence of Token, that we would like to put on a single line if there was no ...
Definition: UnwrappedLineParser.h:36
clang::format::AnnotatedLine::mightBeFunctionDefinition
bool mightBeFunctionDefinition() const
true if this line looks like a function definition instead of a function declaration.
Definition: TokenAnnotator.h:100
clang::format::AnnotatedLine::Type
LineType Type
Definition: TokenAnnotator.h:127
clang::format::TokenAnnotator
Determines extra information about the tokens comprising an UnwrappedLine.
Definition: TokenAnnotator.h:157
clang::format::UnwrappedLine::Tokens
std::list< UnwrappedLineNode > Tokens
The Tokens comprising this UnwrappedLine.
Definition: UnwrappedLineParser.h:41
Line
const AnnotatedLine * Line
Definition: UsingDeclarationsSorter.cpp:68
clang::format::AnnotatedLine::Children
SmallVector< AnnotatedLine *, 0 > Children
Definition: TokenAnnotator.h:125
clang::format::LT_ImportStatement
Definition: TokenAnnotator.h:28
clang::format::FormatToken
A wrapper around a Token storing information about the whitespace characters preceding it...
Definition: FormatToken.h:131
clang::format::LT_ObjCDecl
Definition: TokenAnnotator.h:29
clang::format::AnnotatedLine
Definition: TokenAnnotator.h:37
clang::format::TokenAnnotator::TokenAnnotator
TokenAnnotator(const FormatStyle &Style, const AdditionalKeywords &Keywords)
Definition: TokenAnnotator.h:159
clang::format::LT_Other
Definition: TokenAnnotator.h:32
clang::format::AnnotatedLine::Level
unsigned Level
Definition: TokenAnnotator.h:128
clang::format::AnnotatedLine::Affected
bool Affected
True if this line should be formatted, i.e.
Definition: TokenAnnotator.h:138
clang::format::LT_Invalid
Definition: TokenAnnotator.h:27
false
#define false
Definition: stdbool.h:17
Format.h
Various functions to configurably format source code.
clang::format::AdditionalKeywords
Encapsulates keywords that are context sensitive or for languages not properly supported by Clang&#39;s l...
Definition: FormatToken.h:685
clang::format::AnnotatedLine::First
FormatToken * First
Definition: TokenAnnotator.h:122
UnwrappedLineParser.h
This file contains the declaration of the UnwrappedLineParser, which turns a stream of tokens into Un...
llvm::SmallVector
Definition: LLVM.h:35
clang::format::AnnotatedLine::startsWith
bool startsWith(Ts... Tokens) const
true if this line starts with the given tokens in order, ignoring comments.
Definition: TokenAnnotator.h:86
clang::format::LT_VirtualFunctionDecl
Definition: TokenAnnotator.h:34
clang::format::FormatStyle
The FormatStyle is used to configure the formatting to follow specific guidelines.
Definition: Format.h:49
clang::format::AnnotatedLine::IsMultiVariableDeclStmt
bool IsMultiVariableDeclStmt
Definition: TokenAnnotator.h:134
clang::format::UnwrappedLineNode
Definition: UnwrappedLineParser.h:281
Node
ast_type_traits::DynTypedNode Node
Definition: ASTMatchFinder.cpp:60
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:21
clang::format::AnnotatedLine::AnnotatedLine
AnnotatedLine(const UnwrappedLine &Line)
Definition: TokenAnnotator.h:39
clang::format::LT_ObjCProperty
Definition: TokenAnnotator.h:31
clang::format::AnnotatedLine::MightBeFunctionDecl
bool MightBeFunctionDecl
Definition: TokenAnnotator.h:133
clang::format::AnnotatedLine::startsWithNamespace
bool startsWithNamespace() const
true if this line starts a namespace definition.
Definition: TokenAnnotator.h:116
clang::format::FormatToken::Children
SmallVector< AnnotatedLine *, 1 > Children
If this token starts a block, this contains all the unwrapped lines in it.
Definition: FormatToken.h:304
clang::format::FormatToken::startsSequence
bool startsSequence(A K1, Ts... Tokens) const
true if this token starts a sequence with the given tokens in order, following the Next pointers...
Definition: FormatToken.h:348
clang::format::LT_PreprocessorDirective
Definition: TokenAnnotator.h:33
clang::format::Style
const FormatStyle & Style
Definition: BreakableToken.h:242