[clang-tidy] fix readability-avoid-const-params-in-decls creating invalid code in fix-its

[mgehre]

Summary

The Fix-Its for the added test cases were before:
-void F11(const unsigned int /*version*/);
+void F11(unsigned int int /*version*/);

-void F12(const bool b = true);
+void F12(_Bool true);

[fowles]

Thanks for doing this! I tried a bunch of variants and just couldn't figure it out.

[alexfh]

LG. Thank you!

clang-tools-extra/trunk/clang-tidy/readability/AvoidConstParamsInDecls.cpp

SourceRange getTypeRange(const ParmVarDecl &Param) {
   if (Param.getIdentifier() != nullptr)
     return SourceRange(Param.getLocStart(),
                        Param.getLocEnd().getLocWithOffset(-1));
   return Param.getSourceRange();
 }
 
 } // namespace
 
-
 void AvoidConstParamsInDecls::registerMatchers(MatchFinder *Finder) {
   const auto ConstParamDecl =
       parmVarDecl(hasType(qualType(isConstQualified()))).bind("param");
   Finder->addMatcher(functionDecl(unless(isDefinition()),
                                   has(typeLoc(forEach(ConstParamDecl))))
                          .bind("func"),
                      this);
 }
 
+// Re-lex the tokens to get precise location of last 'const'
+static Token ConstTok(CharSourceRange Range,
+                      const MatchFinder::MatchResult &Result) {
+  const SourceManager &Sources = *Result.SourceManager;
+  std::pair<FileID, unsigned> LocInfo =
+      Sources.getDecomposedLoc(Range.getBegin());
+  StringRef File = Sources.getBufferData(LocInfo.first);
+  const char *TokenBegin = File.data() + LocInfo.second;
+  Lexer RawLexer(Sources.getLocForStartOfFile(LocInfo.first),
+                 Result.Context->getLangOpts(), File.begin(), TokenBegin,
+                 File.end());
+  Token Tok;
+  Token ConstTok;
+  while (!RawLexer.LexFromRawLexer(Tok)) {
+    if (Sources.isBeforeInTranslationUnit(Range.getEnd(), Tok.getLocation()))
+      break;
+    if (Tok.is(tok::raw_identifier)) {
+      IdentifierInfo &Info = Result.Context->Idents.get(StringRef(
+          Sources.getCharacterData(Tok.getLocation()), Tok.getLength()));
+      Tok.setIdentifierInfo(&Info);
+      Tok.setKind(Info.getTokenID());
+    }
+    if (Tok.is(tok::kw_const))
+      ConstTok = Tok;
+  }
+  return ConstTok;
+}
+
 void AvoidConstParamsInDecls::check(const MatchFinder::MatchResult &Result) {
   const auto *Func = Result.Nodes.getNodeAs<FunctionDecl>("func");
   const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>("param");
 
-  QualType Type = Param->getType();
-  if (!Type.isLocalConstQualified())
+  if (!Param->getType().isLocalConstQualified())
     return;
 
-  Type.removeLocalConst();
-
   auto Diag = diag(Param->getLocStart(),
                    "parameter %0 is const-qualified in the function "
                    "declaration; const-qualification of parameters only has an "
                    "effect in function definitions");
   if (Param->getName().empty()) {
     for (unsigned int i = 0; i < Func->getNumParams(); ++i) {
       if (Param == Func->getParamDecl(i)) {
         Diag << (i + 1);
         break;
       }
     }
   } else {
     Diag << Param;
   }
-  Diag << FixItHint::CreateReplacement(getTypeRange(*Param),
-                                       Type.getAsString());
+
+  CharSourceRange FileRange = Lexer::makeFileCharRange(
+      CharSourceRange::getTokenRange(getTypeRange(*Param)),
+      *Result.SourceManager, Result.Context->getLangOpts());
+
+  if (!FileRange.isValid())
+    return;
+
+  Token Tok = ConstTok(FileRange, Result);
+  Diag << FixItHint::CreateRemoval(
+      CharSourceRange::getTokenRange(Tok.getLocation(), Tok.getLocation()));
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/test/clang-tidy/readability-avoid-const-params-in-decls.cpp

 // RUN: %check_clang_tidy %s readability-avoid-const-params-in-decls %t
 
 using alias_type = bool;
 using alias_const_type = const bool;
 
 
 void F1(const int i);
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: parameter 'i' is const-qualified in the function declaration; const-qualification of parameters only has an effect in function definitions [readability-avoid-const-params-in-decls]
 // CHECK-FIXES: void F1(int i);
 
 void F2(const int *const i);
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: parameter 'i' is const-qualified
-// CHECK-FIXES: void F2(const int * i);
+// CHECK-FIXES: void F2(const int *i);
 
 void F3(int const i);
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: parameter 'i' is const-qualified
 // CHECK-FIXES: void F3(int i);
 
 void F4(alias_type const i);
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: parameter 'i' is const-qualified
 // CHECK-FIXES: void F4(alias_type i);
 
 void F5(const int);
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: parameter 1 is const-qualified
 // CHECK-FIXES: void F5(int);
 
 void F6(const int *const);
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: parameter 1 is const-qualified
-// BUG(b/27584482): void F6(const int *);  should be produced
+// CHECK-FIXES: void F6(const int *);
 
 void F7(int, const int);
 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: parameter 2 is const-qualified
 // CHECK-FIXES: void F7(int, int);
 
 void F8(const int, const int);
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: parameter 1 is const-qualified
 // CHECK-MESSAGES: :[[@LINE-2]]:20: warning: parameter 2 is const-qualified
 // CHECK-FIXES: void F8(int, int);
 
 void F9(const int long_name);
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: parameter 'long_name'
 // CHECK-FIXES: void F9(int long_name);
 
 void F10(const int *const *const long_name);
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: parameter 'long_name'
-// CHECK-FIXES: void F10(const int *const * long_name);
+// CHECK-FIXES: void F10(const int *const *long_name);
 
+void F11(const unsigned int /*v*/);
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: parameter 1
+// CHECK-FIXES: void F11(unsigned int /*v*/);
+
+void F12(const bool b = true);
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: parameter 'b'
+// CHECK-FIXES: void F12(bool b = true);
 
 struct Foo {
   Foo(const int i);
   // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: parameter 'i'
   // CHECK-FIXES: Foo(int i);
 
   void operator()(const int i);
   // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: parameter 'i'