[clang-tidy] Enhance modernize-use-auto to casts

[malcolm.parsons]

Summary

Extend modernize-use-auto to cases when a variable is assigned with a cast.

e.g.
Type *Ptr1 = dynamic_cast<Type*>(Ptr2);

http://llvm.org/PR25499

[malcolm.parsons]

Add functional casts to tests and doc.

[Eugene.Zelenko]

I think will be good idea to handle LLVM casts and getAs<> methods too. There are plenty of them in LLVM/Clang/etc code used for variable initialization.

See also D17765 for Boost related ideas.

[malcolm.parsons]

In D25316#563654, @Eugene.Zelenko wrote:

I think will be good idea to handle LLVM casts and getAs<> methods too. There are plenty of them in LLVM/Clang/etc code used for variable initialization.

Yes.
I plan to do that, but maybe in another changeset.

[Eugene.Zelenko]

Please mention this enhancement in in docs/ReleaseNotes.rst (in alphabetical order).

[malcolm.parsons]

Mention in release notes.

[Prazek]

Please add tests with

long long p = static_cast<long long>(4);

and the same with const at beginning. I remember I had problems with this last time (Type->SourceRange was returning only source range for the first token.
I will review patch later.

[malcolm.parsons]

In D25316#563930, @Prazek wrote:

Please add tests with

long long p = static_cast<long long>(4);

and the same with const at beginning. I remember I had problems with this last time (Type->SourceRange was returning only source range for the first token.

BuiltinTypeLoc only returns the first token:

SourceRange getLocalSourceRange() const {
  return SourceRange(getBuiltinLoc(), getBuiltinLoc());
}

The existing check fails too:

-long long *ll = new long long();
+auto long *ll = new long long();

[Prazek]

In D25316#564217, @malcolm.parsons wrote:

In D25316#563930, @Prazek wrote:

Please add tests with

long long p = static_cast<long long>(4);

and the same with const at beginning. I remember I had problems with this last time (Type->SourceRange was returning only source range for the first token.

BuiltinTypeLoc only returns the first token:

SourceRange getLocalSourceRange() const {
  return SourceRange(getBuiltinLoc(), getBuiltinLoc());
}

The existing check fails too:

-long long *ll = new long long();
+auto long *ll = new long long();

Interesting! I remember checking it half year ago, and it was working (SourceRange was returning all tokens from first one
to asterisk). I remember there was some small features introduced, like instead of
auto p = long long new;
to produce
auto *p = long long new;

Maybe it was introduced in that patch. Anyway I think this have to be fixed somehow. Either by playing with lexer, or by fixing sourceRange

[malcolm.parsons]

Add more tests.

[malcolm.parsons]

Rework handling of references

[Prazek]

Awesome to see this patch. After this one will make it to upstream, it will be much easier for me to do same with template functions.

test/clang-tidy/modernize-use-auto-cast-remove-stars.cpp

2 ↗

(On Diff #74022)

What is the difference between this test, and next test?
The name indicate that it removes star, but I see a lot of test that doesn't use star
and that seem to be duplicated with the next one.

25 ↗

(On Diff #74022)

Is it possible to simply fix the double spaces?

test/clang-tidy/modernize-use-auto-cast.cpp

14 ↗

(On Diff #74022)

How do you handle cases like

long l = static_cast<int>(i1);

I would expect it to produce warning, but not produce fixit (because it might change the behavior of program), but I still would like to get information about it because it seems like a bug.

[malcolm.parsons]

In D25316#565378, @Prazek wrote:

Awesome to see this patch. After this one will make it to upstream, it will be much easier for me to do same with template functions.

I was trying to match such functions:

varDecl(hasType(type().bind("type")),
        hasInitializer(callExpr(callee(
            functionDecl(isInstantiated(),
                         hasTemplateArgument(
                             0, refersToType(type(equalsBoundNode("type")))))
                .bind("fn")))))

test/clang-tidy/modernize-use-auto-cast-remove-stars.cpp

2 ↗

(On Diff #74022)

I could remove the duplicated tests, but the expected fixes are different so I'd like to test with and without star removal.

25 ↗

(On Diff #74022)

The existing modernize-use-auto tests have the same problem.
My codebase is clang-formatted regularly so it doesn't bother me.

[Prazek]

In D25316#565463, @malcolm.parsons wrote:

In D25316#565378, @Prazek wrote:

Awesome to see this patch. After this one will make it to upstream, it will be much easier for me to do same with template functions.

I was trying to match such functions:

varDecl(hasType(type().bind("type")),
        hasInitializer(callExpr(callee(
            functionDecl(isInstantiated(),
                         hasTemplateArgument(
                             0, refersToType(type(equalsBoundNode("type")))))
                .bind("fn")))))

I did some implementation long ago for boost-lexical-last here: https://reviews.llvm.org/D17765
My matchers were:

Finder->addMatcher(
    declStmt(has(varDecl(hasInitializer(callExpr(callee(
                             functionDecl(hasName(LEXICAL_CAST_NAME))))),
                         unless(hasType(autoType())))))
        .bind("same_type"),
    this);

Finder->addMatcher(
    declStmt(has(varDecl(hasInitializer(implicitCastExpr(has(callExpr(
                 callee(functionDecl(hasName(LEXICAL_CAST_NAME))))))))))
        .bind("different_type"),
    this);

test/clang-tidy/modernize-use-auto-cast-remove-stars.cpp

2 ↗

(On Diff #74022)

so I think the best thing to do here, is to merge 2 files together, add second RUN: with different -check-prefix and use this prefix in the tests. At least this is how the tests in LLVM works, not sure if this is implemented in check_clang_tidy.

25 ↗

(On Diff #74022)

I agree that it is not huge problem with clang-format and of course it is not required to fix it to push this patch upstream. It would be good to leave a comment somewhere with FIXME: about this, so it would be easier for some other contributor to fix it (or if it simple, just fix it in this patch :))

[malcolm.parsons]

In D25316#565567, @Prazek wrote:

functionDecl(hasName(LEXICAL_CAST_NAME))))),

I was trying to avoid specifying the name of the function so that it works for any templated function/member function that returns its first template type.

test/clang-tidy/modernize-use-auto-cast-remove-stars.cpp

25 ↗

(On Diff #74022)

There's a FIXME comment in one of the existing modernize-use-auto test files.

[Prazek]

In D25316#565574, @malcolm.parsons wrote:

In D25316#565567, @Prazek wrote:

functionDecl(hasName(LEXICAL_CAST_NAME))))),

I was trying to avoid specifying the name of the function so that it works for any templated function/member function that returns its first template type.

Good idea. I am not sure how it will work when you will run it on big codebase, so I wanted to make it configurable for any function name. But if it will work for 99% of useful cases, then it will be great!

[Prazek]

test/clang-tidy/modernize-use-auto-cast-remove-stars.cpp

25 ↗

(On Diff #74022)

Yes, but I am talking about FIXME comment in check code. IF someone reads the code, it is much more clear for them that this thing doesn't work completely, than if the programmer would see the error and would have to look at tests or execute clang-tidy to make sure that he understand code well.

[Prazek]

BTW I think changing the commit name by removing bug ID would be good, because it would be more clear that this is a feature commit, not a bug fix.
You can move t he bug id, or the link to bug to the summary section.

[aaron.ballman]

clang-tidy/modernize/UseAutoCheck.cpp

346 ↗

(On Diff #74022)

I think you should use dyn_cast here because ExprType may vary from call to call and produce an invalid cast otherwise.

404 ↗

(On Diff #74022)

Just inline the lambda expression (below as well).

clang-tidy/modernize/UseAutoCheck.h

28 ↗

(On Diff #74022)

Having the template declaration in the header, but the definition in the source file, is living a bit too close to the edge for my tastes. Since there are no function definitions in the header file, I suppose this may be okay, however.

30 ↗

(On Diff #74022)

s/message/Message

docs/clang-tidy/checks/modernize-use-auto.rst

150 ↗

(On Diff #74022)

s/has to be/is

164–165 ↗

(On Diff #74022)

Should this be moved into Known Limitations?

[malcolm.parsons]

clang-tidy/modernize/UseAutoCheck.cpp

346 ↗

(On Diff #74022)

The cast was safe in the existing check because makeDeclWithNewMatcher creates a matcher that ensures all initializers are CxxNewExpr.
makeDeclWithCastMatcher needs to be fixed.

404 ↗

(On Diff #74022)

OK.

clang-tidy/modernize/UseAutoCheck.h

30 ↗

(On Diff #74022)

Oops.

docs/clang-tidy/checks/modernize-use-auto.rst

150 ↗

(On Diff #74022)

It's a copy and paste from the section above; I'll fix both.

164–165 ↗

(On Diff #74022)

OK.

[malcolm.parsons]

Fix ast matcher
Add test
Fix parameter case
Inline lambdas
Doc fixes

[malcolm.parsons]

test/clang-tidy/modernize-use-auto-cast.cpp

14 ↗

(On Diff #74022)

The check requires the VarDecl and Initializer to have the same type, so there is no warning.
I don't think this check should warn about it.

[alexfh]

clang-tidy/modernize/UseAutoCheck.cpp

331 ↗

(On Diff #74134)

It seems that replaceExpr can be implemented in a non-generic way: GetType could be a std::function<QualType(Expr*)> and the use of ExprType in cast<ExprType>could be replaced with a check whether V->getInit()->IgnoreParenImpCasts()->getStmtClass() is a specific StmtClass. WDYT?

[malcolm.parsons]

Use std::function

[malcolm.parsons]

Really mention in release notes.

[alexfh]

clang-tidy/modernize/UseAutoCheck.cpp

252–254 ↗

(On Diff #74162)

This seems to be repeated almost verbatim three times already. It might make sense to merge the three matchers to avoid redundant computation.

test/clang-tidy/modernize-use-auto-cast-remove-stars.cpp

2 ↗

(On Diff #74022)

Custom -check-prefixes should be supported by the check_clang_tidy.py in order for this to work. It seems out of the scope of this patch.

[malcolm.parsons]

Combine matchers

[malcolm.parsons]

ping.

[alexfh]

Sorry for the delay. Feel free to ping earlier.

One more comment, otherwise looks good.

docs/clang-tidy/checks/modernize-use-auto.rst

163 ↗

(On Diff #74476)

nit: "C-style casts"

[malcolm.parsons]

Change doc to say "C-style casts".

[aaron.ballman]

Does this check properly work in the presence of macros? Those are sometimes more common in casting operations, so a few explicit tests would be good (those tests could be follow-on work if it turns out that this check doesn't play nicely with macros).

clang-tidy/modernize/UseAutoCheck.cpp

404 ↗

(On Diff #74476)

Quote use of auto and new in the diagnostic since they're syntax rather than english.

413 ↗

(On Diff #74476)

Same here.

[malcolm.parsons]

clang-tidy/modernize/UseAutoCheck.cpp

404 ↗

(On Diff #74476)

A lot of clang-tidy diagnostics don't quote syntax/functions/types:

"do not use reinterpret_cast"
"pass by value and use std::move"
"use nullptr"
"the shrink_to_fit method should be used "
"use std::move to transfer ownership"
"auto_ptr is deprecated, use unique_ptr instead"
"use auto when declaring iterators"
"use range-based for loop instead"
"use emplace_back instead of push_back"
"prefer a lambda to std::bind"
...

[malcolm.parsons]

In D25316#583651, @aaron.ballman wrote:

Does this check properly work in the presence of macros? Those are sometimes more common in casting operations, so a few explicit tests would be good (those tests could be follow-on work if it turns out that this check doesn't play nicely with macros).

Tests added in r285601.

[aaron.ballman]

clang-tidy/modernize/UseAutoCheck.cpp

404 ↗

(On Diff #74476)

clang-tidy hasn't always done a good job of following the conventions that clang uses for its diagnostics, but the reason I pointed this wording out specifically is because things like "new" are a valid word to use in an English sentence too, which makes the diagnostic text harder to understand without the quotes.

[malcolm.parsons]

clang-tidy/modernize/UseAutoCheck.cpp

404 ↗

(On Diff #74476)

The diagnostic with 'new' isn't new.

Let's cleanup the diagnostics in another patch.

clang-tools-extra/trunk/clang-tidy/modernize/UseAutoCheck.h

 public:
   UseAutoCheck(StringRef Name, ClangTidyContext *Context);
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   void replaceIterators(const DeclStmt *D, ASTContext *Context);
-  void replaceNew(const DeclStmt *D, ASTContext *Context);
+  void replaceExpr(const DeclStmt *D, ASTContext *Context,
+                   std::function<QualType(const Expr *)> GetType,
+                   StringRef Message);
 
   const bool RemoveStars;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_AUTO_H

clang-tools-extra/trunk/clang-tidy/modernize/UseAutoCheck.cpp

 
 namespace clang {
 namespace tidy {
 namespace modernize {
 namespace {
 
 const char IteratorDeclStmtId[] = "iterator_decl";
 const char DeclWithNewId[] = "decl_new";
+const char DeclWithCastId[] = "decl_cast";
 
 /// \brief Matches variable declarations that have explicit initializers that
 /// are not initializer lists.
 ///
 /// Given
 /// \code
 ///   iterator I = Container.begin();
 ///   MyType A(42);
return elaboratedType(allOf(
       // should name one of the standard iterator names.
       namesType(
           anyOf(typedefType(HasIteratorDecl), recordType(HasIteratorDecl)))));
 }
 
 /// \brief This matcher returns declaration statements that contain variable
 /// declarations with written non-list initializer for standard iterators.
 StatementMatcher makeIteratorDeclMatcher() {
-  return declStmt(
-             // At least one varDecl should be a child of the declStmt to ensure
-             // it's a declaration list and avoid matching other declarations,
-             // e.g. using directives.
-             has(varDecl()),
-             unless(has(varDecl(anyOf(
-                 unless(hasWrittenNonListInitializer()), hasType(autoType()),
-                 unless(hasType(
-                     isSugarFor(anyOf(typedefIterator(), nestedIterator(),
+  return declStmt(unless(has(
+                      varDecl(anyOf(unless(hasWrittenNonListInitializer()),
+                                    unless(hasType(isSugarFor(anyOf(
+                                        typedefIterator(), nestedIterator(),
                                         iteratorFromUsingDeclaration())))))))))
       .bind(IteratorDeclStmtId);
 }
 
 StatementMatcher makeDeclWithNewMatcher() {
   return declStmt(
-             has(varDecl()),
              unless(has(varDecl(anyOf(
                  unless(hasInitializer(ignoringParenImpCasts(cxxNewExpr()))),
-                 // Skip declarations that are already using auto.
-                 anyOf(hasType(autoType()),
-                       hasType(pointerType(pointee(autoType())))),
                  // FIXME: TypeLoc information is not reliable where CV
                  // qualifiers are concerned so these types can't be
                  // handled for now.
                  hasType(pointerType(
                      pointee(hasCanonicalType(hasLocalQualifiers())))),
 
                  // FIXME: Handle function pointers. For now we ignore them
                  // because the replacement replaces the entire type
                  // specifier source range which includes the identifier.
                  hasType(pointsTo(
                      pointsTo(parenType(innerType(functionType()))))))))))
       .bind(DeclWithNewId);
 }
 
+StatementMatcher makeDeclWithCastMatcher() {
+  return declStmt(
+             unless(has(varDecl(unless(hasInitializer(explicitCastExpr()))))))
+      .bind(DeclWithCastId);
+}
+
+StatementMatcher makeCombinedMatcher() {
+  return declStmt(
+      // At least one varDecl should be a child of the declStmt to ensure
+      // it's a declaration list and avoid matching other declarations,
+      // e.g. using directives.
+      has(varDecl()),
+      // Skip declarations that are already using auto.
+      unless(has(varDecl(anyOf(hasType(autoType()),
+                               hasType(pointerType(pointee(autoType()))),
+                               hasType(referenceType(pointee(autoType()))))))),
+      anyOf(makeIteratorDeclMatcher(), makeDeclWithNewMatcher(),
+            makeDeclWithCastMatcher()));
+}
+
 } // namespace
 
 UseAutoCheck::UseAutoCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       RemoveStars(Options.get("RemoveStars", 0)) {}
 
 void UseAutoCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "RemoveStars", RemoveStars ? 1 : 0);
 }
 
 void UseAutoCheck::registerMatchers(MatchFinder *Finder) {
   // Only register the matchers for C++; the functionality currently does not
   // provide any benefit to other languages, despite being benign.
   if (getLangOpts().CPlusPlus) {
-    Finder->addMatcher(makeIteratorDeclMatcher(), this);
-    Finder->addMatcher(makeDeclWithNewMatcher(), this);
+    Finder->addMatcher(makeCombinedMatcher(), this);
   }
 }
 
 void UseAutoCheck::replaceIterators(const DeclStmt *D, ASTContext *Context) {
   for (const auto *Dec : D->decls()) {
     const auto *V = cast<VarDecl>(Dec);
     const Expr *ExprInit = V->getInit();
 
void UseAutoCheck::replaceIterators(const DeclStmt *D, ASTContext *Context) {
   // like function pointers. Not a concern since this action only works with
   // iterators but something to keep in mind in the future.
 
   SourceRange Range(V->getTypeSourceInfo()->getTypeLoc().getSourceRange());
   diag(Range.getBegin(), "use auto when declaring iterators")
       << FixItHint::CreateReplacement(Range, "auto");
 }
 
-void UseAutoCheck::replaceNew(const DeclStmt *D, ASTContext *Context) {
+void UseAutoCheck::replaceExpr(const DeclStmt *D, ASTContext *Context,
+                               std::function<QualType(const Expr *)> GetType,
+                               StringRef Message) {
   const auto *FirstDecl = dyn_cast<VarDecl>(*D->decl_begin());
   // Ensure that there is at least one VarDecl within the DeclStmt.
   if (!FirstDecl)
     return;
 
   const QualType FirstDeclType = FirstDecl->getType().getCanonicalType();
 
   std::vector<FixItHint> StarRemovals;
   for (const auto *Dec : D->decls()) {
     const auto *V = cast<VarDecl>(Dec);
     // Ensure that every DeclStmt child is a VarDecl.
     if (!V)
       return;
 
-    const auto *NewExpr = cast<CXXNewExpr>(V->getInit()->IgnoreParenImpCasts());
-    // Ensure that every VarDecl has a CXXNewExpr initializer.
-    if (!NewExpr)
+    const auto *Expr = V->getInit()->IgnoreParenImpCasts();
+    // Ensure that every VarDecl has an initializer.
+    if (!Expr)
       return;
 
     // If VarDecl and Initializer have mismatching unqualified types.
-    if (!Context->hasSameUnqualifiedType(V->getType(), NewExpr->getType()))
+    if (!Context->hasSameUnqualifiedType(V->getType(), GetType(Expr)))
       return;
 
     // All subsequent variables in this declaration should have the same
     // canonical type.  For example, we don't want to use `auto` in
     // `T *p = new T, **pp = new T*;`.
     if (FirstDeclType != V->getType().getCanonicalType())
       return;
 
void UseAutoCheck::replaceExpr(const DeclStmt *D, ASTContext *Context,
   // information is not reliable where CV qualifiers are concerned so we can't
   // do anything about this case for now.
   TypeLoc Loc = FirstDecl->getTypeSourceInfo()->getTypeLoc();
   if (!RemoveStars) {
     while (Loc.getTypeLocClass() == TypeLoc::Pointer ||
            Loc.getTypeLocClass() == TypeLoc::Qualified)
       Loc = Loc.getNextTypeLoc();
   }
+  while (Loc.getTypeLocClass() == TypeLoc::LValueReference ||
+         Loc.getTypeLocClass() == TypeLoc::RValueReference ||
+         Loc.getTypeLocClass() == TypeLoc::Qualified) {
+    Loc = Loc.getNextTypeLoc();
+  }
   SourceRange Range(Loc.getSourceRange());
-  auto Diag = diag(Range.getBegin(), "use auto when initializing with new"
-                                     " to avoid duplicating the type name");
+  auto Diag = diag(Range.getBegin(), Message);
 
   // Space after 'auto' to handle cases where the '*' in the pointer type is
   // next to the identifier. This avoids changing 'int *p' into 'autop'.
   Diag << FixItHint::CreateReplacement(Range, RemoveStars ? "auto " : "auto")
        << StarRemovals;
 }
 
 void UseAutoCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *Decl = Result.Nodes.getNodeAs<DeclStmt>(IteratorDeclStmtId)) {
     replaceIterators(Decl, Result.Context);
   } else if (const auto *Decl =
                  Result.Nodes.getNodeAs<DeclStmt>(DeclWithNewId)) {
-    replaceNew(Decl, Result.Context);
+    replaceExpr(Decl, Result.Context,
+                [](const Expr *Expr) { return Expr->getType(); },
+                "use auto when initializing with new to avoid "
+                "duplicating the type name");
+  } else if (const auto *Decl =
+                 Result.Nodes.getNodeAs<DeclStmt>(DeclWithCastId)) {
+    replaceExpr(
+        Decl, Result.Context,
+        [](const Expr *Expr) {
+          return cast<ExplicitCastExpr>(Expr)->getTypeAsWritten();
+        },
+        "use auto when initializing with a cast to avoid duplicating the type "
+        "name");
   } else {
     llvm_unreachable("Bad Callback. No node provided.");
   }
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/docs/ReleaseNotes.rst

 - `misc-pointer-and-integral-operation` check was removed.
 
 - New `misc-use-after-move
   <http://clang.llvm.org/extra/clang-tidy/checks/misc-use-after-move.html>`_ check
 
   Warns if an object is used after it has been moved, without an intervening
   reinitialization.
 
+- The `modernize-use-auto
+  <http://clang.llvm.org/extra/clang-tidy/checks/modernize.html>`_ check
+  now warns about variable declarations that are initialized with a cast.
+
 - New `mpi-buffer-deref
   <http://clang.llvm.org/extra/clang-tidy/checks/mpi-buffer-deref.html>`_ check
 
   Flags buffers which are insufficiently dereferenced when passed to an MPI function call.
 
 - New `mpi-type-mismatch
   <http://clang.llvm.org/extra/clang-tidy/checks/mpi-type-mismatch.html>`_ check
 

clang-tools-extra/trunk/docs/clang-tidy/checks/modernize-use-auto.rst

 * The initializer for the variable being declared is not a braced initializer
   list. Otherwise, use of ``auto`` would cause the type of the variable to be
   deduced as ``std::initializer_list``.
 
 New expressions
 ---------------
 
 Frequently, when a pointer is declared and initialized with ``new``, the
-pointee type has to be written twice: in the declaration type and in the
+pointee type is written twice: in the declaration type and in the
 ``new`` expression. In this cases, the declaration type can be replaced with
 ``auto`` improving readability and maintainability.
 
 .. code-block:: c++
 
   TypeName *my_pointer = new TypeName(my_param);
 
   // becomes

 .. code-block:: c++
 
   TypeName *my_first_pointer = new TypeName, *my_second_pointer = new TypeName;
 
   // becomes
 
   auto *my_first_pointer = new TypeName, *my_second_pointer = new TypeName;
 
+Cast expressions
+----------------
+
+Frequently, when a variable is declared and initialized with a cast, the
+variable type is written twice: in the declaration type and in the
+cast expression. In this cases, the declaration type can be replaced with
+``auto`` improving readability and maintainability.
+
+.. code-block:: c++
+
+  TypeName *my_pointer = static_cast<TypeName>(my_param);
+
+  // becomes
+
+  auto *my_pointer = static_cast<TypeName>(my_param);
+
+The check handles ``static_cast``, ``dynamic_cast``, ``const_cast``,
+``reinterpret_cast``, functional casts and C-style casts.
+
 Known Limitations
 -----------------
 
 * If the initializer is an explicit conversion constructor, the check will not
   replace the type specifier even though it would be safe to do so.
 
 * User-defined iterators are not handled at this time.
 
+* Function templates that behave as casts, such as ``llvm::dyn_cast``,
+  ``boost::lexical_cast`` or ``gsl::narrow_cast`` are not handled.
+
 Options
 -------
 
 .. option:: RemoveStars
 
    If the option is set to non-zero (default is `0`), the check will remove
    stars from the non-typedef pointer types when replacing type names with
    ``auto``. Otherwise, the check will leave stars. For example:

clang-tools-extra/trunk/test/clang-tidy/modernize-use-auto-cast-remove-stars.cpp

+// RUN: %check_clang_tidy %s modernize-use-auto %t -- \
+// RUN:   -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: '1'}]}" \
+// RUN:   -- -std=c++11
+
+struct A {
+  virtual ~A() {}
+};
+
+struct B : public A {};
+
+struct C {};
+
+void f_static_cast() {
+  long l = 1;
+  int i1 = static_cast<int>(l);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto  i1 = static_cast<int>(l);
+
+  const int i2 = static_cast<int>(l);
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: const auto  i2 = static_cast<int>(l);
+
+  long long ll = static_cast<long long>(l);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto  ll = static_cast<long long>(l);
+  unsigned long long ull = static_cast<unsigned long long>(l);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto  ull = static_cast<unsigned long long>(l);
+  unsigned int ui = static_cast<unsigned int>(l);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto  ui = static_cast<unsigned int>(l);
+  long double ld = static_cast<long double>(l);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto  ld = static_cast<long double>(l);
+
+  A *a = new B();
+  B *b1 = static_cast<B *>(a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto b1 = static_cast<B *>(a);
+
+  B *const b2 = static_cast<B *>(a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto const b2 = static_cast<B *>(a);
+
+  const B *b3 = static_cast<const B *>(a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto b3 = static_cast<const B *>(a);
+
+  B &b4 = static_cast<B &>(*a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto  &b4 = static_cast<B &>(*a);
+
+  const B &b5 = static_cast<const B &>(*a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: const auto  &b5 = static_cast<const B &>(*a);
+
+  B &b6 = static_cast<B &>(*a), &b7 = static_cast<B &>(*a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto  &b6 = static_cast<B &>(*a), &b7 = static_cast<B &>(*a);
+
+  // Don't warn when auto is already being used.
+  auto i3 = static_cast<int>(l);
+  auto *b8 = static_cast<B *>(a);
+  auto &b9 = static_cast<B &>(*a);
+}
+
+void f_dynamic_cast() {
+  A *a = new B();
+  B *b1 = dynamic_cast<B *>(a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto b1 = dynamic_cast<B *>(a);
+
+  B &b2 = dynamic_cast<B &>(*a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto  &b2 = dynamic_cast<B &>(*a);
+}
+
+void f_reinterpret_cast() {
+  auto *a = new A();
+  C *c1 = reinterpret_cast<C *>(a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto c1 = reinterpret_cast<C *>(a);
+
+  C &c2 = reinterpret_cast<C &>(*a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto  &c2 = reinterpret_cast<C &>(*a);
+}
+
+void f_const_cast() {
+  const A *a1 = new A();
+  A *a2 = const_cast<A *>(a1);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto a2 = const_cast<A *>(a1);
+  A &a3 = const_cast<A &>(*a1);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto  &a3 = const_cast<A &>(*a1);
+}
+
+void f_cstyle_cast() {
+  auto *a = new A();
+  C *c1 = (C *)a;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto c1 = (C *)a;
+
+  C &c2 = (C &)*a;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto  &c2 = (C &)*a;
+}
+
+void f_functional_cast() {
+  long l = 1;
+  int i1 = int(l);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto  i1 = int(l);
+
+  B b;
+  A a = A(b);
+}

clang-tools-extra/trunk/test/clang-tidy/modernize-use-auto-cast.cpp

+// RUN: %check_clang_tidy %s modernize-use-auto %t -- -- \
+// RUN:   -std=c++11 -I %S/Inputs/modernize-use-auto
+
+struct A {
+  virtual ~A() {}
+};
+
+struct B : public A {};
+
+struct C {};
+
+void f_static_cast() {
+  long l = 1;
+  int i1 = static_cast<int>(l);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto i1 = static_cast<int>(l);
+
+  const int i2 = static_cast<int>(l);
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: const auto i2 = static_cast<int>(l);
+
+  long long ll = static_cast<long long>(l);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto ll = static_cast<long long>(l);
+  unsigned long long ull = static_cast<unsigned long long>(l);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto ull = static_cast<unsigned long long>(l);
+  unsigned int ui = static_cast<unsigned int>(l);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto ui = static_cast<unsigned int>(l);
+  long double ld = static_cast<long double>(l);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto ld = static_cast<long double>(l);
+
+  A *a = new B();
+  B *b1 = static_cast<B *>(a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto *b1 = static_cast<B *>(a);
+
+  B *const b2 = static_cast<B *>(a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto *const b2 = static_cast<B *>(a);
+
+  const B *b3 = static_cast<const B *>(a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: const auto *b3 = static_cast<const B *>(a);
+
+  B &b4 = static_cast<B &>(*a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto &b4 = static_cast<B &>(*a);
+
+  const B &b5 = static_cast<const B &>(*a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: const auto &b5 = static_cast<const B &>(*a);
+
+  B &b6 = static_cast<B &>(*a), &b7 = static_cast<B &>(*a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto &b6 = static_cast<B &>(*a), &b7 = static_cast<B &>(*a);
+
+  // Don't warn when non-cast involved
+  long double cast = static_cast<long double>(l), noncast = 5;
+
+  // Don't warn when auto is already being used.
+  auto i3 = static_cast<int>(l);
+  auto *b8 = static_cast<B *>(a);
+  auto &b9 = static_cast<B &>(*a);
+}
+
+void f_dynamic_cast() {
+  A *a = new B();
+  B *b1 = dynamic_cast<B *>(a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto *b1 = dynamic_cast<B *>(a);
+
+  B &b2 = dynamic_cast<B &>(*a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto &b2 = dynamic_cast<B &>(*a);
+}
+
+void f_reinterpret_cast() {
+  auto *a = new A();
+  C *c1 = reinterpret_cast<C *>(a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto *c1 = reinterpret_cast<C *>(a);
+
+  C &c2 = reinterpret_cast<C &>(*a);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto &c2 = reinterpret_cast<C &>(*a);
+}
+
+void f_const_cast() {
+  const A *a1 = new A();
+  A *a2 = const_cast<A *>(a1);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto *a2 = const_cast<A *>(a1);
+  A &a3 = const_cast<A &>(*a1);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto &a3 = const_cast<A &>(*a1);
+}
+
+void f_cstyle_cast() {
+  auto *a = new A();
+  C *c1 = (C *)a;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto *c1 = (C *)a;
+
+  C &c2 = (C &)*a;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto &c2 = (C &)*a;
+}
+
+void f_functional_cast() {
+  long l = 1;
+  int i1 = int(l);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with a cast to avoid duplicating the type name
+  // CHECK-FIXES: auto i1 = int(l);
+
+  B b;
+  A a = A(b);
+}

clang-tools-extra/trunk/test/clang-tidy/modernize-use-auto-new.cpp

void auto_new() {
   MyType *a_new = new MyType();
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with new
   // CHECK-FIXES: auto *a_new = new MyType();
 
   static MyType *a_static = new MyType();
   // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use auto when initializing with new
   // CHECK-FIXES: static auto *a_static = new MyType();
 
+  long long *ll = new long long();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when initializing with new
+  // CHECK-FIXES: auto *ll = new long long();
+
   MyType *derived = new MyDerivedType();
 
   void *vd = new MyType();
 
   // CV-qualifier tests.
   //
   // NOTE : the form "type const" is expected here because of a deficiency in
   // TypeLoc where CV qualifiers are not considered part of the type location