clang  3.9.0
TokenAnnotator.h
Go to the documentation of this file.
1 //===--- TokenAnnotator.h - Format C++ code ---------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 ///
10 /// \file
11 /// \brief This file implements a token annotator, i.e. creates
12 /// \c AnnotatedTokens out of \c FormatTokens with required extra information.
13 ///
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_CLANG_LIB_FORMAT_TOKENANNOTATOR_H
17 #define LLVM_CLANG_LIB_FORMAT_TOKENANNOTATOR_H
18 
19 #include "UnwrappedLineParser.h"
20 #include "clang/Format/Format.h"
21 #include <string>
22 
23 namespace clang {
24 class SourceManager;
25 
26 namespace format {
27 
28 enum LineType {
31  LT_ObjCDecl, // An @interface, @implementation, or @protocol line.
33  LT_ObjCProperty, // An @property line.
37 };
38 
40 public:
42  : First(Line.Tokens.front().Tok), Level(Line.Level),
47  assert(!Line.Tokens.empty());
48 
49  // Calculate Next and Previous for all tokens. Note that we must overwrite
50  // Next and Previous for every token, as previous formatting runs might have
51  // left them in a different state.
52  First->Previous = nullptr;
54  for (std::list<UnwrappedLineNode>::const_iterator I = ++Line.Tokens.begin(),
55  E = Line.Tokens.end();
56  I != E; ++I) {
57  const UnwrappedLineNode &Node = *I;
58  Current->Next = I->Tok;
59  I->Tok->Previous = Current;
60  Current = Current->Next;
61  Current->Children.clear();
62  for (const auto &Child : Node.Children) {
63  Children.push_back(new AnnotatedLine(Child));
64  Current->Children.push_back(Children.back());
65  }
66  }
67  Last = Current;
68  Last->Next = nullptr;
69  }
70 
72  for (unsigned i = 0, e = Children.size(); i != e; ++i) {
73  delete Children[i];
74  }
76  while (Current) {
77  Current->Children.clear();
78  Current->Role.reset();
79  Current = Current->Next;
80  }
81  }
82 
83  /// \c true if this line starts with the given tokens in order, ignoring
84  /// comments.
85  template <typename... Ts> bool startsWith(Ts... Tokens) const {
86  return First && First->startsSequence(Tokens...);
87  }
88 
89  /// \c true if this line ends with the given tokens in reversed order,
90  /// ignoring comments.
91  /// For example, given tokens [T1, T2, T3, ...], the function returns true if
92  /// this line is like "... T3 T2 T1".
93  template <typename... Ts> bool endsWith(Ts... Tokens) const {
94  return Last && Last->endsSequence(Tokens...);
95  }
96 
97  /// \c true if this line looks like a function definition instead of a
98  /// function declaration. Asserts MightBeFunctionDecl.
100  assert(MightBeFunctionDecl);
101  // FIXME: Line.Last points to other characters than tok::semi
102  // and tok::lbrace.
103  return !Last->isOneOf(tok::semi, tok::comment);
104  }
105 
108 
110 
112  unsigned Level;
117 
118  /// \c True if this line should be formatted, i.e. intersects directly or
119  /// indirectly with one of the input ranges.
120  bool Affected;
121 
122  /// \c True if the leading empty lines of this line intersect with one of the
123  /// input ranges.
125 
126  /// \c True if a one of this line's children intersects with an input range.
128 
129 private:
130  // Disallow copying.
131  AnnotatedLine(const AnnotatedLine &) = delete;
132  void operator=(const AnnotatedLine &) = delete;
133 };
134 
135 /// \brief Determines extra information about the tokens comprising an
136 /// \c UnwrappedLine.
138 public:
139  TokenAnnotator(const FormatStyle &Style, const AdditionalKeywords &Keywords)
140  : Style(Style), Keywords(Keywords) {}
141 
142  /// \brief Adapts the indent levels of comment lines to the indent of the
143  /// subsequent line.
144  // FIXME: Can/should this be done in the UnwrappedLineParser?
146 
147  void annotate(AnnotatedLine &Line);
149 
150 private:
151  /// \brief Calculate the penalty for splitting before \c Tok.
152  unsigned splitPenalty(const AnnotatedLine &Line, const FormatToken &Tok,
153  bool InFunctionDecl);
154 
155  bool spaceRequiredBetween(const AnnotatedLine &Line, const FormatToken &Left,
156  const FormatToken &Right);
157 
158  bool spaceRequiredBefore(const AnnotatedLine &Line, const FormatToken &Tok);
159 
160  bool mustBreakBefore(const AnnotatedLine &Line, const FormatToken &Right);
161 
162  bool canBreakBefore(const AnnotatedLine &Line, const FormatToken &Right);
163 
164  bool mustBreakForReturnType(const AnnotatedLine &Line) const;
165 
166  void printDebugInfo(const AnnotatedLine &Line);
167 
168  void calculateUnbreakableTailLengths(AnnotatedLine &Line);
169 
170  const FormatStyle &Style;
171 
172  const AdditionalKeywords &Keywords;
173 };
174 
175 } // end namespace format
176 } // end namespace clang
177 
178 #endif
SmallVector< UnwrappedLine, 0 > Children
std::unique_ptr< TokenRole > Role
A token can have a special role that can carry extra information about the token's formatting...
Definition: FormatToken.h:197
bool isOneOf(A K1, B K2) const
Definition: FormatToken.h:291
bool LeadingEmptyLinesAffected
True if the leading empty lines of this line intersect with one of the input ranges.
void setCommentLineLevels(SmallVectorImpl< AnnotatedLine * > &Lines)
Adapts the indent levels of comment lines to the indent of the subsequent line.
FormatToken * Next
The next token in the unwrapped line.
Definition: FormatToken.h:268
FormatToken * Previous
The previous token in the unwrapped line.
Definition: FormatToken.h:265
bool ChildrenAffected
True if a one of this line's children intersects with an input range.
An unwrapped line is a sequence of Token, that we would like to put on a single line if there was no ...
detail::InMemoryDirectory::const_iterator I
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:310
Determines extra information about the tokens comprising an UnwrappedLine.
std::list< UnwrappedLineNode > Tokens
The Tokens comprising this UnwrappedLine.
SmallVector< AnnotatedLine *, 0 > Children
A wrapper around a Token storing information about the whitespace characters preceding it...
Definition: FormatToken.h:113
TokenAnnotator(const FormatStyle &Style, const AdditionalKeywords &Keywords)
void annotate(AnnotatedLine &Line)
bool startsWith(Ts...Tokens) const
true if this line starts with the given tokens in order, ignoring comments.
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:303
bool Affected
True if this line should be formatted, i.e.
#define false
Definition: stdbool.h:33
AnnotatedLine & Line
Various functions to configurably format source code.
Encapsulates keywords that are context sensitive or for languages not properly supported by Clang's l...
Definition: FormatToken.h:569
ArrayRef< FormatToken * > Tokens
This file contains the declaration of the UnwrappedLineParser, which turns a stream of tokens into Un...
The FormatStyle is used to configure the formatting to follow specific guidelines.
Definition: Format.h:46
ast_type_traits::DynTypedNode Node
AnnotatedLine(const UnwrappedLine &Line)
detail::InMemoryDirectory::const_iterator E
void calculateFormattingInformation(AnnotatedLine &Line)
bool endsWith(Ts...Tokens) const
true if this line ends with the given tokens in reversed order, ignoring comments.
SmallVector< AnnotatedLine *, 1 > Children
If this token starts a block, this contains all the unwrapped lines in it.
Definition: FormatToken.h:272
FormatToken * Current
bool mightBeFunctionDefinition() const
true if this line looks like a function definition instead of a function declaration.