1 //===--- LeftRightQualifierAlignmentFixer.cpp -------------------*- C++--*-===//
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
7 //===----------------------------------------------------------------------===//
10 /// This file implements LeftRightQualifierAlignmentFixer, a TokenAnalyzer that
11 /// enforces either left or right const depending on the style.
13 //===----------------------------------------------------------------------===//
15 #include "QualifierAlignmentFixer.h"
16 #include "FormatToken.h"
17 #include "llvm/Support/Debug.h"
18 #include "llvm/Support/Regex.h"
22 #define DEBUG_TYPE "format-qualifier-alignment-fixer"
27 QualifierAlignmentFixer::QualifierAlignmentFixer(
28 const Environment &Env, const FormatStyle &Style, StringRef &Code,
29 ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn,
30 unsigned NextStartColumn, unsigned LastStartColumn, StringRef FileName)
31 : TokenAnalyzer(Env, Style), Code(Code), Ranges(Ranges),
32 FirstStartColumn(FirstStartColumn), NextStartColumn(NextStartColumn),
33 LastStartColumn(LastStartColumn), FileName(FileName) {
34 std::vector<std::string> LeftOrder;
35 std::vector<std::string> RightOrder;
36 std::vector<tok::TokenKind> ConfiguredQualifierTokens;
37 PrepareLeftRightOrdering(Style.QualifierOrder, LeftOrder, RightOrder,
38 ConfiguredQualifierTokens);
40 // Handle the left and right Alignment Seperately
41 for (const auto &Qualifier : LeftOrder) {
43 [&, Qualifier, ConfiguredQualifierTokens](const Environment &Env) {
44 return LeftRightQualifierAlignmentFixer(Env, Style, Qualifier,
45 ConfiguredQualifierTokens,
50 for (const auto &Qualifier : RightOrder) {
52 [&, Qualifier, ConfiguredQualifierTokens](const Environment &Env) {
53 return LeftRightQualifierAlignmentFixer(Env, Style, Qualifier,
54 ConfiguredQualifierTokens,
61 std::pair<tooling::Replacements, unsigned> QualifierAlignmentFixer::analyze(
62 TokenAnnotator &Annotator, SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
63 FormatTokenLexer &Tokens) {
64 auto Env = Environment::make(Code, FileName, Ranges, FirstStartColumn,
65 NextStartColumn, LastStartColumn);
68 llvm::Optional<std::string> CurrentCode = None;
69 tooling::Replacements Fixes;
70 for (size_t I = 0, E = Passes.size(); I < E; ++I) {
71 std::pair<tooling::Replacements, unsigned> PassFixes = Passes[I](*Env);
72 auto NewCode = applyAllReplacements(
73 CurrentCode ? StringRef(*CurrentCode) : Code, PassFixes.first);
75 Fixes = Fixes.merge(PassFixes.first);
77 CurrentCode = std::move(*NewCode);
78 Env = Environment::make(
79 *CurrentCode, FileName,
80 tooling::calculateRangesAfterReplacements(Fixes, Ranges),
81 FirstStartColumn, NextStartColumn, LastStartColumn);
88 // Don't make replacements that replace nothing.
89 tooling::Replacements NonNoOpFixes;
91 for (auto I = Fixes.begin(), E = Fixes.end(); I != E; ++I) {
92 StringRef OriginalCode = Code.substr(I->getOffset(), I->getLength());
94 if (!OriginalCode.equals(I->getReplacementText())) {
95 auto Err = NonNoOpFixes.add(*I);
97 llvm::errs() << "Error adding replacements : "
98 << llvm::toString(std::move(Err)) << "\n";
101 return {NonNoOpFixes, 0};
104 static void replaceToken(const SourceManager &SourceMgr,
105 tooling::Replacements &Fixes,
106 const CharSourceRange &Range, std::string NewText) {
107 auto Replacement = tooling::Replacement(SourceMgr, Range, NewText);
108 auto Err = Fixes.add(Replacement);
111 llvm::errs() << "Error while rearranging Qualifier : "
112 << llvm::toString(std::move(Err)) << "\n";
115 static void removeToken(const SourceManager &SourceMgr,
116 tooling::Replacements &Fixes,
117 const FormatToken *First) {
118 auto Range = CharSourceRange::getCharRange(First->getStartOfNonWhitespace(),
119 First->Tok.getEndLoc());
120 replaceToken(SourceMgr, Fixes, Range, "");
123 static void insertQualifierAfter(const SourceManager &SourceMgr,
124 tooling::Replacements &Fixes,
125 const FormatToken *First,
126 const std::string &Qualifier) {
127 FormatToken *Next = First->Next;
130 auto Range = CharSourceRange::getCharRange(Next->getStartOfNonWhitespace(),
131 Next->Tok.getEndLoc());
133 std::string NewText = " " + Qualifier + " ";
134 NewText += Next->TokenText;
135 replaceToken(SourceMgr, Fixes, Range, NewText);
138 static void insertQualifierBefore(const SourceManager &SourceMgr,
139 tooling::Replacements &Fixes,
140 const FormatToken *First,
141 const std::string &Qualifier) {
142 auto Range = CharSourceRange::getCharRange(First->getStartOfNonWhitespace(),
143 First->Tok.getEndLoc());
145 std::string NewText = " " + Qualifier + " ";
146 NewText += First->TokenText;
148 replaceToken(SourceMgr, Fixes, Range, NewText);
151 static bool endsWithSpace(const std::string &s) {
155 return isspace(s.back());
158 static bool startsWithSpace(const std::string &s) {
162 return isspace(s.front());
165 static void rotateTokens(const SourceManager &SourceMgr,
166 tooling::Replacements &Fixes, const FormatToken *First,
167 const FormatToken *Last, bool Left) {
176 // If we are rotating to the left we move the Last token to the front.
178 NewText += Last->TokenText;
182 // Then move through the other tokens.
185 if (!NewText.empty() && !endsWithSpace(NewText)) {
189 NewText += Tok->TokenText;
193 // If we are rotating to the right we move the first token to the back.
195 if (!NewText.empty() && !startsWithSpace(NewText)) {
198 NewText += First->TokenText;
201 auto Range = CharSourceRange::getCharRange(First->getStartOfNonWhitespace(),
202 Last->Tok.getEndLoc());
204 replaceToken(SourceMgr, Fixes, Range, NewText);
207 FormatToken *LeftRightQualifierAlignmentFixer::analyzeRight(
208 const SourceManager &SourceMgr, const AdditionalKeywords &Keywords,
209 tooling::Replacements &Fixes, FormatToken *Tok,
210 const std::string &Qualifier, tok::TokenKind QualifierType) {
211 // We only need to think about streams that begin with a qualifier.
212 if (!Tok->is(QualifierType))
214 // Don't concern yourself if nothing follows the qualifier.
217 if (LeftRightQualifierAlignmentFixer::isPossibleMacro(Tok->Next))
220 FormatToken *Qual = Tok->Next;
221 FormatToken *LastQual = Qual;
222 while (Qual && isQualifierOrType(Qual, ConfiguredQualifierTokens)) {
226 if (LastQual && Qual != LastQual) {
227 rotateTokens(SourceMgr, Fixes, Tok, LastQual, /*Left=*/false);
229 } else if (Tok->startsSequence(QualifierType, tok::identifier,
230 TT_TemplateOpener)) {
231 // Read from the TemplateOpener to
232 // TemplateCloser as in const ArrayRef<int> a; const ArrayRef<int> &a;
233 FormatToken *EndTemplate = Tok->Next->Next->MatchingParen;
235 // Move to the end of any template class members e.g.
236 // `Foo<int>::iterator`.
237 if (EndTemplate->startsSequence(TT_TemplateCloser, tok::coloncolon,
239 EndTemplate = EndTemplate->Next->Next;
241 if (EndTemplate && EndTemplate->Next &&
242 !EndTemplate->Next->isOneOf(tok::equal, tok::l_paren)) {
243 insertQualifierAfter(SourceMgr, Fixes, EndTemplate, Qualifier);
244 // Remove the qualifier.
245 removeToken(SourceMgr, Fixes, Tok);
248 } else if (Tok->startsSequence(QualifierType, tok::identifier)) {
249 FormatToken *Next = Tok->Next;
250 // The case `const Foo` -> `Foo const`
251 // The case `const Foo *` -> `Foo const *`
252 // The case `const Foo &` -> `Foo const &`
253 // The case `const Foo &&` -> `Foo const &&`
254 // The case `const std::Foo &&` -> `std::Foo const &&`
255 // The case `const std::Foo<T> &&` -> `std::Foo<T> const &&`
256 while (Next && Next->isOneOf(tok::identifier, tok::coloncolon)) {
259 if (Next && Next->is(TT_TemplateOpener)) {
260 Next = Next->MatchingParen;
261 // Move to the end of any template class members e.g.
262 // `Foo<int>::iterator`.
263 if (Next && Next->startsSequence(TT_TemplateCloser, tok::coloncolon,
265 Next = Next->Next->Next;
268 assert(Next && "Missing template opener");
271 if (Next && Next->isOneOf(tok::star, tok::amp, tok::ampamp) &&
272 !Tok->Next->isOneOf(Keywords.kw_override, Keywords.kw_final)) {
273 if (Next->Previous && !Next->Previous->is(QualifierType)) {
274 insertQualifierAfter(SourceMgr, Fixes, Next->Previous, Qualifier);
275 removeToken(SourceMgr, Fixes, Tok);
284 FormatToken *LeftRightQualifierAlignmentFixer::analyzeLeft(
285 const SourceManager &SourceMgr, const AdditionalKeywords &Keywords,
286 tooling::Replacements &Fixes, FormatToken *Tok,
287 const std::string &Qualifier, tok::TokenKind QualifierType) {
288 // if Tok is an identifier and possibly a macro then don't convert.
289 if (LeftRightQualifierAlignmentFixer::isPossibleMacro(Tok))
292 FormatToken *Qual = Tok;
293 FormatToken *LastQual = Qual;
294 while (Qual && isQualifierOrType(Qual, ConfiguredQualifierTokens)) {
297 if (Qual && Qual->is(QualifierType))
305 if (LastQual && Qual != LastQual && Qual->is(QualifierType)) {
306 rotateTokens(SourceMgr, Fixes, Tok, Qual, /*Left=*/true);
308 } else if (Tok->startsSequence(tok::identifier, QualifierType)) {
309 if (Tok->Next->Next && Tok->Next->Next->isOneOf(tok::identifier, tok::star,
310 tok::amp, tok::ampamp)) {
311 // Don't swap `::iterator const` to `::const iterator`.
312 if (!Tok->Previous ||
313 (Tok->Previous && !Tok->Previous->is(tok::coloncolon))) {
314 rotateTokens(SourceMgr, Fixes, Tok, Tok->Next, /*Left=*/true);
319 if (Tok->is(TT_TemplateOpener) && Tok->Next &&
320 (Tok->Next->is(tok::identifier) || Tok->Next->isSimpleTypeSpecifier()) &&
321 Tok->Next->Next && Tok->Next->Next->is(QualifierType)) {
322 rotateTokens(SourceMgr, Fixes, Tok->Next, Tok->Next->Next, /*Left=*/true);
324 if (Tok->startsSequence(tok::identifier) && Tok->Next) {
326 Tok->Previous->isOneOf(tok::star, tok::ampamp, tok::amp)) {
329 FormatToken *Next = Tok->Next;
330 // The case `std::Foo<T> const` -> `const std::Foo<T> &&`
331 while (Next && Next->isOneOf(tok::identifier, tok::coloncolon))
333 if (Next && Next->Previous &&
334 Next->Previous->startsSequence(tok::identifier, TT_TemplateOpener)) {
335 // Read from to the end of the TemplateOpener to
336 // TemplateCloser const ArrayRef<int> a; const ArrayRef<int> &a;
337 assert(Next->MatchingParen && "Missing template closer");
338 Next = Next->MatchingParen->Next;
340 // Move to the end of any template class members e.g.
341 // `Foo<int>::iterator`.
342 if (Next && Next->startsSequence(tok::coloncolon, tok::identifier))
343 Next = Next->Next->Next;
344 if (Next && Next->is(QualifierType)) {
346 insertQualifierBefore(SourceMgr, Fixes, Tok, Qualifier);
347 removeToken(SourceMgr, Fixes, Next);
351 if (Next && Next->Next &&
352 Next->Next->isOneOf(tok::amp, tok::ampamp, tok::star)) {
353 if (Next->is(QualifierType)) {
354 // Remove the qualifier.
355 insertQualifierBefore(SourceMgr, Fixes, Tok, Qualifier);
356 removeToken(SourceMgr, Fixes, Next);
364 tok::TokenKind LeftRightQualifierAlignmentFixer::getTokenFromQualifier(
365 const std::string &Qualifier) {
366 // Don't let 'type' be an identifier, but steal typeof token.
367 return llvm::StringSwitch<tok::TokenKind>(Qualifier)
368 .Case("type", tok::kw_typeof)
369 .Case("const", tok::kw_const)
370 .Case("volatile", tok::kw_volatile)
371 .Case("static", tok::kw_static)
372 .Case("inline", tok::kw_inline)
373 .Case("constexpr", tok::kw_constexpr)
374 .Case("restrict", tok::kw_restrict)
375 .Default(tok::identifier);
378 LeftRightQualifierAlignmentFixer::LeftRightQualifierAlignmentFixer(
379 const Environment &Env, const FormatStyle &Style,
380 const std::string &Qualifier,
381 const std::vector<tok::TokenKind> &QualifierTokens, bool RightAlign)
382 : TokenAnalyzer(Env, Style), Qualifier(Qualifier), RightAlign(RightAlign),
383 ConfiguredQualifierTokens(QualifierTokens) {}
385 std::pair<tooling::Replacements, unsigned>
386 LeftRightQualifierAlignmentFixer::analyze(
387 TokenAnnotator &Annotator, SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
388 FormatTokenLexer &Tokens) {
389 tooling::Replacements Fixes;
390 const AdditionalKeywords &Keywords = Tokens.getKeywords();
391 const SourceManager &SourceMgr = Env.getSourceManager();
392 AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
394 tok::TokenKind QualifierToken = getTokenFromQualifier(Qualifier);
395 assert(QualifierToken != tok::identifier && "Unrecognised Qualifier");
397 for (size_t I = 0, E = AnnotatedLines.size(); I != E; ++I) {
398 FormatToken *First = AnnotatedLines[I]->First;
399 const auto *Last = AnnotatedLines[I]->Last;
401 for (auto *Tok = First; Tok && Tok != Last && Tok->Next; Tok = Tok->Next) {
402 if (Tok->is(tok::comment))
405 Tok = analyzeRight(SourceMgr, Keywords, Fixes, Tok, Qualifier,
408 Tok = analyzeLeft(SourceMgr, Keywords, Fixes, Tok, Qualifier,
415 void QualifierAlignmentFixer::PrepareLeftRightOrdering(
416 const std::vector<std::string> &Order, std::vector<std::string> &LeftOrder,
417 std::vector<std::string> &RightOrder,
418 std::vector<tok::TokenKind> &Qualifiers) {
420 // Depending on the position of type in the order you need
421 // To iterate forward or backward through the order list as qualifier
422 // can push through each other.
423 // The Order list must define the position of "type" to signify
424 assert(llvm::is_contained(Order, "type") &&
425 "QualifierOrder must contain type");
426 // Split the Order list by type and reverse the left side.
429 for (const auto &s : Order) {
435 tok::TokenKind QualifierToken =
436 LeftRightQualifierAlignmentFixer::getTokenFromQualifier(s);
437 if (QualifierToken != tok::kw_typeof && QualifierToken != tok::identifier) {
438 Qualifiers.push_back(QualifierToken);
442 // Reverse the order for left aligned items.
443 LeftOrder.insert(LeftOrder.begin(), s);
445 RightOrder.push_back(s);
449 bool LeftRightQualifierAlignmentFixer::isQualifierOrType(
450 const FormatToken *Tok, const std::vector<tok::TokenKind> &specifiedTypes) {
451 return Tok && (Tok->isSimpleTypeSpecifier() || Tok->is(tok::kw_auto) ||
452 llvm::is_contained(specifiedTypes, Tok->Tok.getKind()));
455 // If a token is an identifier and it's upper case, it could
456 // be a macro and hence we need to be able to ignore it.
457 bool LeftRightQualifierAlignmentFixer::isPossibleMacro(const FormatToken *Tok) {
460 if (!Tok->is(tok::identifier))
462 if (Tok->TokenText.upper() == Tok->TokenText.str())
467 } // namespace format