Clang: Don't warn about unused private fields of types declared maybe_unused

[hans]

Summary

The compiler should not warn on code such as:

class [[maybe_unused]] MaybeUnusedClass {};
class C {
  MaybeUnusedClass c;
};

Patch based on comments on the bug by Shafik and Aaron.

Fixes #61334

[aaron.ballman]

Thank you for working on this! Mostly looks good, but I did have another test request. Also, please be sure to add a release note for the fix.

clang/test/SemaCXX/warn-unused-private-field.cpp

291–292

Let's try one more thing:

template <typename Ty, typename Uy>
class C2 {
  Ty c; // no-warning
  Uy d; // warning
};

class [[maybe_unused]] Good {};
class Bad {};

C2<Good, Bad> c;

[hans]

Add release note.

clang/test/SemaCXX/warn-unused-private-field.cpp

291–292

The !FD->getParent()->isDependentContext() condition prevents the warning from firing on either C2<>::c or d. (It seems that was there from the beginning: https://github.com/llvm/llvm-project/commit/0baec549a3f49d8c04a0092917f758cc89ef238d#diff-9ced4fa47ee2b9c03b6996ce89a1d131c0f5b71013993bc582209f50d5e934daR1649)

[aaron.ballman]

clang/test/SemaCXX/warn-unused-private-field.cpp

291–292

Hmmm. I think that's intended to ensure we don't diagnose before we've instantiated the template, but once we instantiate with C2<Good, Bad> c;, the field decl is no longer in a dependent context and we should still diagnose when instantiating, right?

[hans]

clang/test/SemaCXX/warn-unused-private-field.cpp

291–292

I tried, and it's not diagnosing: https://godbolt.org/z/osnWbofY5

I'm guessing the motivation was that we shouldn't warn about things that depend on how the template is instantiated, since that could make it hard to write a warning-free template definition.

[aaron.ballman]

LGTM!

clang/test/SemaCXX/warn-unused-private-field.cpp

291–292

I don't think this is your bug to fix, but I still think this is a bug. [[maybe_unused]] is precisely how you would get warning-free template definitions -- you'd put the attribute on the field itself instead of on the type passed in as a template argument.

[shafik]

LGTM

[aaron.ballman]

Thanks! I filed https://github.com/llvm/llvm-project/issues/65111 to track the template instantiation concerns

clang/lib/Sema/SemaDeclCXX.cpp

Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
 
   if (isInstField) {
     FieldDecl *FD = cast<FieldDecl>(Member);
     FieldCollector->Add(FD);
 
     if (!Diags.isIgnored(diag::warn_unused_private_field, FD->getLocation())) {
       // Remember all explicit private FieldDecls that have a name, no side
       // effects and are not part of a dependent type declaration.
+
+      auto DeclHasUnusedAttr = [](const QualType &T) {
+        if (const TagDecl *TD = T->getAsTagDecl())
+          return TD->hasAttr<UnusedAttr>();
+        if (const TypedefType *TDT = T->getAs<TypedefType>())
+          return TDT->getDecl()->hasAttr<UnusedAttr>();
+        return false;
+      };
+
       if (!FD->isImplicit() && FD->getDeclName() &&
           FD->getAccess() == AS_private &&
           !FD->hasAttr<UnusedAttr>() &&
           !FD->getParent()->isDependentContext() &&
+          !DeclHasUnusedAttr(FD->getType()) &&
           !InitializationHasSideEffects(*FD))
         UnusedPrivateFields.insert(FD);
     }
   }
 
   return Member;
 }
 

clang/test/SemaCXX/warn-unused-private-field.cpp

 
 class defaulted_special_member {
 public:
   defaulted_special_member(const defaulted_special_member&) = default;
 
 private:
   int n; // expected-warning{{private field 'n' is not used}}
 };
+
+namespace pr61334 {
+class [[maybe_unused]] MaybeUnusedClass {};
+enum [[maybe_unused]] MaybeUnusedEnum {};
+typedef int MaybeUnusedTypedef [[maybe_unused]];
+class C {
+  MaybeUnusedClass c; // no-warning
+  MaybeUnusedEnum e; // no-warning
+  MaybeUnusedTypedef t; // no-warning
+};
+}