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 { 29 LT_Invalid, 30 LT_ImportStatement, 31 LT_ObjCDecl, // An @interface, @implementation, or @protocol line. 32 LT_ObjCMethodDecl, 33 LT_ObjCProperty, // An @property line. 34 LT_Other, 35 LT_PreprocessorDirective, 36 LT_VirtualFunctionDecl 37 }; 38 39 class AnnotatedLine { 40 public: 41 AnnotatedLine(const UnwrappedLine &Line) 42 : First(Line.Tokens.front().Tok), Level(Line.Level), 43 InPPDirective(Line.InPPDirective), 44 MustBeDeclaration(Line.MustBeDeclaration), MightBeFunctionDecl(false), 45 IsMultiVariableDeclStmt(false), Affected(false), 46 LeadingEmptyLinesAffected(false), ChildrenAffected(false) { 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; 53 FormatToken *Current = First; 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 71 ~AnnotatedLine() { 72 for (unsigned i = 0, e = Children.size(); i != e; ++i) { 73 delete Children[i]; 74 } 75 FormatToken *Current = First; 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 startsWith(First, Tokens...); 87 } 88 89 /// \c true if this line looks like a function definition instead of a 90 /// function declaration. Asserts MightBeFunctionDecl. 91 bool mightBeFunctionDefinition() const { 92 assert(MightBeFunctionDecl); 93 // FIXME: Line.Last points to other characters than tok::semi 94 // and tok::lbrace. 95 return !Last->isOneOf(tok::semi, tok::comment); 96 } 97 98 FormatToken *First; 99 FormatToken *Last; 100 101 SmallVector<AnnotatedLine *, 0> Children; 102 103 LineType Type; 104 unsigned Level; 105 bool InPPDirective; 106 bool MustBeDeclaration; 107 bool MightBeFunctionDecl; 108 bool IsMultiVariableDeclStmt; 109 110 /// \c True if this line should be formatted, i.e. intersects directly or 111 /// indirectly with one of the input ranges. 112 bool Affected; 113 114 /// \c True if the leading empty lines of this line intersect with one of the 115 /// input ranges. 116 bool LeadingEmptyLinesAffected; 117 118 /// \c True if a one of this line's children intersects with an input range. 119 bool ChildrenAffected; 120 121 private: 122 // Disallow copying. 123 AnnotatedLine(const AnnotatedLine &) = delete; 124 void operator=(const AnnotatedLine &) = delete; 125 126 template <typename A, typename... Ts> 127 bool startsWith(FormatToken *Tok, A K1) const { 128 while (Tok && Tok->is(tok::comment)) 129 Tok = Tok->Next; 130 return Tok && Tok->is(K1); 131 } 132 133 template <typename A, typename... Ts> 134 bool startsWith(FormatToken *Tok, A K1, Ts... Tokens) const { 135 return startsWith(Tok, K1) && startsWith(Tok->Next, Tokens...); 136 } 137 }; 138 139 /// \brief Determines extra information about the tokens comprising an 140 /// \c UnwrappedLine. 141 class TokenAnnotator { 142 public: 143 TokenAnnotator(const FormatStyle &Style, const AdditionalKeywords &Keywords) 144 : Style(Style), Keywords(Keywords) {} 145 146 /// \brief Adapts the indent levels of comment lines to the indent of the 147 /// subsequent line. 148 // FIXME: Can/should this be done in the UnwrappedLineParser? 149 void setCommentLineLevels(SmallVectorImpl<AnnotatedLine *> &Lines); 150 151 void annotate(AnnotatedLine &Line); 152 void calculateFormattingInformation(AnnotatedLine &Line); 153 154 private: 155 /// \brief Calculate the penalty for splitting before \c Tok. 156 unsigned splitPenalty(const AnnotatedLine &Line, const FormatToken &Tok, 157 bool InFunctionDecl); 158 159 bool spaceRequiredBetween(const AnnotatedLine &Line, const FormatToken &Left, 160 const FormatToken &Right); 161 162 bool spaceRequiredBefore(const AnnotatedLine &Line, const FormatToken &Tok); 163 164 bool mustBreakBefore(const AnnotatedLine &Line, const FormatToken &Right); 165 166 bool canBreakBefore(const AnnotatedLine &Line, const FormatToken &Right); 167 168 bool mustBreakForReturnType(const AnnotatedLine &Line) const; 169 170 void printDebugInfo(const AnnotatedLine &Line); 171 172 void calculateUnbreakableTailLengths(AnnotatedLine &Line); 173 174 const FormatStyle &Style; 175 176 const AdditionalKeywords &Keywords; 177 }; 178 179 } // end namespace format 180 } // end namespace clang 181 182 #endif 183
