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 enum ScopeType { 38 // Contained in class declaration/definition. 39 ST_Class, 40 // Contained within function definition. 41 ST_Function, 42 // Contained within other scope block (loop, if/else, etc). 43 ST_Other, 44 }; 45 46 class AnnotatedLine { 47 public: 48 AnnotatedLine(const UnwrappedLine &Line) 49 : First(Line.Tokens.front().Tok), Level(Line.Level), 50 PPLevel(Line.PPLevel), 51 MatchingOpeningBlockLineIndex(Line.MatchingOpeningBlockLineIndex), 52 MatchingClosingBlockLineIndex(Line.MatchingClosingBlockLineIndex), 53 InPPDirective(Line.InPPDirective), 54 InPragmaDirective(Line.InPragmaDirective), 55 InMacroBody(Line.InMacroBody), 56 MustBeDeclaration(Line.MustBeDeclaration), MightBeFunctionDecl(false), 57 IsMultiVariableDeclStmt(false), Affected(false), 58 LeadingEmptyLinesAffected(false), ChildrenAffected(false), 59 ReturnTypeWrapped(false), IsContinuation(Line.IsContinuation), 60 FirstStartColumn(Line.FirstStartColumn) { 61 assert(!Line.Tokens.empty()); 62 63 // Calculate Next and Previous for all tokens. Note that we must overwrite 64 // Next and Previous for every token, as previous formatting runs might have 65 // left them in a different state. 66 First->Previous = nullptr; 67 FormatToken *Current = First; 68 addChildren(Line.Tokens.front(), Current); 69 for (const UnwrappedLineNode &Node : llvm::drop_begin(Line.Tokens)) { 70 if (Node.Tok->MacroParent) 71 ContainsMacroCall = true; 72 Current->Next = Node.Tok; 73 Node.Tok->Previous = Current; 74 Current = Current->Next; 75 addChildren(Node, Current); 76 // FIXME: if we add children, previous will point to the token before 77 // the children; changing this requires significant changes across 78 // clang-format. 79 } 80 Last = Current; 81 Last->Next = nullptr; 82 } 83 84 void addChildren(const UnwrappedLineNode &Node, FormatToken *Current) { 85 Current->Children.clear(); 86 for (const auto &Child : Node.Children) { 87 Children.push_back(new AnnotatedLine(Child)); 88 if (Children.back()->ContainsMacroCall) 89 ContainsMacroCall = true; 90 Current->Children.push_back(Children.back()); 91 } 92 } 93 94 ~AnnotatedLine() { 95 for (AnnotatedLine *Child : Children) 96 delete Child; 97 FormatToken *Current = First; 98 while (Current) { 99 Current->Children.clear(); 100 Current->Role.reset(); 101 Current = Current->Next; 102 } 103 } 104 105 bool isComment() const { 106 return First && First->is(tok::comment) && !First->getNextNonComment(); 107 } 108 109 /// \c true if this line starts with the given tokens in order, ignoring 110 /// comments. 111 template <typename... Ts> bool startsWith(Ts... Tokens) const { 112 return First && First->startsSequence(Tokens...); 113 } 114 115 /// \c true if this line ends with the given tokens in reversed order, 116 /// ignoring comments. 117 /// For example, given tokens [T1, T2, T3, ...], the function returns true if 118 /// this line is like "... T3 T2 T1". 119 template <typename... Ts> bool endsWith(Ts... Tokens) const { 120 return Last && Last->endsSequence(Tokens...); 121 } 122 123 /// \c true if this line looks like a function definition instead of a 124 /// function declaration. Asserts MightBeFunctionDecl. 125 bool mightBeFunctionDefinition() const { 126 assert(MightBeFunctionDecl); 127 // Try to determine if the end of a stream of tokens is either the 128 // Definition or the Declaration for a function. It does this by looking for 129 // the ';' in foo(); and using that it ends with a ; to know this is the 130 // Definition, however the line could end with 131 // foo(); /* comment */ 132 // or 133 // foo(); // comment 134 // or 135 // foo() // comment 136 // endsWith() ignores the comment. 137 return !endsWith(tok::semi); 138 } 139 140 /// \c true if this line starts a namespace definition. 141 bool startsWithNamespace() const { 142 return startsWith(tok::kw_namespace) || startsWith(TT_NamespaceMacro) || 143 startsWith(tok::kw_inline, tok::kw_namespace) || 144 startsWith(tok::kw_export, tok::kw_namespace); 145 } 146 147 FormatToken *First; 148 FormatToken *Last; 149 150 SmallVector<AnnotatedLine *, 0> Children; 151 152 LineType Type; 153 unsigned Level; 154 unsigned PPLevel; 155 size_t MatchingOpeningBlockLineIndex; 156 size_t MatchingClosingBlockLineIndex; 157 bool InPPDirective; 158 bool InPragmaDirective; 159 bool InMacroBody; 160 bool MustBeDeclaration; 161 bool MightBeFunctionDecl; 162 bool IsMultiVariableDeclStmt; 163 164 /// \c True if this line contains a macro call for which an expansion exists. 165 bool ContainsMacroCall = false; 166 167 /// \c True if this line should be formatted, i.e. intersects directly or 168 /// indirectly with one of the input ranges. 169 bool Affected; 170 171 /// \c True if the leading empty lines of this line intersect with one of the 172 /// input ranges. 173 bool LeadingEmptyLinesAffected; 174 175 /// \c True if one of this line's children intersects with an input range. 176 bool ChildrenAffected; 177 178 /// \c True if breaking after last attribute group in function return type. 179 bool ReturnTypeWrapped; 180 181 /// \c True if this line should be indented by ContinuationIndent in addition 182 /// to the normal indention level. 183 bool IsContinuation; 184 185 unsigned FirstStartColumn; 186 187 private: 188 // Disallow copying. 189 AnnotatedLine(const AnnotatedLine &) = delete; 190 void operator=(const AnnotatedLine &) = delete; 191 }; 192 193 /// Determines extra information about the tokens comprising an 194 /// \c UnwrappedLine. 195 class TokenAnnotator { 196 public: 197 TokenAnnotator(const FormatStyle &Style, const AdditionalKeywords &Keywords) 198 : Style(Style), Keywords(Keywords) {} 199 200 /// Adapts the indent levels of comment lines to the indent of the 201 /// subsequent line. 202 // FIXME: Can/should this be done in the UnwrappedLineParser? 203 void setCommentLineLevels(SmallVectorImpl<AnnotatedLine *> &Lines) const; 204 205 void annotate(AnnotatedLine &Line); 206 void calculateFormattingInformation(AnnotatedLine &Line) const; 207 208 private: 209 /// Calculate the penalty for splitting before \c Tok. 210 unsigned splitPenalty(const AnnotatedLine &Line, const FormatToken &Tok, 211 bool InFunctionDecl) const; 212 213 bool spaceRequiredBeforeParens(const FormatToken &Right) const; 214 215 bool spaceRequiredBetween(const AnnotatedLine &Line, const FormatToken &Left, 216 const FormatToken &Right) const; 217 218 bool spaceRequiredBefore(const AnnotatedLine &Line, 219 const FormatToken &Right) const; 220 221 bool mustBreakBefore(const AnnotatedLine &Line, 222 const FormatToken &Right) const; 223 224 bool canBreakBefore(const AnnotatedLine &Line, 225 const FormatToken &Right) const; 226 227 bool mustBreakForReturnType(const AnnotatedLine &Line) const; 228 229 void printDebugInfo(const AnnotatedLine &Line) const; 230 231 void calculateUnbreakableTailLengths(AnnotatedLine &Line) const; 232 233 void calculateArrayInitializerColumnList(AnnotatedLine &Line) const; 234 235 FormatToken *calculateInitializerColumnList(AnnotatedLine &Line, 236 FormatToken *CurrentToken, 237 unsigned Depth) const; 238 FormatStyle::PointerAlignmentStyle 239 getTokenReferenceAlignment(const FormatToken &PointerOrReference) const; 240 241 FormatStyle::PointerAlignmentStyle getTokenPointerOrReferenceAlignment( 242 const FormatToken &PointerOrReference) const; 243 244 const FormatStyle &Style; 245 246 const AdditionalKeywords &Keywords; 247 248 SmallVector<ScopeType> Scopes; 249 }; 250 251 } // end namespace format 252 } // end namespace clang 253 254 #endif 255