Fix danmar#7458 (FP unusedStructMember with struct in union)

Author: danmar

lib/checkunusedvar.cpp

@@ -1599,6 +1599,57 @@ void CheckUnusedVar::checkStructMemberUsage()
         if (bailout)
             continue;
 
+        // #7458 - if struct is declared inside union and any struct member is used,
+        // then don't warn about other struct members
+        bool structInUnionWithUsedMember = false;
+        if (scope.type == ScopeType::eStruct && scope.nestedIn && scope.nestedIn->type == ScopeType::eUnion) {
+            for (const Variable &unionVar : scope.varlist) {
+                for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
+                    if (tok->variable() == &unionVar && tok != unionVar.nameToken()) {
+                        structInUnionWithUsedMember = true;
+                        break;
+                    }
+                }
+                if (structInUnionWithUsedMember)
+                    break;
+            }
+        }
+
+        // #7458 - if this is a union and any member is used, don't warn about other members
+        bool unionWithUsedMember = false;
+        if (scope.type == ScopeType::eUnion) {
+            // Check if any direct member of the union is used
+            for (const Variable &unionVar : scope.varlist) {
+                for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
+                    if (tok->variable() == &unionVar && tok != unionVar.nameToken()) {
+                        unionWithUsedMember = true;
+                        break;
+                    }
+                }
+                if (unionWithUsedMember)
+                    break;
+            }
+            // Also check if any member of nested structs in this union is used
+            if (!unionWithUsedMember) {
+                for (const Scope *nestedScope : scope.nestedList) {
+                    if (nestedScope->type == ScopeType::eStruct) {
+                        for (const Variable &structVar : nestedScope->varlist) {
+                            for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
+                                if (tok->variable() == &structVar && tok != structVar.nameToken()) {
+                                    unionWithUsedMember = true;
+                                    break;
+                                }
+                            }
+                            if (unionWithUsedMember)
+                                break;
+                        }
+                        if (unionWithUsedMember)
+                            break;
+                    }
+                }
+            }
+        }
+
         for (const Variable &var : scope.varlist) {
             // only warn for variables without side effects
             if (!var.typeStartToken()->isStandardType() && !var.isPointer() && !astIsContainer(var.nameToken()) && !isRecordTypeWithoutSideEffects(var.type()))
@@ -1612,6 +1663,14 @@ void CheckUnusedVar::checkStructMemberUsage()
             if (mTokenizer->isVarUsedInTemplate(var.declarationId()))
                 continue;
 
+            // Skip reporting unused members if this struct is in a union and any member is used
+            if (structInUnionWithUsedMember)
+                continue;
+
+            // Skip reporting unused members if this is a union and any member is used
+            if (unionWithUsedMember)
+                continue;
+
             // Check if the struct member variable is used anywhere in the file
             bool use = false;
             for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {

test/testunusedvar.cpp

@@ -1409,6 +1409,20 @@ class TestUnusedVar : public TestFixture {
         ASSERT_EQUALS("[test.cpp:3:9]: (style) union member 'abc::a' is never used. [unusedStructMember]\n"
                       "[test.cpp:4:9]: (style) union member 'abc::b' is never used. [unusedStructMember]\n"
                       "[test.cpp:5:9]: (style) union member 'abc::c' is never used. [unusedStructMember]\n", errout_str());
+
+        // #7458 - union with anonymous struct should not cause false positive
+        checkStructMemberUsage("union DoubleInt {\n"
+                               "    double asDouble;\n"
+                               "    uint64_t asInt;\n"
+                               "    struct {\n"
+                               "        uint32_t lo, hi;\n"
+                               "    } asIntel;\n"
+                               "};\n"
+                               "void f() {\n"
+                               "    union DoubleInt di;\n"
+                               "    di.asIntel.hi = 3;\n"
+                               "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structmember2() {