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

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

@@ -107,13 +107,13 @@ QualifiedAutoCheck::QualifiedAutoCheck(StringRef Name,
       AddConstToQualified(Options.get("AddConstToQualified", true)),
       AllowedTypes(
           utils::options::parseStringList(Options.get("AllowedTypes", ""))),
-      RespectOpaqueTypes(Options.get("RespectOpaqueTypes", false)) {}
+      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, "RespectOpaqueTypes", RespectOpaqueTypes);
+  Options.store(Opts, "IgnoreAliasing", IgnoreAliasing);
 }
 
 void QualifiedAutoCheck::registerMatchers(MatchFinder *Finder) {
@@ -136,11 +136,11 @@ void QualifiedAutoCheck::registerMatchers(MatchFinder *Finder) {
 
   auto IsBoundToType = refersToType(equalsBoundNode("type"));
   auto UnlessFunctionType = unless(hasUnqualifiedDesugaredType(functionType()));
-  auto RespectOpaqueTypes = this->RespectOpaqueTypes;
-  auto IsAutoDeducedToPointer = [&RespectOpaqueTypes](
+  auto IgnoreAliasing = this->IgnoreAliasing;
+  auto IsAutoDeducedToPointer = [&IgnoreAliasing](
                                     const std::vector<StringRef> &AllowedTypes,
                                     const auto &...InnerMatchers) {
-    if (!RespectOpaqueTypes) {
+    if (IgnoreAliasing) {
       return autoType(hasDeducedType(
           hasUnqualifiedDesugaredType(pointerType(pointee(InnerMatchers...))),
           unless(hasUnqualifiedType(

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

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

clang-tools-extra/docs/ReleaseNotes.rst

@@ -374,7 +374,7 @@ 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 `RespectOpaqueTypes`, that allows not looking at underlying
+  Added the option `IgnoreAliasing`, that allows not looking at underlying
   types of type aliases.
 
 - Improved :doc:`readability-redundant-inline-specifier

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

@@ -97,10 +97,10 @@ Note in the LLVM alias, the default value is `false`.
   for ``std::array`` iterators use `std::array<.*>::(const_)?iterator` string.
   The default is an empty string.
 
-.. option:: RespectOpaqueTypes
+.. option:: IgnoreAliasing
 
-  If set to `false` the check will use the canonical type to determine the type that ``auto`` is deduced to.
-  If set to `true` the check will not look beyond the first type alias. Default value is `false`.
+  If set to `true` the check will use the canonical 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++
 
@@ -109,10 +109,32 @@ Note in the LLVM alias, the default value is `false`.
 
    auto bar = foo();
 
-If RespectOpaqueTypes is set to `false`, it will be transformed into:
+If IgnoreAliasing is set to `true`, it will be transformed into:
 
 .. code-block:: c++
 
    auto *bar = foo();
 
 Otherwise no changes will occur.
+
+Limitations
+-----------
+
+When IgnoreAliasing is set to `false`, there are cases where Clang has not preserved the sugar
+and the canonical 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) {
+
+    // Currently fails for IgnoreAliasing==false as AST does not have the IntPtr
+    for (auto Data : VectorIntPtr) {
+      change(*Data);
+    }
+  }