[clang-tidy] Add IgnoreAliasing option to readability-qualified-auto check

clang-tools-extra/clang-tidy/readability/QualifiedAutoCheck.cpp

@@ -106,12 +106,14 @@ QualifiedAutoCheck::QualifiedAutoCheck(StringRef Name,
     : ClangTidyCheck(Name, Context),
       AddConstToQualified(Options.get("AddConstToQualified", true)),
       AllowedTypes(
-          utils::options::parseStringList(Options.get("AllowedTypes", ""))) {}
+          utils::options::parseStringList(Options.get("AllowedTypes", ""))),
+      IgnoreAliasing(Options.get("IgnoreAliasing", true)) {}
 
 void QualifiedAutoCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "AddConstToQualified", AddConstToQualified);
   Options.store(Opts, "AllowedTypes",
                 utils::options::serializeStringList(AllowedTypes));
+  Options.store(Opts, "IgnoreAliasing", IgnoreAliasing);
 }
 
 void QualifiedAutoCheck::registerMatchers(MatchFinder *Finder) {
@@ -134,14 +136,26 @@ void QualifiedAutoCheck::registerMatchers(MatchFinder *Finder) {
 
   auto IsBoundToType = refersToType(equalsBoundNode("type"));
   auto UnlessFunctionType = unless(hasUnqualifiedDesugaredType(functionType()));
-  auto IsAutoDeducedToPointer = [](const std::vector<StringRef> &AllowedTypes,
-                                   const auto &...InnerMatchers) {
-    return autoType(hasDeducedType(
-        hasUnqualifiedDesugaredType(pointerType(pointee(InnerMatchers...))),
-        unless(hasUnqualifiedType(
-            matchers::matchesAnyListedTypeName(AllowedTypes, false))),
-        unless(pointerType(pointee(hasUnqualifiedType(
-            matchers::matchesAnyListedTypeName(AllowedTypes, false)))))));
+  auto IsAutoDeducedToPointer = [this](
+                                    const std::vector<StringRef> &AllowedTypes,
+                                    const auto &...InnerMatchers) {
+    if (this->IgnoreAliasing) {
+      return autoType(hasDeducedType(
+          hasUnqualifiedDesugaredType(pointerType(pointee(InnerMatchers...))),
+          unless(hasUnqualifiedType(
+              matchers::matchesAnyListedTypeName(AllowedTypes, false))),
+          unless(pointerType(pointee(hasUnqualifiedType(
+              matchers::matchesAnyListedTypeName(AllowedTypes, false)))))));
+    } else {
+      return autoType(hasDeducedType(
+          anyOf(qualType(pointerType(pointee(InnerMatchers...))),
+                qualType(substTemplateTypeParmType(hasReplacementType(
+                    pointerType(pointee(InnerMatchers...)))))),
+          unless(hasUnqualifiedType(
+              matchers::matchesAnyListedTypeName(AllowedTypes, false))),
+          unless(pointerType(pointee(hasUnqualifiedType(
+              matchers::matchesAnyListedTypeName(AllowedTypes, false)))))));
+    }
   };
 
   Finder->addMatcher(

clang-tools-extra/clang-tidy/readability/QualifiedAutoCheck.h

@@ -32,6 +32,7 @@ class QualifiedAutoCheck : public ClangTidyCheck {
 private:
   const bool AddConstToQualified;
   const std::vector<StringRef> AllowedTypes;
+  const bool IgnoreAliasing;
 };
 
 } // namespace clang::tidy::readability

clang-tools-extra/docs/ReleaseNotes.rst

@@ -374,6 +374,8 @@ Changes in existing checks
 - Improved :doc:`readability-qualified-auto
   <clang-tidy/checks/readability/qualified-auto>` check by adding the option
   `AllowedTypes`, that excludes specified types from adding qualifiers.
+  Added the option `IgnoreAliasing`, that allows not looking at underlying
+  types of type aliases.
 
 - Improved :doc:`readability-redundant-inline-specifier
   <clang-tidy/checks/readability/redundant-inline-specifier>` check by fixing

clang-tools-extra/docs/clang-tidy/checks/readability/qualified-auto.rst

@@ -96,3 +96,49 @@ Note in the LLVM alias, the default value is `false`.
   matched against only the type name (i.e. ``Type``). E.g. to suppress reports
   for ``std::array`` iterators use `std::array<.*>::(const_)?iterator` string.
   The default is an empty string.
+
+.. option:: IgnoreAliasing
+
+  If set to `true` the check will use the underlying type to determine the type
+  that ``auto`` is deduced to.
+  If set to `false` the check will not look beyond the first type alias.
+  Default value is `true`.
+
+.. code-block:: c++
+
+   using IntPtr = int*;
+   IntPtr foo();
+
+   auto bar = foo();
+
+If :option:`IgnoreAliasing` is set to `true`, it will be transformed into:
+
+.. code-block:: c++
+
+   auto *bar = foo();
+
+Otherwise no changes will occur.
+
+Limitations
+-----------
+
+When :option:`IgnoreAliasing` is set to `false`, there are cases where
+Clang has not preserved the type alias and the underlying type will be used so
+false positives may occur.
+For example:
+
+.. code-block:: c++
+
+  #include <vector>
+
+  void change(int&);
+
+  using IntPtr = int *; // Relevant typedef
+
+  void loopPtr(const std::vector<IntPtr> &VectorIntPtr) {
+
+    // May fail for IgnoreAliasing==false as AST does not have the IntPtr
+    for (auto Data : VectorIntPtr) {
+      change(*Data);
+    }
+  }