format.yml: updated uncrustify to 0.74.0

Author: firewave

.github/workflows/format.yml

@@ -21,7 +21,7 @@ jobs:
     runs-on: ubuntu-22.04
 
     env:
-      UNCRUSTIFY_VERSION: 0.73.0
+      UNCRUSTIFY_VERSION: 0.74.0
 
     steps:
       - uses: actions/checkout@v4

lib/checkersreport.cpp

@@ -191,11 +191,11 @@ std::string CheckersReport::getReport(const std::string& criticalErrors) const
     const bool cppcheckPremium = isCppcheckPremium(mSettings);
 
     auto reportSection = [&fout, cppcheckPremium]
-                             (const std::string& title,
-                             const Settings& settings,
-                             const std::set<std::string>& activeCheckers,
-                             const std::map<std::string, std::string>& premiumCheckers,
-                             const std::string& substring) {
+                         (const std::string& title,
+                          const Settings& settings,
+                          const std::set<std::string>& activeCheckers,
+                          const std::map<std::string, std::string>& premiumCheckers,
+                          const std::string& substring) {
         fout << std::endl << std::endl;
         fout << title << std::endl;
         fout << std::string(title.size(), '-') << std::endl;

lib/checkstl.cpp

@@ -3293,12 +3293,12 @@ static const ValueFlow::Value* getOOBIterValue(const Token* tok, const ValueFlow
     auto it = std::find_if(tok->values().begin(), tok->values().end(), [&](const ValueFlow::Value& v) {
         if (v.isPossible() || v.isKnown()) {
             switch (v.valueType) {
-            case ValueFlow::Value::ValueType::ITERATOR_END:
-                return v.intvalue >= 0;
-            case ValueFlow::Value::ValueType::ITERATOR_START:
-                return (v.intvalue < 0) || (sizeVal && v.intvalue >= sizeVal->intvalue);
-            default:
-                break;
+                case ValueFlow::Value::ValueType::ITERATOR_END:
+                    return v.intvalue >= 0;
+                case ValueFlow::Value::ValueType::ITERATOR_START:
+                    return (v.intvalue < 0) || (sizeVal && v.intvalue >= sizeVal->intvalue);
+                default:
+                    break;
             }
         }
         return false;

lib/clangimport.cpp

@@ -1502,12 +1502,12 @@ void clangimport::AstNode::createTokensForCXXRecord(TokenList &tokenList)
         std::vector<AstNodePtr> children2;
         std::copy_if(children.cbegin(), children.cend(), std::back_inserter(children2), [](const AstNodePtr& child) {
             return child->nodeType == CXXConstructorDecl ||
-            child->nodeType == CXXDestructorDecl ||
-            child->nodeType == CXXMethodDecl ||
-            child->nodeType == FieldDecl ||
-            child->nodeType == VarDecl ||
-            child->nodeType == AccessSpecDecl ||
-            child->nodeType == TypedefDecl;
+                   child->nodeType == CXXDestructorDecl ||
+                   child->nodeType == CXXMethodDecl ||
+                   child->nodeType == FieldDecl ||
+                   child->nodeType == VarDecl ||
+                   child->nodeType == AccessSpecDecl ||
+                   child->nodeType == TypedefDecl;
         });
         Scope *scope = createScope(tokenList, isStruct ? ScopeType::eStruct : ScopeType::eClass, children2, classToken);
         const std::string addr = mExtTokens[0];

lib/programmemory.cpp

@@ -669,7 +669,7 @@ static ValueFlow::Value evaluate(const std::string& op, const ValueFlow::Value&
     return result;
 }
 
-using BuiltinLibraryFunction = std::function<ValueFlow::Value(const std::vector<ValueFlow::Value>&)>;
+using BuiltinLibraryFunction = std::function<ValueFlow::Value (const std::vector<ValueFlow::Value>&)>;
 static std::unordered_map<std::string, BuiltinLibraryFunction> createBuiltinLibraryFunctions()
 {
     std::unordered_map<std::string, BuiltinLibraryFunction> functions;

lib/symboldatabase.cpp

@@ -5732,11 +5732,11 @@ static bool hasMatchingConstructor(const Scope* classScope, const ValueType* arg
             return false;
         const ValueType* vt = f.getArgumentVar(0)->valueType();
         return vt &&
-        vt->type == argType->type &&
-        (argType->sign == ValueType::Sign::UNKNOWN_SIGN || vt->sign == argType->sign) &&
-        vt->pointer == argType->pointer &&
-        (vt->constness & 1) >= (argType->constness & 1) &&
-        (vt->volatileness & 1) >= (argType->volatileness & 1);
+               vt->type == argType->type &&
+               (argType->sign == ValueType::Sign::UNKNOWN_SIGN || vt->sign == argType->sign) &&
+               vt->pointer == argType->pointer &&
+               (vt->constness & 1) >= (argType->constness & 1) &&
+               (vt->volatileness & 1) >= (argType->volatileness & 1);
     });
 }
 

lib/token.cpp

@@ -2534,7 +2534,7 @@ bool Token::hasKnownSymbolicValue(const Token* tok) const
     return mImpl->mValues &&
            std::any_of(mImpl->mValues->begin(), mImpl->mValues->end(), [&](const ValueFlow::Value& value) {
         return value.isKnown() && value.isSymbolicValue() && value.tokvalue &&
-        value.tokvalue->exprId() == tok->exprId();
+               value.tokvalue->exprId() == tok->exprId();
     });
 }
 
@@ -2607,7 +2607,7 @@ const ValueFlow::Value* Token::getMovedValue() const
         return nullptr;
     const auto it = std::find_if(mImpl->mValues->begin(), mImpl->mValues->end(), [](const ValueFlow::Value& value) {
         return value.isMovedValue() && !value.isImpossible() &&
-        value.moveKind != ValueFlow::Value::MoveKind::NonMovedVariable;
+               value.moveKind != ValueFlow::Value::MoveKind::NonMovedVariable;
     });
     return it == mImpl->mValues->end() ? nullptr : &*it;
 }

lib/token.h

@@ -1426,7 +1426,7 @@ class CPPCHECKLIB Token {
         fIsInitBracket          = (1ULL << 43), // Is this bracket used as a part of variable initialization i.e: int a{5}, b(2);
     };
 
-    enum : std::uint8_t  {
+    enum : std::uint8_t {
         efMaxSize = sizeof(nonneg int) * 8,
         efIsUnique = efMaxSize - 2,
     };

lib/tokenize.cpp

@@ -10921,10 +10921,10 @@ bool Tokenizer::hasIfdef(const Token *start, const Token *end) const
     const auto& directives = mDirectives;
     return std::any_of(directives.cbegin(), directives.cend(), [&](const Directive& d) {
         return startsWith(d.str, "#if") &&
-        d.linenr >= start->linenr() &&
-        d.linenr <= end->linenr() &&
-        start->fileIndex() < list.getFiles().size() &&
-        d.file == list.getFiles()[start->fileIndex()];
+               d.linenr >= start->linenr() &&
+               d.linenr <= end->linenr() &&
+               start->fileIndex() < list.getFiles().size() &&
+               d.file == list.getFiles()[start->fileIndex()];
     });
 }
 

lib/vf_settokenvalue.cpp

@@ -537,7 +537,7 @@ namespace ValueFlow
                                                        args2.begin(),
                                                        [&](const Token* atok, const Token* btok) {
                                         return atok->getKnownIntValue() ==
-                                        btok->getKnownIntValue();
+                                               btok->getKnownIntValue();
                                     });
                                 } else {
                                     equal = false;

test/fixture.h

@@ -335,7 +335,9 @@ class TestInstance {
 #define TODO_ASSERT( CONDITION ) do { const bool condition=(CONDITION); todoAssertEquals(__FILE__, __LINE__, true, false, condition); } while (false)
 #define TODO_ASSERT_EQUALS( WANTED, CURRENT, ACTUAL ) todoAssertEquals(__FILE__, __LINE__, WANTED, CURRENT, ACTUAL)
 
+// *INDENT-OFF*
 #define REGISTER_TEST( CLASSNAME ) namespace { class CLASSNAME ## Instance : public TestInstance { public: CLASSNAME ## Instance() : TestInstance(#CLASSNAME) {} TestFixture* create() override { impl.reset(new CLASSNAME); return impl.get(); } }; CLASSNAME ## Instance instance_ ## CLASSNAME; }
+// *INDENT-ON*
 
 #define PLATFORM( P, T ) do { std::string errstr; assertEquals(__FILE__, __LINE__, true, P.set(Platform::toString(T), errstr, {exename}), errstr); } while (false)