[rpms/clazy] epel8: Backport patches for LLVM 22

[Tulio Magno Quites Machado Filho <tuliom@redhat.com>]

            A new commit has been pushed.

            Repo   : rpms/clazy
            Branch : epel8
            Commit : dc9f383a3824f57b3d9e2b15fbf7e85158b28623
            Author : Tulio Magno Quites Machado Filho <tuliom@redhat.com>
            Date   : 2026-02-09T14:37:52-03:00
            Stats  : +419/-1 in 5 file(s)
            URL    : https://src.fedoraproject.org/rpms/clazy/c/dc9f383a3824f57b3d9e2b15fbf7e85158b28623?branch=epel8

            Log:
            Backport patches for LLVM 22

Add 4 patches from upstream that are required to build clazy with
LLVM 22.

---
diff --git a/76212885729bf9dcfea7c198d32a15651310aceb.patch b/76212885729bf9dcfea7c198d32a15651310aceb.patch
new file mode 100644
index 0000000..f2f7e61
--- /dev/null
+++ b/76212885729bf9dcfea7c198d32a15651310aceb.patch
@@ -0,0 +1,64 @@
+From 76212885729bf9dcfea7c198d32a15651310aceb Mon Sep 17 00:00:00 2001
+From: Alexander Lohnau <alexander.lohnau@gmx.de>
+Date: Sun, 2 Nov 2025 08:30:28 +0100
+Subject: [PATCH] Fix qhash-namespace test with llvm22
+
+---
+ src/checks/level1/qhash-namespace.cpp | 16 ++++++++++++----
+ src/checks/level1/qhash-namespace.h   |  3 +++
+ 2 files changed, 15 insertions(+), 4 deletions(-)
+
+diff --git a/src/checks/level1/qhash-namespace.cpp b/src/checks/level1/qhash-namespace.cpp
+index ef29711b..4b397fc3 100644
+--- a/src/checks/level1/qhash-namespace.cpp
++++ b/src/checks/level1/qhash-namespace.cpp
+@@ -18,6 +18,15 @@
+ 
+ using namespace clang;
+ 
++std::string QHashNamespace::fullyQualifiedParamName(clang::ParmVarDecl *firstArg)
++{
++    if (auto *typePtr = firstArg->getType().getTypePtr()->getAsTagDecl()) {
++        return typePtr->getQualifiedNameAsString();
++    }
++    // Fallback, should not happen
++    return firstArg->getType().getAsString();
++}
++
+ void QHashNamespace::VisitDecl(clang::Decl *decl)
+ {
+     auto *func = dyn_cast<FunctionDecl>(decl);
+@@ -34,13 +43,12 @@ void QHashNamespace::VisitDecl(clang::Decl *decl)
+         const std::string argumentNSstr = argumentNS->getQualifiedNameAsString();
+         const std::string qhashNSstr = qHashNS->getQualifiedNameAsString();
+         if (argumentNSstr != qhashNSstr) {
+-            msg = "Move qHash(" + clazy::simpleTypeName(firstArg->getType(), lo()) + ") to " + argumentNSstr + " namespace for ADL lookup";
++            msg = "Move qHash(" + fullyQualifiedParamName(firstArg) + ") to " + argumentNSstr + " namespace for ADL lookup";
+         }
+     } else if (qHashNS && !argumentNS) {
+-        msg = "Move qHash(" + clazy::simpleTypeName(firstArg->getType(), lo()) + ") out of namespace " + qHashNS->getQualifiedNameAsString();
++        msg = "Move qHash(" + fullyQualifiedParamName(firstArg) + ") out of namespace " + qHashNS->getQualifiedNameAsString();
+     } else if (!qHashNS && argumentNS) {
+-        msg =
+-            "Move qHash(" + clazy::simpleTypeName(firstArg->getType(), lo()) + ") into " + argumentNS->getQualifiedNameAsString() + " namespace for ADL lookup";
++        msg = "Move qHash(" + fullyQualifiedParamName(firstArg) + ") into " + argumentNS->getQualifiedNameAsString() + " namespace for ADL lookup";
+     }
+ 
+     if (!msg.empty()) {
+diff --git a/src/checks/level1/qhash-namespace.h b/src/checks/level1/qhash-namespace.h
+index 0bedd50c..c30adb25 100644
+--- a/src/checks/level1/qhash-namespace.h
++++ b/src/checks/level1/qhash-namespace.h
+@@ -17,6 +17,9 @@ class QHashNamespace : public CheckBase
+ public:
+     using CheckBase::CheckBase;
+     void VisitDecl(clang::Decl *decl) override;
++
++private:
++    std::string fullyQualifiedParamName(clang::ParmVarDecl *firstArg);
+ };
+ 
+ #endif
+-- 
+GitLab
+

diff --git a/81b7cf38a444f6ca7a539ceb51ada050214f3b47.patch b/81b7cf38a444f6ca7a539ceb51ada050214f3b47.patch
new file mode 100644
index 0000000..2a26655
--- /dev/null
+++ b/81b7cf38a444f6ca7a539ceb51ada050214f3b47.patch
@@ -0,0 +1,81 @@
+From 81b7cf38a444f6ca7a539ceb51ada050214f3b47 Mon Sep 17 00:00:00 2001
+From: Alexander Lohnau <alexander.lohnau@gmx.de>
+Date: Fri, 31 Oct 2025 08:02:53 +0100
+Subject: [PATCH] Add #if statements to avoid using ElaboratedType that is
+ removed in LLVM 22
+
+Starting to make it compatible with LLVM22:
+https://invent.kde.org/sdk/clazy/-/issues/32
+---
+ src/StringUtils.h                               | 4 ++++
+ src/TypeUtils.h                                 | 2 ++
+ src/checks/level0/fully-qualified-moc-types.cpp | 2 ++
+ 3 files changed, 8 insertions(+)
+
+diff --git a/src/StringUtils.h b/src/StringUtils.h
+index 1d2f301b..03c79a60 100644
+--- a/src/StringUtils.h
++++ b/src/StringUtils.h
+@@ -93,9 +93,11 @@ inline std::string classNameFor(clang::QualType qt)
+         return {};
+     }
+ 
++#if LLVM_VERSION_MAJOR < 22
+     if (clang::ElaboratedType::classof(t)) {
+         return classNameFor(static_cast<const clang::ElaboratedType *>(t)->getNamedType());
+     }
++#endif
+ 
+     const clang::CXXRecordDecl *record = t->isRecordType() ? t->getAsCXXRecordDecl() : t->getPointeeCXXRecordDecl();
+     return classNameFor(record);
+@@ -256,9 +258,11 @@ inline std::string simpleTypeName(clang::QualType qt, const clang::LangOptions &
+         return {};
+     }
+ 
++#if LLVM_VERSION_MAJOR < 22
+     if (clang::ElaboratedType::classof(t)) {
+         qt = static_cast<const clang::ElaboratedType *>(t)->getNamedType();
+     }
++#endif
+ 
+     return qt.getNonReferenceType().getUnqualifiedType().getAsString(clang::PrintingPolicy(lo));
+ }
+diff --git a/src/TypeUtils.h b/src/TypeUtils.h
+index 49f373d0..c93f542d 100644
+--- a/src/TypeUtils.h
++++ b/src/TypeUtils.h
+@@ -211,9 +211,11 @@ inline clang::CXXRecordDecl *parentRecordForTypedef(const clang::QualType qt)
+ {
+     auto *t = qt.getTypePtrOrNull();
+ 
++#if LLVM_VERSION_MAJOR < 22
+     if (const auto *elab = llvm::dyn_cast<clang::ElaboratedType>(t)) {
+         t = elab->desugar().getTypePtrOrNull();
+     }
++#endif
+ 
+     if (const auto *tdt = llvm::dyn_cast<clang::TypedefType>(t)) {
+         clang::TypedefNameDecl *tdnd = tdt->getDecl();
+diff --git a/src/checks/level0/fully-qualified-moc-types.cpp b/src/checks/level0/fully-qualified-moc-types.cpp
+index 7f9d6ab5..40d7f6cb 100644
+--- a/src/checks/level0/fully-qualified-moc-types.cpp
++++ b/src/checks/level0/fully-qualified-moc-types.cpp
+@@ -86,6 +86,7 @@ void FullyQualifiedMocTypes::VisitDecl(clang::Decl *decl)
+ 
+ std::string FullyQualifiedMocTypes::getQualifiedNameOfType(const Type *ptr, bool checkElabType) const
+ {
++#if LLVM_VERSION_MAJOR < 22
+     if (auto *elabType = dyn_cast<ElaboratedType>(ptr); elabType && checkElabType) {
+         if (auto *specType = dyn_cast<TemplateSpecializationType>(elabType->getNamedType().getTypePtrOrNull()); specType && !ptr->getAs<TypedefType>()) {
+             return resolveTemplateType(specType, false);
+@@ -94,6 +95,7 @@ std::string FullyQualifiedMocTypes::getQualifiedNameOfType(const Type *ptr, bool
+             return elabType->getAs<EnumType>()->getDecl()->getQualifiedNameAsString();
+         }
+     }
++#endif
+     if (auto *typedefDecl = ptr->getAs<TypedefType>(); typedefDecl && typedefDecl->getDecl()) {
+         return typedefDecl->getDecl()->getQualifiedNameAsString();
+     } else if (auto templateSpec = ptr->getAs<TemplateSpecializationType>()) {
+-- 
+GitLab
+

diff --git a/9cf68dbe86c02d7b4e5913be1f637ba12000ac8d.patch b/9cf68dbe86c02d7b4e5913be1f637ba12000ac8d.patch
new file mode 100644
index 0000000..9916081
--- /dev/null
+++ b/9cf68dbe86c02d7b4e5913be1f637ba12000ac8d.patch
@@ -0,0 +1,42 @@
+From 9cf68dbe86c02d7b4e5913be1f637ba12000ac8d Mon Sep 17 00:00:00 2001
+From: Alexander Lohnau <alexander.lohnau@gmx.de>
+Date: Mon, 17 Nov 2025 20:47:32 +0100
+Subject: [PATCH] Fix old-style-connect check not working with LLVM22
+
+The decleration did not contain the info we needed.
+
+CXXRecordDecl 0x7f0f7c4f2930 prev 0x38f35d18 </usr/include/qt5/QtDBus/qdbusconnection.h:74:1, col:7> col:7 referenced class QObject
+`-VisibilityAttr 0x7f0f7c4f29f0 </usr/include/qt5/QtCore/qcompilerdetection.h:236:46, col:66> Inherited Default
+
+Compared to before, where we had all the methods and so on.
+To fix this, get the decleration of the class
+---
+ src/checks/level2/old-style-connect.cpp | 5 +++--
+ 1 file changed, 3 insertions(+), 2 deletions(-)
+
+diff --git a/src/checks/level2/old-style-connect.cpp b/src/checks/level2/old-style-connect.cpp
+index d5b82fd4..7461a27f 100644
+--- a/src/checks/level2/old-style-connect.cpp
++++ b/src/checks/level2/old-style-connect.cpp
+@@ -350,7 +350,7 @@ std::vector<FixItHint> OldStyleConnect::fixits(int classification, T *callOrCtor
+                 }
+             }
+ 
+-            if (!lastRecordDecl) {
++            if (!lastRecordDecl || !lastRecordDecl->hasDefinition()) {
+                 std::string msg = "Failed to get class name for explicit receiver";
+                 queueManualFixitWarning(s, msg);
+                 return {};
+@@ -358,7 +358,8 @@ std::vector<FixItHint> OldStyleConnect::fixits(int classification, T *callOrCtor
+ 
+             const std::string methodName = signalOrSlotNameFromMacro(s);
+ 
+-            auto methods = Utils::methodsFromString(lastRecordDecl, methodName);
++            // With LLVM22, we need to explicitly ask for the definition
++            auto methods = Utils::methodsFromString(lastRecordDecl->getDefinition(), methodName);
+             if (methods.empty()) {
+                 std::string msg;
+                 if (isPrivateSlot(methodName)) {
+-- 
+GitLab
+

diff --git a/ccffc8695477d9f486e509874440c7c63e2ec599.patch b/ccffc8695477d9f486e509874440c7c63e2ec599.patch
new file mode 100644
index 0000000..2ec2afc
--- /dev/null
+++ b/ccffc8695477d9f486e509874440c7c63e2ec599.patch
@@ -0,0 +1,226 @@
+From ccffc8695477d9f486e509874440c7c63e2ec599 Mon Sep 17 00:00:00 2001
+From: Alexander Lohnau <alexander.lohnau@gmx.de>
+Date: Sun, 16 Nov 2025 19:43:51 +0100
+Subject: [PATCH] Fix fully-fualified-moc-types not working with llvm22
+
+The core change is: Use the lexer to get the source text directly, normalize it and avoid shenanigans that are too fragile
+---
+ Changelog                                     |   1 +
+ .../level0/fully-qualified-moc-types.cpp      | 116 ++++++++++++++----
+ src/checks/level0/fully-qualified-moc-types.h |   8 +-
+ 3 files changed, 101 insertions(+), 24 deletions(-)
+
+diff --git a/src/checks/level0/fully-qualified-moc-types.cpp b/src/checks/level0/fully-qualified-moc-types.cpp
+index 40d7f6cb..576c9968 100644
+--- a/src/checks/level0/fully-qualified-moc-types.cpp
++++ b/src/checks/level0/fully-qualified-moc-types.cpp
+@@ -28,6 +28,73 @@
+ 
+ using namespace clang;
+ 
++/*
++ * When we get the raw string from the lexer, ensure we remove unneeded whitespaces to get a proper representation of the expression
++ */
++static std::string normalizeType(const std::string &type)
++{
++    std::string out;
++    bool lastWasSpace = false;
++
++    for (size_t i = 0; i < type.size(); ++i) {
++        const char c = type[i];
++
++        if (isspace(static_cast<unsigned char>(c))) {
++            lastWasSpace = true;
++            continue; // skip now, decide later
++        }
++
++        // Remove space before certain punctuation that is relevant here
++        if ((c == '<' || c == '>' || c == ',') && !out.empty() && out.back() == ' ') {
++            out.pop_back();
++        }
++
++        // Add a space if needed (mandatory space between keywords/identifiers)
++        if (lastWasSpace) {
++            if (!out.empty()) {
++                const char prev = out.back();
++                // insert a space if previous and current chars are alphanumeric or underscores
++                if ((isalnum(prev) || prev == '_') && (isalnum(c) || c == '_')) {
++                    out += ' ';
++                }
++            }
++        }
++
++        out += c;
++
++        // Add exactly one space after comma
++        if (c == ',') {
++            out += ' ';
++        }
++
++        lastWasSpace = false;
++    }
++
++    return out;
++}
++
++std::string FullyQualifiedMocTypes::writtenType(const ParmVarDecl *param) const
++{
++    TypeSourceInfo *TSI = param->getTypeSourceInfo();
++    if (!TSI)
++        return {};
++
++    TypeLoc TL = TSI->getTypeLoc();
++    while (true) {
++        if (auto PtrLoc = TL.getAs<PointerTypeLoc>()) {
++            TL = PtrLoc.getPointeeLoc();
++        } else if (auto RefLoc = TL.getAs<ReferenceTypeLoc>()) {
++            TL = RefLoc.getPointeeLoc();
++        } else {
++            break; // reached underlying type
++        }
++    }
++
++    CharSourceRange CSR = CharSourceRange::getTokenRange(TL.getSourceRange());
++    StringRef text = Lexer::getSourceText(CSR, sm(), lo());
++    return normalizeType(text.str());
++}
++
+ void FullyQualifiedMocTypes::VisitDecl(clang::Decl *decl)
+ {
+     auto *method = dyn_cast<CXXMethodDecl>(decl);
+@@ -54,10 +121,10 @@ void FullyQualifiedMocTypes::VisitDecl(clang::Decl *decl)
+     }
+ 
+     std::string qualifiedTypeName;
+-    std::string typeName;
+     for (auto *param : method->parameters()) {
+         QualType t = clazy::pointeeQualType(param->getType());
+-        if (!typeIsFullyQualified(t, /*by-ref*/ qualifiedTypeName, /*by-ref*/ typeName)) {
++        const std::string typeName = writtenType(param);
++        if (!typeIsFullyQualified(t, /*by-ref*/ qualifiedTypeName, typeName)) {
+             SourceRange fixitRange = param->getTypeSourceInfo()->getTypeLoc().getSourceRange();
+             // We don't want to include the & or * characters for the fixit range
+             if (param->getType()->isReferenceType() || param->getType()->isPointerType()) {
+@@ -70,8 +137,18 @@ void FullyQualifiedMocTypes::VisitDecl(clang::Decl *decl)
+     }
+ 
+     if (qst == QtAccessSpecifier_Slot || qst == QtAccessSpecifier_Invokable) {
++        std::string typeName;
+         QualType returnT = clazy::pointeeQualType(method->getReturnType());
+-        if (!typeIsFullyQualified(returnT, /*by-ref*/ qualifiedTypeName, /*by-ref*/ typeName)) {
++        if (auto *TSI = method->getTypeSourceInfo()) {
++            FunctionTypeLoc FTL = TSI->getTypeLoc().castAs<FunctionTypeLoc>();
++            SourceRange SR = FTL.getReturnLoc().getSourceRange();
++            if (SR.isValid()) {
++                StringRef returnText = Lexer::getSourceText(CharSourceRange::getTokenRange(SR), sm(), lo());
++                typeName = normalizeType(returnText.str());
++            }
++        }
++
++        if (!typeName.empty() && !typeIsFullyQualified(returnT, /*by-ref*/ qualifiedTypeName, typeName)) {
+             SourceRange returnTypeSourceRange = method->getReturnTypeSourceRange();
+             // We don't want to include the & or * characters for the fixit range
+             if (method->getReturnType()->isReferenceType() || method->getReturnType()->isPointerType()) {
+@@ -84,25 +161,23 @@ void FullyQualifiedMocTypes::VisitDecl(clang::Decl *decl)
+     }
+ }
+ 
+-std::string FullyQualifiedMocTypes::getQualifiedNameOfType(const Type *ptr, bool checkElabType) const
++std::string FullyQualifiedMocTypes::getQualifiedNameOfType(const Type *ptr, bool resolveTemplateArgs) const
+ {
+-#if LLVM_VERSION_MAJOR < 22
+-    if (auto *elabType = dyn_cast<ElaboratedType>(ptr); elabType && checkElabType) {
+-        if (auto *specType = dyn_cast<TemplateSpecializationType>(elabType->getNamedType().getTypePtrOrNull()); specType && !ptr->getAs<TypedefType>()) {
+-            return resolveTemplateType(specType, false);
+-        }
+-        if (elabType->isEnumeralType() && elabType->getAs<EnumType>()) {
+-            return elabType->getAs<EnumType>()->getDecl()->getQualifiedNameAsString();
+-        }
++    if (ptr->isEnumeralType() && ptr->getAs<EnumType>()) {
++        return ptr->getAs<EnumType>()->getDecl()->getQualifiedNameAsString();
+     }
+-#endif
+     if (auto *typedefDecl = ptr->getAs<TypedefType>(); typedefDecl && typedefDecl->getDecl()) {
+         return typedefDecl->getDecl()->getQualifiedNameAsString();
++    }
++
++    else if (auto templateSpec = ptr->getAs<TemplateSpecializationType>(); templateSpec && resolveTemplateArgs) {
++        return resolveTemplateType(templateSpec, false);
+     } else if (auto templateSpec = ptr->getAs<TemplateSpecializationType>()) {
+         // In case one uses a typedef with generics, like QVector<QString> in Qt6
+         // The docs indicate getAsTemplateDecl might be null - so be prepared for that
+         if (auto *decl = templateSpec->getTemplateName().getAsTemplateDecl()) {
+             return decl->getQualifiedNameAsString();
++        } else {
+         }
+     } else if (auto recordDecl = ptr->getAsRecordDecl()) {
+         return recordDecl->getQualifiedNameAsString();
+@@ -132,30 +207,27 @@ std::string FullyQualifiedMocTypes::resolveTemplateType(const clang::TemplateSpe
+             if (argType.isConstQualified()) {
+                 str += "const ";
+             }
+-            str += getQualifiedNameOfType(argType.getTypePtr());
++            str += getQualifiedNameOfType(argType.getTypePtr(), true);
+         }
+     }
+     str += ">";
+     return str;
+ }
+ 
+-bool FullyQualifiedMocTypes::typeIsFullyQualified(QualType t, std::string &qualifiedTypeName, std::string &typeName) const
++bool FullyQualifiedMocTypes::typeIsFullyQualified(QualType t, std::string &qualifiedTypeName, const std::string &typeName) const
+ {
+     qualifiedTypeName.clear();
+-    typeName.clear();
+-
+     if (auto *ptr = t.getTypePtrOrNull(); ptr && (ptr->isRecordType() || ptr->isEnumeralType())) {
+-        typeName = clazy::name(t.getUnqualifiedType(), lo(), /*asWritten=*/true); // Ignore qualifiers like const here
+         if (typeName == "QPrivateSignal") {
+             return true;
+         }
+ 
+         if (auto specType = ptr->getAs<TemplateSpecializationType>(); specType && !ptr->getAs<TypedefType>()) {
+-            qualifiedTypeName = resolveTemplateType(specType);
++            qualifiedTypeName = resolveTemplateType(specType, false);
+         } else if (auto recordDecl = ptr->getAsRecordDecl(); recordDecl && recordDecl->isInAnonymousNamespace()) {
+             return true;
+         } else {
+-            qualifiedTypeName = getQualifiedNameOfType(ptr);
++            qualifiedTypeName = getQualifiedNameOfType(ptr, true);
+         }
+         return qualifiedTypeName.empty() || typeName == qualifiedTypeName;
+     }
+@@ -212,8 +284,10 @@ bool FullyQualifiedMocTypes::handleQ_PROPERTY(CXXMethodDecl *method)
+                             continue;
+                         }
+ 
+-                        std::string nameAsWritten;
++                        QualType castType = clazy::pointeeQualType(reinterpret->getTypeAsWritten()).getUnqualifiedType();
++                        std::string nameAsWritten = castType.getUnqualifiedType().getAsString();
+                         std::string qualifiedName;
++
+                         if (!typeIsFullyQualified(qt, qualifiedName, nameAsWritten)) {
+                             // warn in the cxxrecorddecl, since we don't want to warn in the .moc files.
+                             // Ideally we would do some cross checking with the Q_PROPERTIES, but that's not in the AST
+diff --git a/src/checks/level0/fully-qualified-moc-types.h b/src/checks/level0/fully-qualified-moc-types.h
+index 3b791667..7b34a99c 100644
+--- a/src/checks/level0/fully-qualified-moc-types.h
++++ b/src/checks/level0/fully-qualified-moc-types.h
+@@ -32,9 +32,11 @@ private:
+     bool handleQ_PROPERTY(clang::CXXMethodDecl *);
+     void VisitMacroExpands(const clang::Token &MacroNameTok, const clang::SourceRange &range, const clang::MacroInfo *minfo = nullptr) override;
+     void registerQ_GADGET(clang::SourceLocation);
+-    bool typeIsFullyQualified(clang::QualType t, std::string &qualifiedTypeName, std::string &typeName) const;
+-    std::string getQualifiedNameOfType(const clang::Type *ptr, bool checkElabType = true) const;
+-    std::string resolveTemplateType(const clang::TemplateSpecializationType *ptr, bool checkElabType = true) const;
++    bool typeIsFullyQualified(clang::QualType t, std::string &qualifiedTypeName, const std::string &typeName) const;
++    std::string getQualifiedNameOfType(const clang::Type *ptr, bool resolveTemplateArgs) const;
++    std::string resolveTemplateType(const clang::TemplateSpecializationType *ptr, bool resolveTemplateArgs) const;
++
++    std::string writtenType(const clang::ParmVarDecl *param) const;
+ 
+     std::vector<clang::SourceLocation> m_qgadgetMacroLocations;
+ };
+-- 
+GitLab
+

diff --git a/clazy.spec b/clazy.spec
index 2b15504..caa15cc 100644
--- a/clazy.spec
+++ b/clazy.spec
@@ -1,7 +1,7 @@
 Name:           clazy
 Summary:        Qt oriented code checker based on clang framework
 Version:        1.16
-Release:        4%{?dist}
+Release:        5%{?dist}
 License:        LGPL-2.0-or-later
 URL:            https://invent.kde.org/sdk/%{name}
 
@@ -12,6 +12,11 @@ Source0:        https://download.kde.org/stable/%{name}/%{version}/src/%{name}-v
 %endif
 
 Patch0:         clazy-no-rpath.patch
+# Patches required for LLVM 22.
+Patch1:         81b7cf38a444f6ca7a539ceb51ada050214f3b47.patch
+Patch2:         76212885729bf9dcfea7c198d32a15651310aceb.patch
+Patch3:         ccffc8695477d9f486e509874440c7c63e2ec599.patch
+Patch4:         9cf68dbe86c02d7b4e5913be1f637ba12000ac8d.patch
 
 BuildRequires: cmake
 BuildRequires: gcc-c++