fix #14130: false positive: unusedStructMember with [[maybe_unused]] (#7818)

Author: ludviggunne

lib/checkclass.cpp

@@ -1338,7 +1338,7 @@ void CheckClass::privateFunctions()
 
         while (!privateFuncs.empty()) {
             const auto& pf = privateFuncs.front();
-            if (pf->retDef && pf->retDef->isAttributeMaybeUnused()) {
+            if (pf->token->isAttributeMaybeUnused()) {
                 privateFuncs.pop_front();
                 continue;
             }

lib/checkunusedvar.cpp

@@ -1606,7 +1606,7 @@ void CheckUnusedVar::checkStructMemberUsage()
             if (isInherited && !var.isPrivate())
                 continue;
 
-            if (!var.nameToken() || var.nameToken()->isAttributeUnused() || var.nameToken()->isAnonymous())
+            if (!var.nameToken() || var.nameToken()->isAttributeUnused() || var.nameToken()->isAttributeMaybeUnused() || var.nameToken()->isAnonymous())
                 continue;
 
             if (mTokenizer->isVarUsedInTemplate(var.declarationId()))

lib/symboldatabase.cpp

@@ -2357,8 +2357,11 @@ void Variable::evaluate(const Settings& settings)
     const Library & lib = settings.library;
 
     bool isContainer = false;
-    if (mNameToken)
+    if (mNameToken) {
         setFlag(fIsArray, arrayDimensions(settings, isContainer));
+        setFlag(fIsMaybeUnused, mNameToken->isAttributeMaybeUnused());
+    }
+
 
     if (mTypeStartToken)
         setValueType(ValueType::parseDecl(mTypeStartToken,settings));
@@ -2395,10 +2398,6 @@ void Variable::evaluate(const Settings& settings)
             setFlag(fIsReference, true); // Set also fIsReference
         }
 
-        if (tok->isAttributeMaybeUnused()) {
-            setFlag(fIsMaybeUnused, true);
-        }
-
         if (tok->str() == "<" && tok->link())
             tok = tok->link();
         else

lib/tokenize.cpp

@@ -9550,9 +9550,27 @@ void Tokenizer::simplifyCPPAttribute()
                 Token* head = skipCPPOrAlignAttribute(tok)->next();
                 while (isCPPAttribute(head) || isAlignAttribute(head))
                     head = skipCPPOrAlignAttribute(head)->next();
+
                 if (!head)
                     syntaxError(tok);
-                head->isAttributeMaybeUnused(true);
+
+                while (Token::Match(head->next(), "%name%|*|&|&&|const|static|inline|volatile"))
+                    head = head->next();
+                if (Token::Match(head, "%name%") && !Token::Match(head, "auto ["))
+                    head->isAttributeMaybeUnused(true);
+                else if (Token::Match(tok->previous(), "%name%") && Token::Match(tok->link(), "] [;={]")) {
+                    tok->previous()->isAttributeMaybeUnused(true);
+                } else {
+                    if (Token::simpleMatch(head->next(), "[")) {
+                        head = head->next();
+                        const Token *end = head->link();
+                        for (head = head->next(); end && head != end; head = head->next()) {
+                            if (Token::Match(head, "%name%")) {
+                                head->isAttributeMaybeUnused(true);
+                            }
+                        }
+                    }
+                }
             } else if (Token::findsimplematch(tok->tokAt(2), "unused", tok->link())) {
                 Token* head = skipCPPOrAlignAttribute(tok)->next();
                 while (isCPPAttribute(head) || isAlignAttribute(head))

test/testtokenize.cpp

@@ -273,6 +273,10 @@ class TestTokenizer : public TestFixture {
         TEST_CASE(functionAttributeListBefore);
         TEST_CASE(functionAttributeListAfter);
 
+        TEST_CASE(cppMaybeUnusedBefore);
+        TEST_CASE(cppMaybeUnusedAfter);
+        TEST_CASE(cppMaybeUnusedStructuredBinding);
+
         TEST_CASE(splitTemplateRightAngleBrackets);
 
         TEST_CASE(cpp03template1);
@@ -4193,6 +4197,47 @@ class TestTokenizer : public TestFixture {
         ASSERT(func8 && func8->isAttributeNoreturn() && func8->isAttributePure() && func8->isAttributeNothrow() && func8->isAttributeConst());
     }
 
+    void cppMaybeUnusedBefore() {
+        const char code[] = "[[maybe_unused]] int var {};";
+        const char expected[] = "int var { } ;";
+
+        SimpleTokenizer tokenizer(settings0, *this);
+        ASSERT(tokenizer.tokenize(code));
+
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token *var = Token::findsimplematch(tokenizer.tokens(), "var");
+        ASSERT(var && var->isAttributeMaybeUnused());
+    }
+
+    void cppMaybeUnusedAfter() {
+        const char code[] = "int var [[maybe_unused]] {};";
+        const char expected[] = "int var { } ;";
+
+        SimpleTokenizer tokenizer(settings0, *this);
+        ASSERT(tokenizer.tokenize(code));
+
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token *var = Token::findsimplematch(tokenizer.tokens(), "var");
+        ASSERT(var && var->isAttributeMaybeUnused());
+    }
+
+    void cppMaybeUnusedStructuredBinding() {
+        const char code[] = "[[maybe_unused]] auto [var1, var2] = f();";
+        const char expected[] = "auto [ var1 , var2 ] = f ( ) ;";
+
+        SimpleTokenizer tokenizer(settings0, *this);
+        ASSERT(tokenizer.tokenize(code));
+
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token *var1 = Token::findsimplematch(tokenizer.tokens(), "var1");
+        ASSERT(var1 && var1->isAttributeMaybeUnused());
+        const Token *var2 = Token::findsimplematch(tokenizer.tokens(), "var2");
+        ASSERT(var2 && var2->isAttributeMaybeUnused());
+    }
+
 
     void splitTemplateRightAngleBrackets() {
         {

test/testunusedvar.cpp

@@ -73,6 +73,7 @@ class TestUnusedVar : public TestFixture {
         TEST_CASE(structmember28);
         TEST_CASE(structmember29); // #14075
         TEST_CASE(structmember30); // #14131
+        TEST_CASE(structmember31); // #14130
         TEST_CASE(structmember_macro);
         TEST_CASE(structmember_template_argument); // #13887 - do not report that member used in template argument is unused
         TEST_CASE(classmember);
@@ -2035,6 +2036,15 @@ class TestUnusedVar : public TestFixture {
         ASSERT_EQUALS("", errout_str());
     }
 
+    void structmember31() { // #14130
+        checkStructMemberUsage("struct S\n"
+                               "{\n"
+                               "    [[maybe_unused]] int i1{};\n"
+                               "    int i2 [[maybe_unused]] {};\n"
+                               "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
     void structmember_macro() {
         checkStructMemberUsageP("#define S(n) struct n { int a, b, c; };\n"
                                 "S(unused);\n");