`-Wunused-private-field` not reported for `[[gnu::warn_unused]]` annotated type when empty constructors are present

[firewave]

class [[gnu::warn_unused]] S1 {
public:
    S1() {}
};

class [[gnu::warn_unused]] S2 {
public:
    S2() = default;
};

class [[gnu::warn_unused]] S3 {
public:
    S3();
};

class [[gnu::warn_unused]] S4 {
};

class C {
public:
    C() {}

private:
    const S1 s1; // no warning
    const S2 s2; // warning
    const S3 s3; // no warning
    const S4 s4; // warning
};

<source>:25:14: warning: private field 's2' is not used [-Wunused-private-field]
   25 |     const S2 s2; // warning
      |              ^
<source>:27:14: warning: private field 's4' is not used [-Wunused-private-field]
   27 |     const S4 s4; // warning
      |              ^

https://godbolt.org/z/rjcEMzn96

If you change the C constructor to = default all are reported regardless of the other constructor.

[shafik]

So we have IsUnusedPrivateField:

llvm-project/clang/lib/Sema/SemaDeclCXX.cpp

Lines 3444 to 3456 in 2800ac2

	static bool IsUnusedPrivateField(const FieldDecl *FD) {
	if (FD->getAccess() == AS_private && FD->getDeclName()) {
	QualType FieldType = FD->getType();
	if (HasAttribute<WarnUnusedAttr>(FieldType))
	return true;
	return !FD->isImplicit() && !FD->hasAttr<UnusedAttr>() &&
	!FD->getParent()->isDependentContext() &&
	!HasAttribute<UnusedAttr>(FieldType) &&
	!InitializationHasSideEffects(*FD);
	}
	return false;
	}

it uses InitializationHasSideEffects:

llvm-project/clang/lib/Sema/SemaDeclCXX.cpp

Lines 3375 to 3383 in 2800ac2

	static bool InitializationHasSideEffects(const FieldDecl &FD) {
	const Type *T = FD.getType()->getBaseElementTypeUnsafe();
	// FIXME: Destruction of ObjC lifetime types has side-effects.
	if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
	return !RD->isCompleteDefinition() ||
	!RD->hasTrivialDefaultConstructor() ||
	!RD->hasTrivialDestructor();
	return false;
	}

and I think the cases fall under the !FD->isImplicit() and !InitializationHasSideEffects(*FD)

I have not dug deeper.

[firewave]

I interpret the [[gnu::warn_unused]] attribute as saying "I have no side effects and even if, ignore them".

[firewave]

I forgot to mention that if you add a private POD type member to C it is reported regardless of how the C constructor is implemented. I had that in the example but I removed it as not to distract.

[a-tarasyuk]

The first stage works correctly and UnusedPrivateFields contains 4 items, but two of them are removed because they’re considered to have side effects

llvm-project/clang/lib/Sema/SemaDeclCXX.cpp

Lines 5187 to 5195 in bb38b48

	bool addFieldInitializer(CXXCtorInitializer *Init) {
	AllToInit.push_back(Init);
	// Check whether this initializer makes the field "used".
	if (Init->getInit()->HasSideEffects(S.Context))
	S.UnusedPrivateFields.remove(Init->getAnyMember());
	return false;
	}

llvm-project/clang/lib/AST/Expr.cpp

Lines 3896 to 3904 in bb38b48

	case CXXConstructExprClass:
	case CXXTemporaryObjectExprClass: {
	const CXXConstructExpr *CE = cast<CXXConstructExpr>(this);
	if (!CE->getConstructor()->isTrivial() && IncludePossibleEffects)
	return true;
	// A trivial constructor does not add any side-effects of its own. Just look
	// at its arguments.
	break;
	}

HasSideEffects can be invoked without considering potential side effects; in this case, however, it may trigger warnings that could be treated as regressions, for instance

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

Line 165 in 047ddbf

int in_class_initializer_with_side_effect_ = side_effect();

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

Line 167 in 047ddbf

Trivial non_trivial_initializer_ = Trivial(42);

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

Line 168 in 047ddbf

int initialized_with_side_effect_;

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

Line 172 in 047ddbf

Trivial user_constructor_;

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

Line 297 in 047ddbf

A b;

@AaronBallman could you clarify this case?

[AaronBallman]

I interpret the [[gnu::warn_unused]] attribute as saying "I have no side effects and even if, ignore them".

That's actually the opposite of the intent: https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html#index-warn_005funused-type-attribute

This type attribute informs the compiler that variables of this type should be warned about if they appear to be unused, just like variables of fundamental types.

s2 and s4 are being diagnoses because the compiler knows the unused variables have no side effects. The same is not true for s1 because that would require us to analyze the body of the constructor (which we don't do due to compile time overhead and false positives), or for s3 because that has no constructor body visible.

So I think this is behaving by design (but we could sure use some documentation on the attribute).