[Clang-tidy] Check the existence of ElaboratedType's qualifiers

[junaire]

Summary

The ElaboratedType can have no qualifiers, so we should check it before
use.

Fix #issue53874(https://github.com/llvm/llvm-project/issues/53874)

[cloudhan]

As the original bug reporter, I don't think this is a proper fix for it. There seems to be some kind of bug deep in the frontend. This just hide it anyway.

[junaire]

In D119949#3328254, @cloudhan wrote:

As the original bug reporter, I don't think this is a proper fix for it. There seems to be some kind of bug deep in the frontend. This just hide it anyway.

Yeah, maybe there's a deeper issue need to be dug into. I just found the code below doesn't work as well:

namespace N {

struct S{
        static int i;
} s;
}

int main()
{
        return N::s.i;
}

Without this fix, clang-tidy will crash, but after applying this patch, clang-tidy gives the wrong fixhint:

/home/jun/workground/demo.cpp:10:9: warning: static member accessed through instance [readability-static-accessed-through-instance]
        return N::s.i;
               ^~~~~
               struct S::
      // should be N::S::

I will try to look into this issue, any comments about it are welcome :-)

[junaire]

• Only suppress canonical types when it's a TypedefNameType.
• Add more tests.

[junaire]

Simplify code a little bit.

[junaire]

Gentle ping~

[junaire]

In D119949#3338818, @junaire wrote:

Gentle ping~

Gentle ping~

[LegalizeAdulthood]

Fix one nit and ship

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

74

Simplify to !BaseExpr->getType()->isTypedefNameType();

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

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
 static unsigned getNameSpecifierNestingLevel(const QualType &QType) {
   if (const ElaboratedType *ElType = QType->getAs<ElaboratedType>()) {
-    const NestedNameSpecifier *NestedSpecifiers = ElType->getQualifier();
+    if (const NestedNameSpecifier *NestedSpecifiers = ElType->getQualifier()) {
       unsigned NameSpecifierNestingLevel = 1;
       do {
         NameSpecifierNestingLevel++;
         NestedSpecifiers = NestedSpecifiers->getPrefix();
       } while (NestedSpecifiers);
 
       return NameSpecifierNestingLevel;
     }
+  }
   return 0;
 }
 
 void StaticAccessedThroughInstanceCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "NameSpecifierNestingThreshold",
                 NameSpecifierNestingThreshold);
 }
QualType BaseType =
       BaseExpr->getType()->isPointerType()
           ? BaseExpr->getType()->getPointeeType().getUnqualifiedType()
           : BaseExpr->getType().getUnqualifiedType();
 
   const ASTContext *AstContext = Result.Context;
   PrintingPolicy PrintingPolicyWithSupressedTag(AstContext->getLangOpts());
   PrintingPolicyWithSupressedTag.SuppressTagKeyword = true;
   PrintingPolicyWithSupressedTag.SuppressUnwrittenScope = true;
+
+  PrintingPolicyWithSupressedTag.PrintCanonicalTypes =
+      !BaseExpr->getType()->isTypedefNameType();
+
   std::string BaseTypeName =
       BaseType.getAsString(PrintingPolicyWithSupressedTag);
 
   // Do not warn for CUDA built-in variables.
   if (StringRef(BaseTypeName).startswith("__cuda_builtin_"))
     return;
 
   SourceLocation MemberExprStartLoc = MemberExpression->getBeginLoc();

clang-tools-extra/test/clang-tidy/checkers/readability-static-accessed-through-instance.cpp

void static_through_instance() {
 
   CCT<int> cct;
   cct.foo(); // OK, CCT has no static members.
   cct.x;     // OK, CCT has no static members.
 
   h<4>();
 }
 
+struct SP {
+  static int I;
+} P;
+
+void usep() {
+  P.I;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member
+  // CHECK-FIXES: {{^}}  SP::I;{{$}}
+}
+
+namespace NSP {
+struct SP {
+  static int I;
+} P;
+} // namespace NSP
+
+void usensp() {
+  NSP::P.I;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member
+  // CHECK-FIXES: {{^}}  NSP::SP::I;{{$}}
+}
+
 // Overloaded member access operator
 struct Q {
   static int K;
   int y = 0;
 };
 
 int Q::K = 0;
 
void use_anonymous() {
   Anonymous Anon;
   Anon.I;
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member
   // CHECK-FIXES: {{^}}  Anonymous::I;{{$}}
 }
 
 namespace Outer {
   inline namespace Inline {
-    struct S {
-      static int I;
-    };
   }
 }
 
 void use_inline() {
   Outer::S V;
   V.I;
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: static member
   // CHECK-FIXES: {{^}}  Outer::S::I;{{$}}