[rpms/cvise] rawhide: Update to v2.12.0, fix FTBFS

[Artur Frenszek-Iwicki <fedora@svgames.pl>]

A new commit has been pushed.

Repo   : rpms/cvise
Branch : rawhide
Commit : ab282320661cff1a0f29f9667ff239550257e359
Author : Artur Frenszek-Iwicki <fedora@svgames.pl>
Date   : 2026-07-17T15:42:09+02:00
Stats  : +1567/-4 in 4 file(s)
URL    : https://src.fedoraproject.org/rpms/cvise/c/ab282320661cff1a0f29f9667ff239550257e359?branch=rawhide

Log:
Update to v2.12.0, fix FTBFS

---
diff --git a/.gitignore b/.gitignore
index a620747..8890219 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,3 +11,4 @@
 /v2.10.0.tar.gz
 /v2.10.0.1.tar.gz
 /v2.11.0.tar.gz
+/v2.12.0.tar.gz

diff --git a/cvise.spec b/cvise.spec
index 9015554..b3d4ec8 100644
--- a/cvise.spec
+++ b/cvise.spec
@@ -1,12 +1,22 @@
 Name: cvise
-Version: 2.11.0
-Release: 6%{?dist}
+Version: 2.12.0
+Release: 1%{?dist}
 Summary: Super-parallel Python port of the C-Reduce
 # Automatically converted from old format: BSD - review is highly recommended.
 License: LicenseRef-Callaway-BSD
 URL: https://github.com/marxin/cvise
 Source: https://github.com/marxin/cvise/archive/v%{version}.tar.gz
 
+# Fix compatibility with LLVM22.
+#
+# Backport of upstream commits:
+# https://github.com/marxin/cvise/commit/59e9058c43b12b802893bde668113c8b3b3525b7
+# https://github.com/marxin/cvise/commit/68262f7d6de584b6474801827cb7dfc68011de25
+# https://github.com/marxin/cvise/commit/fa1be9523d569adfe207c85a1e44f074172bc305
+# https://github.com/marxin/cvise/commit/b17bbacdb279babd87dc9ef24756f3003746717c
+# https://github.com/marxin/cvise/commit/c7f9642340eb61c09a05c96498fd21c9b7293770
+Patch1: llvm22.patch
+
 BuildRequires: astyle
 BuildRequires: cmake
 BuildRequires: flex
@@ -43,7 +53,7 @@ has the same property. It is intended for use by people who discover
 and report bugs in compilers and other tools that process C/C++ or OpenCL code.
 
 %prep
-%setup -q
+%autosetup -p1
 
 %build
 export CXXFLAGS="$RPM_OPT_FLAGS -Wno-error=restrict"
@@ -68,6 +78,9 @@ export CXXFLAGS="$RPM_OPT_FLAGS -Wno-error=restrict"
 %{_datadir}/cvise
 
 %changelog
+* Fri Jul 17 2026 Artur Frenszek-Iwicki <fedora@svgames.pl> - 2.12.0-1
+- Update to v2.12.0 (rhbz#2123703), fix FTBFS (rhbz#2433972)
+
 * Wed Jul 15 2026 Fedora Release Engineering <releng@fedoraproject.org> - 2.11.0-6
 - Rebuilt for https://fedoraproject.org/wiki/Fedora_45_Mass_Rebuild
 

diff --git a/llvm22.patch b/llvm22.patch
new file mode 100644
index 0000000..cd520dd
--- /dev/null
+++ b/llvm22.patch
@@ -0,0 +1,1549 @@
+diff -rNU4 cvise-2.12.0--orig/clang_delta/CMakeLists.txt cvise-2.12.0/clang_delta/CMakeLists.txt
+--- cvise-2.12.0--orig/clang_delta/CMakeLists.txt	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/CMakeLists.txt	2026-07-17 15:05:38.202425418 +0200
+@@ -348,8 +348,10 @@
+   "/tests/rename-param/invalid.output"
+   "/tests/rename-param/stuck.ii"
+   "/tests/rename-var/rename-var.c"
+   "/tests/rename-var/rename-var.output"
++  "/tests/replace-dependent-typedef/test2.cc"
++  "/tests/replace-dependent-typedef/test2.output"
+   "/tests/replace-derived-class/replace-derived1.cpp"
+   "/tests/replace-derived-class/replace-derived1.output"
+   "/tests/replace-derived-class/replace-derived2.cpp"
+   "/tests/replace-derived-class/replace-derived2.output"
+diff -rNU4 cvise-2.12.0--orig/clang_delta/CommonParameterRewriteVisitor.h cvise-2.12.0/clang_delta/CommonParameterRewriteVisitor.h
+--- cvise-2.12.0--orig/clang_delta/CommonParameterRewriteVisitor.h	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/CommonParameterRewriteVisitor.h	2026-07-17 13:53:45.285780097 +0200
+@@ -110,11 +110,17 @@
+     TransAssert(((DName.getNameKind() == clang::DeclarationName::Identifier) ||
+                  (DName.getNameKind() == 
+                     clang::DeclarationName::CXXOperatorName)) &&
+                 "Not an indentifier!");
++#if LLVM_VERSION_MAJOR < 22
+     if (const clang::NestedNameSpecifier *NNS = UE->getQualifier()) {
+       if (const clang::DeclContext *Ctx = 
+           ConsumerInstance->getDeclContextFromSpecifier(NNS)) {
++#else
++    if (const clang::NestedNameSpecifier NNS = UE->getQualifier()) {
++      if (const clang::DeclContext *Ctx =
++          ConsumerInstance->getDeclContextFromSpecifier(&NNS)) {
++#endif
+         DeclContextSet VisitedCtxs; 
+         CalleeDecl = 
+           ConsumerInstance->lookupFunctionDecl(DName, Ctx, VisitedCtxs);
+       }
+diff -rNU4 cvise-2.12.0--orig/clang_delta/CommonRenameClassRewriteVisitor.h cvise-2.12.0/clang_delta/CommonRenameClassRewriteVisitor.h
+--- cvise-2.12.0--orig/clang_delta/CommonRenameClassRewriteVisitor.h	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/CommonRenameClassRewriteVisitor.h	2026-07-17 14:14:42.079575996 +0200
+@@ -53,10 +53,13 @@
+          TemplateSpecializationTypeLoc TSPLoc);
+ 
+   bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc);
+ 
++#if LLVM_VERSION_MAJOR < 22
+   bool VisitDependentTemplateSpecializationTypeLoc(
+          DependentTemplateSpecializationTypeLoc DTSLoc);
++#endif
++
+ #if LLVM_VERSION_MAJOR < 19
+   bool VisitClassTemplatePartialSpecializationDecl(
+          ClassTemplatePartialSpecializationDecl *D);
+ #endif
+@@ -295,8 +298,9 @@
+ bool CommonRenameClassRewriteVisitor<T>::VisitInjectedClassNameTypeLoc(
+        InjectedClassNameTypeLoc TyLoc)
+ {
+   const CXXRecordDecl *CXXRD = TyLoc.getDecl();
++
+   TransAssert(CXXRD && "Invalid CXXRecordDecl!");
+ 
+   std::string Name;
+   if (getNewName(CXXRD, Name)) {
+@@ -336,8 +340,9 @@
+   if (Ty->isUnionType())
+     return true;
+ 
+   const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RTLoc.getDecl());
++
+   if (!RD)
+     return true;
+ 
+   std::string Name;
+@@ -358,8 +363,9 @@
+   RewriteHelper->replaceRecordType(RTLoc, Name);
+   return true;
+ }
+ 
++#if LLVM_VERSION_MAJOR < 22
+ template<typename T> bool CommonRenameClassRewriteVisitor<T>::
+   VisitDependentTemplateSpecializationTypeLoc(
+     DependentTemplateSpecializationTypeLoc DTSLoc)
+ {
+@@ -367,9 +373,14 @@
+   const DependentTemplateSpecializationType *DTST = 
+     dyn_cast<DependentTemplateSpecializationType>(Ty);
+   TransAssert(DTST && "Bad DependentTemplateSpecializationType!");
+ 
+-  const IdentifierInfo *IdInfo = DTST->getIdentifier();
++  const IdentifierInfo *IdInfo =
++#if LLVM_VERSION_MAJOR > 20
++    DTST->getDependentTemplateName().getName().getIdentifier();
++#else
++    DTST->getIdentifier();
++#endif
+   std::string IdName = IdInfo->getName().str();
+   std::string Name;
+   if (getNewNameByName(IdName, Name)) {
+     SourceLocation LocStart = DTSLoc.getTemplateNameLoc();
+@@ -377,15 +388,28 @@
+   }
+ 
+   return true;
+ }
++#endif
+ 
+ template<typename T>
+ void CommonRenameClassRewriteVisitor<T>::renameTemplateName(
+        TemplateName TmplName, SourceLocation LocStart)
+ {
++#if LLVM_VERSION_MAJOR < 22
+   if (TmplName.getKind() == TemplateName::DependentTemplate)
+     return;
++#else
++  if (TmplName.getKind() == TemplateName::DependentTemplate) {
++    DependentTemplateName* DTN = TmplName.getAsDependentTemplateName();
++    const IdentifierInfo *IdInfo = DTN->getName().getIdentifier();
++    std::string IdName = IdInfo->getName().str();
++    std::string Name;
++    if (getNewNameByName(IdName, Name))
++      TheRewriter->ReplaceText(LocStart, IdName.size(), Name);
++    return;
++  }
++#endif
+   const TemplateDecl *TmplD = TmplName.getAsTemplateDecl();
+   TransAssert(TmplD && "Invalid TemplateDecl!");
+   NamedDecl *ND = TmplD->getTemplatedDecl();
+   // in some cases, ND could be NULL, e.g., the 
+diff -rNU4 cvise-2.12.0--orig/clang_delta/EmptyStructToInt.cpp cvise-2.12.0/clang_delta/EmptyStructToInt.cpp
+--- cvise-2.12.0--orig/clang_delta/EmptyStructToInt.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/EmptyStructToInt.cpp	2026-07-17 14:00:33.565483599 +0200
+@@ -63,9 +63,11 @@
+   { }
+ 
+   bool VisitRecordTypeLoc(RecordTypeLoc RTLoc);
+ 
++#if LLVM_VERSION_MAJOR < 22
+   bool VisitElaboratedTypeLoc(ElaboratedTypeLoc Loc);
++#endif
+ 
+   bool VisitRecordDecl(RecordDecl *RD);
+ 
+   bool VisitVarDecl(VarDecl *VD);
+@@ -111,10 +113,38 @@
+ bool EmptyStructToIntRewriteVisitor::VisitRecordTypeLoc(RecordTypeLoc RTLoc)
+ {
+   const RecordDecl *RD = RTLoc.getDecl();
+ 
++
+   if (RD->getCanonicalDecl() == ConsumerInstance->TheRecordDecl) {
+     SourceLocation LocStart = RTLoc.getBeginLoc();
++#if LLVM_VERSION_MAJOR >= 22
++    // Check this ElaboratedTypeLoc hasn't been removed along with the RD
++    if (!ConsumerInstance->isSourceRangeWithinRecordDecl(
++          RTLoc.getSourceRange(), RD)) {
++      if (RTLoc.getBeginLoc() != RTLoc.getNonElaboratedBeginLoc()) {
++        SourceLocation KeywordEndLoc = RTLoc.getNonElaboratedBeginLoc().getLocWithOffset(-1);
++        ConsumerInstance->TheRewriter.RemoveText(SourceRange(RTLoc.getBeginLoc(), KeywordEndLoc));
++      } else {
++        // It's possible, e.g.,
++        // struct S1 {
++        //   struct { } S;
++        // };
++        // Clang will translate struct { } S to
++        // struct {
++        // };
++        //  struct <anonymous struct ...> S;
++        // the last declaration is injected by clang.
++        // We need to omit it.
++        SourceLocation KeywordLoc = RTLoc.getElaboratedKeywordLoc();
++        const llvm::StringRef Keyword =
++          TypeWithKeyword::getKeywordName(RTLoc.getTypePtr()->getKeyword());
++        ConsumerInstance->TheRewriter.ReplaceText(KeywordLoc,
++                                                  Keyword.size(), "int");
++      }
++    }
++#endif
++
+     void *LocPtr = LocStart.getPtrEncoding();
+     if (ConsumerInstance->VisitedLocs.count(LocPtr))
+       return true;
+     ConsumerInstance->VisitedLocs.insert(LocPtr);
+@@ -136,8 +166,9 @@
+   }
+   return true;
+ }
+ 
++#if LLVM_VERSION_MAJOR < 22
+ bool EmptyStructToIntRewriteVisitor::VisitElaboratedTypeLoc(
+        ElaboratedTypeLoc Loc)
+ {
+   const ElaboratedType *ETy = dyn_cast<ElaboratedType>(Loc.getTypePtr());
+@@ -159,8 +190,10 @@
+   SourceLocation EndLoc = TyLoc.getBeginLoc();
+   if (EndLoc.isInvalid())
+     return true;
+   EndLoc = EndLoc.getLocWithOffset(-1);
++  if (EndLoc.isInvalid())
++    return true;
+   // This ElaboratedTypeLoc has been removed along with the RD
+   if (ConsumerInstance->isSourceRangeWithinRecordDecl(
+         SourceRange(StartLoc, EndLoc), RD)) {
+     return true;
+@@ -192,8 +225,9 @@
+   
+   ConsumerInstance->TheRewriter.RemoveText(SourceRange(StartLoc, EndLoc));
+   return true;
+ }
++#endif
+ 
+ bool EmptyStructToIntRewriteVisitor::VisitRecordDecl(RecordDecl *RD)
+ {
+   //if (ConsumerInstance->isSpecialRecordDecl(RD))
+@@ -395,8 +429,9 @@
+   const RecordType *RT = PointeeTy->getAs<RecordType>();
+   if (!RT)
+     return false;
+   const RecordDecl *RD = RT->getDecl();
++
+   const RecordDecl *Parent = FD->getParent();
+   return (Parent->getCanonicalDecl() == RD->getCanonicalDecl());
+ }
+ 
+@@ -486,8 +521,9 @@
+     return NULL;
+ 
+   const RecordType *RT = Ty->getAsStructureType();
+   return RT->getDecl()->getDefinition();
++
+ }
+ 
+ void EmptyStructToInt::getInitExprs(const Type *Ty, 
+                                     const Expr *E,
+@@ -526,8 +562,9 @@
+   }
+ 
+   const RecordDecl *RD = RT->getDecl();
+ 
++
+   if (RD->getCanonicalDecl() == TheRecordDecl) {
+     InitExprs.push_back(E);
+   }
+   else {
+diff -rNU4 cvise-2.12.0--orig/clang_delta/InstantiateTemplateParam.cpp cvise-2.12.0/clang_delta/InstantiateTemplateParam.cpp
+--- cvise-2.12.0--orig/clang_delta/InstantiateTemplateParam.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/InstantiateTemplateParam.cpp	2026-07-17 14:00:33.565608845 +0200
+@@ -284,8 +284,9 @@
+        RecordDeclSet &TempAvailableRecordDecls)
+ {
+   if (const RecordType *RT = Ty->getAsUnionType()) {
+     const RecordDecl *RD = RT->getDecl();
++
+     addOneForwardDeclStr(RD, ForwardStr, TempAvailableRecordDecls);
+     return;
+   }
+ 
+diff -rNU4 cvise-2.12.0--orig/clang_delta/MemberToGlobal.cpp cvise-2.12.0/clang_delta/MemberToGlobal.cpp
+--- cvise-2.12.0--orig/clang_delta/MemberToGlobal.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/MemberToGlobal.cpp	2026-07-17 14:09:20.859030227 +0200
+@@ -28,9 +28,9 @@
+ 
+ static RegisterTransformation<MemberToGlobal>
+          Trans("member-to-global", DescriptionMsg);
+ 
+-class MemberToGlobal::CollectionVisitor : public 
++class MemberToGlobal::CollectionVisitor : public
+   RecursiveASTVisitor<CollectionVisitor> {
+ 
+ public:
+   explicit CollectionVisitor(MemberToGlobal *Instance)
+@@ -65,8 +65,9 @@
+ 
+     return true;
+   }
+ 
++#if LLVM_VERSION_MAJOR < 22
+   bool VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
+     // Replace CLASS::TYPE by TYPE
+     if (auto* TT = TL.getInnerType()->getAs<TypedefType>()) {
+       if (ConsumerInstance->isTheDecl(TT->getDecl())) {
+@@ -79,8 +80,21 @@
+     }
+ 
+     return true;
+   }
++#else
++  bool VisitTypedefTypeLoc(const TypedefTypeLoc &TTL) {
++    if (ConsumerInstance->isTheDecl(TTL.getDecl()))
++      ConsumerInstance->removeRecordQualifier(TTL.getQualifierLoc());
++    return true;
++  }
++
++  bool VisitTagTypeLoc(TagTypeLoc TL) {
++    if (ConsumerInstance->isTheDecl(TL.getDecl()))
++      ConsumerInstance->removeRecordQualifier(TL.getQualifierLoc());
++    return true;
++  }
++#endif
+ 
+   bool VisitDeclRefExpr(DeclRefExpr* DRE) {
+     if (ConsumerInstance->isTheDecl(DRE->getDecl())) {
+       ConsumerInstance->removeRecordQualifier(DRE->getQualifierLoc());
+@@ -92,9 +106,9 @@
+ private:
+   MemberToGlobal *ConsumerInstance;
+ };
+ 
+-void MemberToGlobal::Initialize(ASTContext &context) 
++void MemberToGlobal::Initialize(ASTContext &context)
+ {
+   Transformation::Initialize(context);
+ }
+ 
+@@ -111,10 +125,19 @@
+ void MemberToGlobal::removeRecordQualifier(const NestedNameSpecifierLoc& NNSLoc) {
+   if (!NNSLoc)
+     return;
+ 
+-  if (isTheRecordDecl(NNSLoc.getNestedNameSpecifier()->getAsRecordDecl())) {
++#if LLVM_VERSION_MAJOR < 22
++  CXXRecordDecl *RD = NNSLoc.getNestedNameSpecifier()->getAsRecordDecl();
++#else
++  CXXRecordDecl *RD = NNSLoc.getNestedNameSpecifier().getAsRecordDecl();
++#endif
++  if (isTheRecordDecl(RD)) {
+     SourceRange SR = NNSLoc.getLocalSourceRange();
++#if LLVM_VERSION_MAJOR >= 22
++    if (TypeLoc TL = NNSLoc.getAsTypeLoc())
++      SR.setBegin(TL.castAs<TagTypeLoc>().getNameLoc());
++#endif
+     SR.setEnd(SR.getEnd().getLocWithOffset(1));
+ 
+     TheRewriter.RemoveText(SR);
+   }
+diff -rNU4 cvise-2.12.0--orig/clang_delta/ReducePointerLevel.cpp cvise-2.12.0/clang_delta/ReducePointerLevel.cpp
+--- cvise-2.12.0--orig/clang_delta/ReducePointerLevel.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/ReducePointerLevel.cpp	2026-07-17 14:00:33.565837606 +0200
+@@ -259,15 +259,17 @@
+     if (!ArrayElemTy->isStructureType() && !ArrayElemTy->isUnionType())
+       return true;
+     if (const RecordType *RDTy = ArrayElemTy->getAs<RecordType>()) {
+       const RecordDecl *RD = RDTy->getDecl();
++
+       ConsumerInstance->rewriteArrayInit(RD, VD->getInit());
+     }
+     return true;
+   }
+ 
+   if (const RecordType *RDTy = VDTy->getAs<RecordType>()) {
+     const RecordDecl *RD = RDTy->getDecl();
++
+     ConsumerInstance->rewriteRecordInit(RD, VD->getInit());
+   }
+ 
+   return true;
+@@ -977,8 +979,9 @@
+   if (!RD)
+     return false;
+ 
+   const RecordDecl *NestedRD = RTy->getDecl();
++
+   return (RD->getCanonicalDecl() == NestedRD->getCanonicalDecl());
+ }
+ 
+ void ReducePointerLevel::rewriteRecordInit(const RecordDecl *RD,
+diff -rNU4 cvise-2.12.0--orig/clang_delta/RemoveBaseClass.cpp cvise-2.12.0/clang_delta/RemoveBaseClass.cpp
+--- cvise-2.12.0--orig/clang_delta/RemoveBaseClass.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/RemoveBaseClass.cpp	2026-07-17 14:00:33.565966068 +0200
+@@ -97,10 +97,10 @@
+        E = SubC->bases_end(); I != E; ++I) {
+     if (I->getType()->isDependentType())
+       continue;
+ 
+-    const CXXRecordDecl *BaseDecl =
+-      dyn_cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
++    const RecordType *RT = I->getType()->getAs<RecordType>();
++    const CXXRecordDecl *BaseDecl = dyn_cast<CXXRecordDecl>(RT->getDecl());
+     if (Base->getCanonicalDecl() == BaseDecl->getCanonicalDecl())
+       return true;
+   }
+   return false;
+@@ -199,9 +199,15 @@
+ }
+ 
+ bool RemoveBaseClass::isTheBaseClass(const CXXBaseSpecifier &Specifier)
+ {
++#if LLVM_VERSION_MAJOR < 22
+   const Type *Ty = TheBaseClass->getTypeForDecl();
++#else
++  const Type *Ty = TheBaseClass->getASTContext()
++                       .getCanonicalTagType(TheBaseClass)
++                       ->getTypePtr();
++#endif
+   return Context->hasSameType(Specifier.getType(), 
+                               Ty->getCanonicalTypeInternal());
+ }
+ 
+@@ -251,10 +257,18 @@
+ 
+     if ((*I)->isBaseInitializer()) {
+       const Type *Ty = (*I)->getBaseClass();
+       TransAssert(Ty && "Invalid Base Class Type!");
+-      if (Context->hasSameType(Ty->getCanonicalTypeInternal(),
+-            TheBaseClass->getTypeForDecl()->getCanonicalTypeInternal())) {
++#if LLVM_VERSION_MAJOR < 22
++      QualType CanonT =
++          TheBaseClass->getTypeForDecl()->getCanonicalTypeInternal();
++#else
++      QualType CanonT = TheBaseClass->getASTContext()
++                                   .getCanonicalTagType(TheBaseClass)
++                                   ->getTypePtr()
++                                   ->getCanonicalTypeInternal();
++#endif
++      if (Context->hasSameType(Ty->getCanonicalTypeInternal(), CanonT)) {
+         Init = (*I);
+         break;
+       }
+     }
+diff -rNU4 cvise-2.12.0--orig/clang_delta/RemoveNamespace.cpp cvise-2.12.0/clang_delta/RemoveNamespace.cpp
+--- cvise-2.12.0--orig/clang_delta/RemoveNamespace.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/RemoveNamespace.cpp	2026-07-17 14:14:42.080060829 +0200
+@@ -90,10 +90,12 @@
+ 
+   bool VisitTemplateSpecializationTypeLoc(
+          TemplateSpecializationTypeLoc TSPLoc);
+ 
++#if LLVM_VERSION_MAJOR < 22
+   bool VisitDependentTemplateSpecializationTypeLoc(
+          DependentTemplateSpecializationTypeLoc DTSLoc);
++#endif
+ 
+   bool VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TyLoc);
+ 
+   bool VisitTypedefTypeLoc(TypedefTypeLoc TyLoc);
+@@ -225,11 +227,21 @@
+ 
+   // check if this UsingDecl refers to the namespaced being removed
+   NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
+   TransAssert(QualifierLoc && "Bad QualifierLoc!");
++#if LLVM_VERSION_MAJOR < 22
+   NestedNameSpecifierLoc PrefixLoc = QualifierLoc.getPrefix();
++#else
++  NestedNameSpecifierLoc PrefixLoc =
++      QualifierLoc.getAsNamespaceAndPrefix().Prefix;
++#endif
+ 
++#if LLVM_VERSION_MAJOR < 22
+   const NestedNameSpecifier *NNS = D->getQualifier();
++#else
++  const NestedNameSpecifier NNSVal = QualifierLoc.getNestedNameSpecifier();
++  const NestedNameSpecifier *NNS = NNSVal ? &NNSVal : nullptr;
++#endif
+   TransAssert(NNS && "Bad NameSpecifier!");
+   if (ConsumerInstance->isTheNamespaceSpecifier(NNS) &&
+       (!PrefixLoc || ConsumerInstance->isGlobalNamespace(PrefixLoc))) {
+     ConsumerInstance->RewriteHelper->removeDecl(D);
+@@ -377,8 +389,9 @@
+ 
+ bool RemoveNamespaceRewriteVisitor::VisitRecordTypeLoc(RecordTypeLoc RTLoc)
+ {
+   const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RTLoc.getDecl());
++
+   if (!RD)
+     return true;
+ 
+   std::string Name;
+@@ -396,8 +409,41 @@
+     dyn_cast<TemplateSpecializationType>(Ty);
+   TransAssert(TST && "Bad TemplateSpecializationType!");
+ 
+   TemplateName TplName = TST->getTemplateName();
++
++#if LLVM_VERSION_MAJOR >= 22
++  if (TplName.getKind() == TemplateName::DependentTemplate) {
++    DependentTemplateName* DTN = TplName.getAsDependentTemplateName();
++    const IdentifierInfo *IdInfo = DTN->getName().getIdentifier();
++    std::string IdName = IdInfo->getName().str();
++    std::string Name;
++
++    // FIXME:
++    // This isn't quite right, we will generate bad code for some cases, e.g.,
++    // namespace NS1 {
++    //   template <class T> struct Base {};
++    //   template <class T> struct Derived: public Base<T> {
++    //     typename Derived::template Base<double>* p1;
++    //   };
++    // }
++    // template <class T> struct Base {};
++    // template <class T> struct Derived: public Base<T> {
++    //   typename Derived::template Base<double>* p1;
++    // };
++    // For the global Derived template class, we will end up with
++    // typename Derived::template Tran_NS_NS1_Base ...,
++    // which is obviously wrong.
++    // Any way to avoid this bad transformation?
++    if (ConsumerInstance->getNewNameByName(IdName, Name)) {
++      SourceLocation LocStart = TSPLoc.getTemplateNameLoc();
++      ConsumerInstance->TheRewriter.ReplaceText(
++        LocStart, IdName.size(), Name);
++    }
++    return true;
++  }
++#endif
++
+   const TemplateDecl *TplD = TplName.getAsTemplateDecl();
+   TransAssert(TplD && "Invalid TemplateDecl!");
+   NamedDecl *ND = TplD->getTemplatedDecl();
+   // in some cases, ND could be NULL, e.g., the
+@@ -426,8 +472,9 @@
+ 
+   return true;
+ }
+ 
++#if LLVM_VERSION_MAJOR < 22
+ // handle the case where a template specialization type cannot be resolved, e.g.
+ // template <class T> struct Base {};
+ // template <class T> struct Derived: public Base<T> {
+ //  typename Derived::template Base<double>* p1;
+@@ -439,9 +486,14 @@
+   const DependentTemplateSpecializationType *DTST =
+     dyn_cast<DependentTemplateSpecializationType>(Ty);
+   TransAssert(DTST && "Bad DependentTemplateSpecializationType!");
+ 
+-  const IdentifierInfo *IdInfo = DTST->getIdentifier();
++  const IdentifierInfo *IdInfo =
++#if LLVM_VERSION_MAJOR > 20
++    DTST->getDependentTemplateName().getName().getIdentifier();
++#else
++    DTST->getIdentifier();
++#endif
+   std::string IdName = IdInfo->getName().str();
+   std::string Name;
+ 
+   // FIXME:
+@@ -467,13 +519,15 @@
+   }
+ 
+   return true;
+ }
++#endif
+ 
+ bool RemoveNamespaceRewriteVisitor::VisitInjectedClassNameTypeLoc(
+        InjectedClassNameTypeLoc TyLoc)
+ {
+   const CXXRecordDecl *CXXRD = TyLoc.getDecl();
++
+   TransAssert(CXXRD && "Invalid CXXRecordDecl!");
+ 
+   std::string Name;
+   if (ConsumerInstance->getNewName(CXXRD, Name)) {
+@@ -487,9 +541,13 @@
+ }
+ 
+ bool RemoveNamespaceRewriteVisitor::VisitTypedefTypeLoc(TypedefTypeLoc TyLoc)
+ {
++#if LLVM_VERSION_MAJOR < 22
+   const TypedefNameDecl *D = TyLoc.getTypedefNameDecl();
++#else
++  const TypedefNameDecl *D = TyLoc.getDecl();
++#endif
+ 
+   std::string Name;
+   if (ConsumerInstance->getNewName(D, Name)) {
+     SourceLocation LocStart = TyLoc.getBeginLoc();
+@@ -502,8 +560,9 @@
+ bool RemoveNamespaceRewriteVisitor::VisitEnumTypeLoc(EnumTypeLoc TyLoc)
+ {
+   const EnumDecl *D = TyLoc.getDecl();
+ 
++
+   std::string Name;
+   if (ConsumerInstance->getNewName(D, Name)) {
+     SourceLocation LocStart = TyLoc.getBeginLoc();
+     ConsumerInstance->TheRewriter.ReplaceText(
+@@ -541,18 +600,33 @@
+   if (!QualifierLoc || QualifierLoc.getBeginLoc().isInvalid())
+     return true;
+ 
+   SmallVector<NestedNameSpecifierLoc, 8> QualifierLocs;
++#if LLVM_VERSION_MAJOR < 22
+   for (; QualifierLoc; QualifierLoc = QualifierLoc.getPrefix())
++#else
++  for (; QualifierLoc;
++       QualifierLoc = QualifierLoc.getAsNamespaceAndPrefix().Prefix)
++#endif
+     QualifierLocs.push_back(QualifierLoc);
+ 
+   while (!QualifierLocs.empty()) {
+     NestedNameSpecifierLoc Loc = QualifierLocs.pop_back_val();
++#if LLVM_VERSION_MAJOR < 22
+     NestedNameSpecifier *NNS = Loc.getNestedNameSpecifier();
++#else
++    NestedNameSpecifier NNSVal = Loc.getNestedNameSpecifier();
++    NestedNameSpecifier *NNS = NNSVal ? &NNSVal : nullptr;
++#endif
++#if LLVM_VERSION_MAJOR < 22
+     NestedNameSpecifier::SpecifierKind Kind = NNS->getKind();
++#else
++    NestedNameSpecifier::Kind Kind = NNS->getKind();
++#endif
+     const NamespaceDecl *ND = NULL;
+ 
+     switch (Kind) {
++#if LLVM_VERSION_MAJOR < 22
+       case NestedNameSpecifier::Namespace: {
+         ND = NNS->getAsNamespace()->getCanonicalDecl();
+         break;
+       }
+@@ -562,11 +636,29 @@
+           ND = NAD->getNamespace()->getCanonicalDecl();
+         break;
+       }
+       case NestedNameSpecifier::TypeSpec: // Fall-through
++#if LLVM_VERSION_MAJOR <= 20
+       case NestedNameSpecifier::TypeSpecWithTemplate:
++#endif
+         TraverseTypeLoc(Loc.getTypeLoc());
+         break;
++#else
++      case NestedNameSpecifier::Kind::Namespace: {
++        if (auto* NS = dyn_cast<NamespaceDecl>(
++                NNS->getAsNamespaceAndPrefix().Namespace)) {
++          ND = NS->getCanonicalDecl();
++        } else if (auto* NAD = dyn_cast<NamespaceAliasDecl>(
++                       NNS->getAsNamespaceAndPrefix().Namespace)) {
++          if (!NAD->getQualifier())
++            ND = NAD->getNamespace()->getCanonicalDecl();
++        }
++        break;
++      }
++      case NestedNameSpecifier::Kind::Type:
++        TraverseTypeLoc(Loc.getAsTypeLoc());
++        break;
++#endif
+       default:
+         break;
+     }
+ 
+@@ -772,17 +864,25 @@
+   std::string NewName;
+   UsingDecl *D = dyn_cast<UsingDecl>(UD->getIntroducer());
+ 
+   NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
++#if LLVM_VERSION_MAJOR < 22
+   NestedNameSpecifier *NNS = QualifierLoc.getNestedNameSpecifier();
++#else
++  NestedNameSpecifier NNS = QualifierLoc.getNestedNameSpecifier();
++#endif
+ 
+   // QualifierLoc could be ::foo, whose PrefixLoc is invalid, e.g.,
+   // void foo();
+   // namespace NS2 {
+   //   using ::foo;
+   //   void bar () { foo(); }
+   // }
++#if LLVM_VERSION_MAJOR < 22
+   if (NNS->getKind() != NestedNameSpecifier::Global) {
++#else
++  if (NNS.getKind() != NestedNameSpecifier::Kind::Global) {
++#endif
+     // NestedNameSpecifierLoc PrefixLoc = QualifierLoc.getPrefix();
+     RewriteHelper->getQualifierAsString(QualifierLoc, NewName);
+   }
+ 
+@@ -1102,16 +1202,26 @@
+ }
+ 
+ bool RemoveNamespace::isGlobalNamespace(NestedNameSpecifierLoc Loc)
+ {
++#if LLVM_VERSION_MAJOR < 22
+   NestedNameSpecifier *NNS = Loc.getNestedNameSpecifier();
+   return (NNS->getKind() == NestedNameSpecifier::Global);
++#else
++  NestedNameSpecifier NNS = Loc.getNestedNameSpecifier();
++  return (NNS.getKind() == NestedNameSpecifier::Kind::Global);
++#endif
+ }
+ 
+ bool RemoveNamespace::isTheNamespaceSpecifier(const NestedNameSpecifier *NNS)
+ {
++#if LLVM_VERSION_MAJOR < 22
+   NestedNameSpecifier::SpecifierKind Kind = NNS->getKind();
++#else
++  NestedNameSpecifier::Kind Kind = NNS->getKind();
++#endif
+   switch (Kind) {
++#if LLVM_VERSION_MAJOR < 22
+   case NestedNameSpecifier::Namespace: {
+     const NamespaceDecl *CanonicalND =
+       NNS->getAsNamespace()->getCanonicalDecl();
+     return (CanonicalND == TheNamespaceDecl);
+@@ -1125,8 +1235,22 @@
+     const NamespaceDecl *CanonicalND =
+       NAD->getNamespace()->getCanonicalDecl();
+     return (CanonicalND == TheNamespaceDecl);
+   }
++#else
++  case NestedNameSpecifier::Kind::Namespace: {
++    const NamespaceDecl* CanonicalND = nullptr;
++    if (auto* NS = dyn_cast<NamespaceDecl>(
++            NNS->getAsNamespaceAndPrefix().Namespace)) {
++      CanonicalND = NS->getCanonicalDecl();
++    } else if (auto* NAD = dyn_cast<NamespaceAliasDecl>(
++                    NNS->getAsNamespaceAndPrefix().Namespace)) {
++      if (NAD->getQualifier()) return false;
++      CanonicalND = NAD->getNamespace()->getCanonicalDecl();
++    }
++    return (CanonicalND == TheNamespaceDecl);
++  }
++#endif
+ 
+   default:
+     return false;
+   }
+diff -rNU4 cvise-2.12.0--orig/clang_delta/RemoveNestedFunction.cpp cvise-2.12.0/clang_delta/RemoveNestedFunction.cpp
+--- cvise-2.12.0--orig/clang_delta/RemoveNestedFunction.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/RemoveNestedFunction.cpp	2026-07-17 13:53:45.287068105 +0200
+@@ -282,10 +282,15 @@
+     TransAssert(((DName.getNameKind() == DeclarationName::Identifier) ||
+                  (DName.getNameKind() == DeclarationName::CXXOperatorName)) &&
+                 "Not an indentifier!");
+     const FunctionDecl *FD = NULL;
++#if LLVM_VERSION_MAJOR < 22
+     if (const NestedNameSpecifier *NNS = UE->getQualifier()) {
+       if (const DeclContext *Ctx = getDeclContextFromSpecifier(NNS)) {
++#else
++    if (const NestedNameSpecifier NNS = UE->getQualifier()) {
++      if (const DeclContext *Ctx = getDeclContextFromSpecifier(&NNS)) {
++#endif
+         DeclContextSet VisitedCtxs;
+         FD = lookupFunctionDecl(DName, Ctx, VisitedCtxs);
+       }
+     }
+diff -rNU4 cvise-2.12.0--orig/clang_delta/RemoveUnusedFunction.cpp cvise-2.12.0/clang_delta/RemoveUnusedFunction.cpp
+--- cvise-2.12.0--orig/clang_delta/RemoveUnusedFunction.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/RemoveUnusedFunction.cpp	2026-07-17 14:14:42.080537027 +0200
+@@ -253,9 +253,13 @@
+   }
+ 
+   if (FD->isReferenced() ||
+       FD->isMain() ||
++#if LLVM_VERSION_MAJOR > 20
++      FD->hasAttr<DeviceKernelAttr>() ||
++#else
+       FD->hasAttr<OpenCLKernelAttr>() ||
++#endif
+       ConsumerInstance->hasReferencedSpecialization(CanonicalFD) ||
+       ConsumerInstance->isInlinedSystemFunction(CanonicalFD) ||
+       ConsumerInstance->isInReferencedSet(CanonicalFD) ||
+       !ConsumerInstance->hasAtLeastOneValidLocation(CanonicalFD))
+@@ -757,23 +761,35 @@
+ {
+   std::unordered_set<const DeclContext *> seenDeclarations;
+   const FunctionDecl *FD = NULL;
+   switch (NNS->getKind()) {
+-  case NestedNameSpecifier::Namespace:
+-    FD = lookupFunctionDeclShallow(Name,
+-                                   NNS->getAsNamespace(),
+-                                   seenDeclarations);
++#if LLVM_VERSION_MAJOR < 22
++  case NestedNameSpecifier::Namespace: {
++    const DeclContext *DC = NNS->getAsNamespace();
++    FD = lookupFunctionDeclShallow(Name, DC, seenDeclarations);
+     break;
+-  case NestedNameSpecifier::NamespaceAlias:
++  }
++  case NestedNameSpecifier::NamespaceAlias: {
+     FD = lookupFunctionDeclShallow(Name,
+            NNS->getAsNamespaceAlias()->getNamespace(),
+            seenDeclarations);
+     break;
+-  case NestedNameSpecifier::Global:
++  }
++  case NestedNameSpecifier::Global: {
++#else
++  case NestedNameSpecifier::Kind::Namespace: {
++    const DeclContext *DC =
++        NNS->getAsNamespaceAndPrefix().Namespace->getDeclContext();
++    FD = lookupFunctionDeclShallow(Name, DC, seenDeclarations);
++    break;
++  }
++  case NestedNameSpecifier::Kind::Global: {
++#endif
+     FD = lookupFunctionDeclShallow(Name,
+                                    Context->getTranslationUnitDecl(),
+                                    seenDeclarations);
+     break;
++  }
+   default:
+     return NULL;
+   }
+   return FD;
+@@ -785,9 +801,14 @@
+   if (VisitedUsingDecls.count(UD))
+     return;
+ 
+   VisitedUsingDecls.insert(UD);
++#if LLVM_VERSION_MAJOR < 22
+   const NestedNameSpecifier *NNS = UD->getQualifier();
++#else
++  const NestedNameSpecifier NNSVal = UD->getQualifier();
++  const NestedNameSpecifier *NNS = NNSVal ? &NNSVal : nullptr;
++#endif
+   if (!NNS)
+     return;
+   DeclarationName Name = UD->getUnderlyingDecl()->getDeclName();
+   const FunctionDecl *FD = getFunctionDeclFromSpecifier(Name, NNS);
+@@ -844,9 +865,14 @@
+   DeclarationName::NameKind K = DName.getNameKind();
+   if ((K != DeclarationName::CXXOperatorName) &&
+       (K != DeclarationName::Identifier))
+     return;
++#if LLVM_VERSION_MAJOR < 22
+   const NestedNameSpecifier *NNS = E->getQualifier();
++#else
++  const NestedNameSpecifier NNSVal = E->getQualifier();
++  const NestedNameSpecifier *NNS = NNSVal ? &NNSVal : nullptr;
++#endif
+   // we fail only if UE is invoked with some qualifier or
+   // instantiation, e.g.:
+   // namespace NS { template<typename T> void foo(T&) { } }
+   // template<typename T> void bar(T p) { NS::foo(p); }
+diff -rNU4 cvise-2.12.0--orig/clang_delta/RemoveUnusedOuterClass.cpp cvise-2.12.0/clang_delta/RemoveUnusedOuterClass.cpp
+--- cvise-2.12.0--orig/clang_delta/RemoveUnusedOuterClass.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/RemoveUnusedOuterClass.cpp	2026-07-17 14:00:33.566350773 +0200
+@@ -52,8 +52,9 @@
+ 
+ bool RemoveUnusedOuterClassVisitor::VisitRecordTypeLoc(RecordTypeLoc TLoc)
+ {
+   const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TLoc.getDecl());
++
+   ConsumerInstance->UsedCXXRDSet.insert(RD->getCanonicalDecl());
+   return true;
+ }
+ 
+diff -rNU4 cvise-2.12.0--orig/clang_delta/RemoveUnusedStructField.cpp cvise-2.12.0/clang_delta/RemoveUnusedStructField.cpp
+--- cvise-2.12.0--orig/clang_delta/RemoveUnusedStructField.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/RemoveUnusedStructField.cpp	2026-07-17 14:00:33.566442546 +0200
+@@ -326,8 +326,9 @@
+     TransAssert(0 && "Bad RecordType!");
+   }
+ 
+   const RecordDecl *RD = RT->getDecl();
++
+   unsigned int VecSz = IdxVec->size();
+   for (IndexVector::const_iterator FI = IdxVec->begin(),
+        FE = IdxVec->end(); FI != FE; ++FI)
+   {
+@@ -407,9 +408,11 @@
+   if (!Ty->isStructureType())
+     return NULL;
+ 
+   const RecordType *RT = Ty->getAsStructureType();
+-  return RT->getDecl()->getDefinition();
++  const RecordDecl *RD = RT->getDecl();
++
++  return RD->getDefinition();
+ }
+ 
+ void RemoveUnusedStructField::removeFieldDecl(void)
+ {
+diff -rNU4 cvise-2.12.0--orig/clang_delta/RenameFun.cpp cvise-2.12.0/clang_delta/RenameFun.cpp
+--- cvise-2.12.0--orig/clang_delta/RenameFun.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/RenameFun.cpp	2026-07-17 14:14:42.080793420 +0200
+@@ -260,9 +260,15 @@
+ void RenameFun::addFun(const FunctionDecl *FD)
+ {
+   std::string Name = FD->getNameAsString();
+   // Skip special functions
+-  if (isSpecialFun(Name) || FD->hasAttr<OpenCLKernelAttr>())
++  if (isSpecialFun(Name) ||
++#if LLVM_VERSION_MAJOR > 20
++      FD->hasAttr<DeviceKernelAttr>()
++#else
++      FD->hasAttr<OpenCLKernelAttr>()
++#endif
++     )
+     FunToNameMap[FD] = Name;
+ 
+   if (FunToNameMap.find(FD) != FunToNameMap.end())
+     return;
+diff -rNU4 cvise-2.12.0--orig/clang_delta/ReplaceClassWithBaseTemplateSpec.cpp cvise-2.12.0/clang_delta/ReplaceClassWithBaseTemplateSpec.cpp
+--- cvise-2.12.0--orig/clang_delta/ReplaceClassWithBaseTemplateSpec.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/ReplaceClassWithBaseTemplateSpec.cpp	2026-07-17 14:00:33.566542795 +0200
+@@ -79,8 +79,9 @@
+   if (Ty->isUnionType())
+     return true;
+ 
+   const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TLoc.getDecl());
++
+   if (!RD || (RD->getCanonicalDecl() != ConsumerInstance->TheCXXRecord))
+     return true;
+ 
+   ConsumerInstance->RewriteHelper->replaceRecordType(
+diff -rNU4 cvise-2.12.0--orig/clang_delta/ReplaceDependentName.cpp cvise-2.12.0/clang_delta/ReplaceDependentName.cpp
+--- cvise-2.12.0--orig/clang_delta/ReplaceDependentName.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/ReplaceDependentName.cpp	2026-07-17 13:53:45.287638059 +0200
+@@ -54,14 +54,16 @@
+   ConsumerInstance->handleOneDependentNameTypeLoc(TLoc);
+   return true;
+ }
+ 
++#if LLVM_VERSION_MAJOR < 22
+ bool ReplaceDependentNameCollectionVisitor::VisitElaboratedTypeLoc(
+        ElaboratedTypeLoc TLoc)
+ {
+   ConsumerInstance->handleOneElaboratedTypeLoc(TLoc);
+   return true;
+ }
++#endif
+ 
+ void ReplaceDependentName::Initialize(ASTContext &context) 
+ {
+   Transformation::Initialize(context);
+@@ -93,8 +95,9 @@
+       Ctx.getDiagnostics().hasFatalErrorOccurred())
+     TransError = TransInternalError;
+ }
+ 
++#if LLVM_VERSION_MAJOR < 22
+ SourceLocation ReplaceDependentName::getElaboratedTypeLocBegin(
+                  const ElaboratedTypeLoc &TLoc)
+ {
+   SourceLocation Loc = TLoc.getElaboratedKeywordLoc();
+@@ -149,8 +152,9 @@
+     TheLocBegin = getElaboratedTypeLocBegin(TLoc);
+     TheNameLocEnd = TLoc.getEndLoc();
+   }
+ }
++#endif
+ 
+ void ReplaceDependentName::handleOneDependentNameTypeLoc(
+        const DependentNameTypeLoc &TLoc)
+ {
+diff -rNU4 cvise-2.12.0--orig/clang_delta/ReplaceDependentTypedef.cpp cvise-2.12.0/clang_delta/ReplaceDependentTypedef.cpp
+--- cvise-2.12.0--orig/clang_delta/ReplaceDependentTypedef.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/ReplaceDependentTypedef.cpp	2026-07-17 13:53:45.287729571 +0200
+@@ -44,13 +44,66 @@
+ 
+ static RegisterTransformation<ReplaceDependentTypedef>
+          Trans("replace-dependent-typedef", DescriptionMsg);
+ 
++static bool DependsOnTypedef(const Type &Ty) {
++  switch (Ty.getTypeClass()) {
++  case Type::SubstTemplateTypeParm: {
++    const SubstTemplateTypeParmType *TP =
++      dyn_cast<SubstTemplateTypeParmType>(&Ty);
++    const Type *ReplTy = TP->getReplacementType().getTypePtr();
++    return DependsOnTypedef(*ReplTy);
++  }
++
++#if LLVM_VERSION_MAJOR < 22
++  case Type::Elaborated: {
++    const ElaboratedType *ETy = dyn_cast<ElaboratedType>(&Ty);
++    const Type *NamedTy = ETy->getNamedType().getTypePtr();
++    return DependsOnTypedef(*NamedTy);
++  }
++#endif
++
++  case Type::Typedef: {
++    return true;
++  }
++
++  case Type::DependentName: {
++    const DependentNameType *DNT = dyn_cast<DependentNameType>(&Ty);
++#if LLVM_VERSION_MAJOR < 22
++    const NestedNameSpecifier *Specifier = DNT->getQualifier();
++#else
++    const NestedNameSpecifier Specifier = DNT->getQualifier();
++#endif
++    if (!Specifier)
++      return false;
++#if LLVM_VERSION_MAJOR < 22
++    const Type *NestedTy = Specifier->getAsType();
++#else
++    const Type *NestedTy = Specifier.getAsType();
++#endif
++    if (!NestedTy)
++      return false;
++    return DependsOnTypedef(*NestedTy);
++  }
++
++  case Type::Record:
++  case Type::Builtin: { // fall-through
++    return false;
++  }
++
++  default:
++    return false;
++  }
++
++  TransAssert(0 && "Unreachable code!");
++  return false;
++}
++
+ class ReplaceDependentTypedefCollectionVisitor : public
+   RecursiveASTVisitor<ReplaceDependentTypedefCollectionVisitor> {
+ 
+ public:
+-  explicit 
++  explicit
+   ReplaceDependentTypedefCollectionVisitor(ReplaceDependentTypedef *Instance)
+     : ConsumerInstance(Instance)
+   { }
+ 
+@@ -60,16 +113,16 @@
+   ReplaceDependentTypedef *ConsumerInstance;
+ 
+ };
+ 
+-bool 
++bool
+ ReplaceDependentTypedefCollectionVisitor::VisitTypedefNameDecl(TypedefNameDecl *D)
+ {
+   ConsumerInstance->handleOneTypedefDecl(D);
+   return true;
+ }
+ 
+-void ReplaceDependentTypedef::Initialize(ASTContext &context) 
++void ReplaceDependentTypedef::Initialize(ASTContext &context)
+ {
+   Transformation::Initialize(context);
+   CollectionVisitor = new ReplaceDependentTypedefCollectionVisitor(this);
+ }
+@@ -110,8 +163,9 @@
+   case Type::Typedef:
+   case Type::DependentName: // fall-through
+     return true;
+ 
++#if LLVM_VERSION_MAJOR < 22
+   case Type::Elaborated: {
+     const ElaboratedType *ETy = dyn_cast<ElaboratedType>(Ty);
+     ElaboratedTypeKeyword Keyword = ETy->getKeyword();
+ 
+@@ -120,9 +174,10 @@
+ #else
+     return ((Keyword == ETK_Typename) || (Keyword == ETK_None));
+ #endif
+   }
+-  
++#endif
++
+   default:
+     return false;
+   }
+ 
+@@ -136,8 +191,10 @@
+     return;
+ 
+   if (!isValidType(D->getUnderlyingType()))
+     return;
++  if (!DependsOnTypedef(*D->getUnderlyingType()))
++    return;
+ 
+   std::string Str = "";
+   bool Typename = false;
+   if (!getTypeString(D->getUnderlyingType(), Str, Typename))
+diff -rNU4 cvise-2.12.0--orig/clang_delta/ReplaceSimpleTypedef.cpp cvise-2.12.0/clang_delta/ReplaceSimpleTypedef.cpp
+--- cvise-2.12.0--orig/clang_delta/ReplaceSimpleTypedef.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/ReplaceSimpleTypedef.cpp	2026-07-17 14:00:33.566632104 +0200
+@@ -57,9 +57,11 @@
+   { }
+ 
+   bool VisitTypedefTypeLoc(TypedefTypeLoc Loc);
+ 
++#if LLVM_VERSION_MAJOR < 22
+   bool VisitElaboratedTypeLoc(ElaboratedTypeLoc Loc);
++#endif
+ 
+ private:
+   ReplaceSimpleTypedef *ConsumerInstance;
+ 
+@@ -96,8 +98,9 @@
+   }
+   return true;
+ }
+ 
++#if LLVM_VERSION_MAJOR < 22
+ // Handle cases like:
+ // struct S {
+ //   typedef int Int;
+ // };
+@@ -124,8 +127,9 @@
+     ConsumerInstance->Rewritten = true;
+   }
+   return true;
+ }
++#endif
+ 
+ void ReplaceSimpleTypedef::Initialize(ASTContext &context) 
+ {
+   Transformation::Initialize(context);
+@@ -177,8 +181,9 @@
+     return true;
+ 
+   if (const RecordType *RDTy = Ty->getAs<RecordType>()) {
+     const RecordDecl *RD = RDTy->getDecl();
++
+     // omit some trivial cases, e.g.,
+     // typedef struct S { int x; } S;
+     if (RD->getNameAsString() == D->getNameAsString())
+       return false;
+diff -rNU4 cvise-2.12.0--orig/clang_delta/RewriteUtils.cpp cvise-2.12.0/clang_delta/RewriteUtils.cpp
+--- cvise-2.12.0--orig/clang_delta/RewriteUtils.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/RewriteUtils.cpp	2026-07-17 14:09:20.860636248 +0200
+@@ -1702,9 +1702,13 @@
+   const IdentifierInfo *TypeId = RTLoc.getType().getBaseTypeIdentifier();
+   if (!TypeId)
+     return true;
+ 
++#if LLVM_VERSION_MAJOR < 22
+   SourceLocation LocStart = RTLoc.getBeginLoc();
++#else
++  SourceLocation LocStart = RTLoc.getNameLoc();
++#endif
+ 
+   // Loc could be invalid, for example:
+   // class AAA { };
+   // class BBB:AAA {
+diff -rNU4 cvise-2.12.0--orig/clang_delta/SimplifyDependentTypedef.cpp cvise-2.12.0/clang_delta/SimplifyDependentTypedef.cpp
+--- cvise-2.12.0--orig/clang_delta/SimplifyDependentTypedef.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/SimplifyDependentTypedef.cpp	2026-07-17 13:53:45.288153220 +0200
+@@ -202,13 +202,19 @@
+ 
+   QualType QT = CanonicalD->getUnderlyingType();
+   const Type *Ty = QT.getTypePtr();
+   Type::TypeClass TC = Ty->getTypeClass();
++#if LLVM_VERSION_MAJOR < 22
+   if ((TC != Type::DependentName) &&
+       (TC != Type::DependentTemplateSpecialization) &&
+       (TC != Type::TemplateSpecialization) &&
+       (TC != Type::Elaborated))
+     return;
++#else
++  if ((TC != Type::DependentName) &&
++      (TC != Type::TemplateSpecialization))
++    return;
++#endif
+ 
+   TemplateTypeParmTypeVisitor->setTypeSet(&TypeSet);
+   TemplateTypeParmTypeVisitor->setValidType(false);
+   TemplateTypeParmTypeVisitor->TraverseType(QT);
+diff -rNU4 cvise-2.12.0--orig/clang_delta/SimplifyNestedClass.cpp cvise-2.12.0/clang_delta/SimplifyNestedClass.cpp
+--- cvise-2.12.0--orig/clang_delta/SimplifyNestedClass.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/SimplifyNestedClass.cpp	2026-07-17 14:00:33.566720220 +0200
+@@ -77,8 +77,9 @@
+ 
+ bool SimplifyNestedClassRewriteVisitor::VisitRecordTypeLoc(RecordTypeLoc TLoc)
+ {
+   const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TLoc.getDecl());
++
+   if (!RD || (RD->getCanonicalDecl() != 
+               ConsumerInstance->TheBaseCXXRD->getCanonicalDecl()))
+     return true;
+ 
+diff -rNU4 cvise-2.12.0--orig/clang_delta/SimplifyStruct.cpp cvise-2.12.0/clang_delta/SimplifyStruct.cpp
+--- cvise-2.12.0--orig/clang_delta/SimplifyStruct.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/SimplifyStruct.cpp	2026-07-17 14:00:33.566813375 +0200
+@@ -99,8 +99,9 @@
+   if (!RT)
+     return true;
+ 
+   const RecordDecl *NestedRD = RT->getDecl();
++
+   if (NestedRD->getNameAsString() == "")
+     return true;
+ 
+   ConsumerInstance->ValidInstanceNum++;
+@@ -126,8 +127,9 @@
+   if (!RT)
+     return true;
+ 
+   const RecordDecl *RD = RT->getDecl();
++
+   if (RD != ConsumerInstance->TheRecordDecl)
+     return true;
+ 
+   SourceLocation LocStart = VD->getBeginLoc();
+@@ -182,8 +184,9 @@
+   if (Ty->isUnionType())
+     return true;
+ 
+   RecordDecl *RD = RTLoc.getDecl();
++
+   RecordDecl *CanonicalRD = dyn_cast<RecordDecl>(RD->getCanonicalDecl());
+   if (CanonicalRD != ConsumerInstance->TheRecordDecl)
+     return true;
+ 
+@@ -217,10 +220,11 @@
+ 
+   const Type *T = FD->getType().getTypePtr();
+   const RecordType *RT = T->getAs<RecordType>();
+   TransAssert(RT && "Invalid record type!");
+-  const RecordDecl *ReplacingRD = 
+-    dyn_cast<RecordDecl>(RT->getDecl()->getCanonicalDecl());
++  RecordDecl *RTD = RT->getDecl();
++
++  const RecordDecl *ReplacingRD = dyn_cast<RecordDecl>(RTD->getCanonicalDecl());
+   (void)ReplacingRD; 
+   TransAssert((ReplacingRD == ConsumerInstance->ReplacingRecordDecl) && 
+     "Unmatched Replacing RD!");
+ 
+diff -rNU4 cvise-2.12.0--orig/clang_delta/SimplifyStructUnionDecl.cpp cvise-2.12.0/clang_delta/SimplifyStructUnionDecl.cpp
+--- cvise-2.12.0--orig/clang_delta/SimplifyStructUnionDecl.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/SimplifyStructUnionDecl.cpp	2026-07-17 14:00:33.566911080 +0200
+@@ -220,8 +220,9 @@
+   else
+     return NULL;
+ 
+   return RT->getDecl();
++
+ }
+ 
+ bool SimplifyStructUnionDecl::handleOneDeclarator(const Type *Ty)
+ {
+diff -rNU4 cvise-2.12.0--orig/clang_delta/TemplateArgToInt.cpp cvise-2.12.0/clang_delta/TemplateArgToInt.cpp
+--- cvise-2.12.0--orig/clang_delta/TemplateArgToInt.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/TemplateArgToInt.cpp	2026-07-17 13:53:45.288531823 +0200
+@@ -324,13 +324,15 @@
+ TemplateArgToInt::getSubstTemplateTypeParmType(const Type *Ty)
+ {
+   Type::TypeClass TC = Ty->getTypeClass();
+   switch (TC) {
++#if LLVM_VERSION_MAJOR < 22
+   case Type::Elaborated: {
+     const ElaboratedType *ETy = dyn_cast<ElaboratedType>(Ty);
+     const Type *NamedT = ETy->getNamedType().getTypePtr();
+     return getSubstTemplateTypeParmType(NamedT);
+   }
++#endif
+ 
+   case Type::Typedef: {
+     const TypedefType *TdefTy = dyn_cast<TypedefType>(Ty);
+     const TypedefNameDecl *TdefD = TdefTy->getDecl();
+diff -rNU4 cvise-2.12.0--orig/clang_delta/tests/replace-dependent-typedef/test2.cc cvise-2.12.0/clang_delta/tests/replace-dependent-typedef/test2.cc
+--- cvise-2.12.0--orig/clang_delta/tests/replace-dependent-typedef/test2.cc	1970-01-01 01:00:00.000000000 +0100
++++ cvise-2.12.0/clang_delta/tests/replace-dependent-typedef/test2.cc	2026-07-17 13:53:38.929860733 +0200
+@@ -0,0 +1,19 @@
++template <typename T>
++struct A {
++  struct Inner;
++  // This shouldn't be treated as an instance:
++  typedef A::Inner Foo;
++};
++
++template <class T> struct S { typedef T type; };
++
++struct B {
++  struct Inner;
++};
++
++template <typename T>
++struct C {
++  typedef typename S<T>::type::Inner Bar;
++};
++
++typedef C<B>::Bar D;
+diff -rNU4 cvise-2.12.0--orig/clang_delta/tests/replace-dependent-typedef/test2.output cvise-2.12.0/clang_delta/tests/replace-dependent-typedef/test2.output
+--- cvise-2.12.0--orig/clang_delta/tests/replace-dependent-typedef/test2.output	1970-01-01 01:00:00.000000000 +0100
++++ cvise-2.12.0/clang_delta/tests/replace-dependent-typedef/test2.output	2026-07-17 13:53:38.929918442 +0200
+@@ -0,0 +1,19 @@
++template <typename T>
++struct A {
++  struct Inner;
++  // This shouldn't be treated as an instance:
++  typedef A::Inner Foo;
++};
++
++template <class T> struct S { typedef T type; };
++
++struct B {
++  struct Inner;
++};
++
++template <typename T>
++struct C {
++  typedef typename S<T>::type::Inner Bar;
++};
++
++typedef B::Inner D;
+diff -rNU4 cvise-2.12.0--orig/clang_delta/tests/test_clang_delta.py cvise-2.12.0/clang_delta/tests/test_clang_delta.py
+--- cvise-2.12.0--orig/clang_delta/tests/test_clang_delta.py	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/tests/test_clang_delta.py	2026-07-17 13:53:38.930086038 +0200
+@@ -893,8 +893,19 @@
+ 
+     def test_rename_var_rename_var(self):
+         self.check_clang_delta('rename-var/rename-var.c', '--transformation=rename-var --counter=1')
+ 
++    def test_replace_derived_class_replace_dependent_typedef_2(self):
++        self.check_query_instances(
++            'replace-dependent-typedef/test2.cc',
++            '--query-instances=replace-dependent-typedef',
++            'Available transformation instances: 1',
++        )
++        self.check_clang_delta(
++            'replace-dependent-typedef/test2.cc',
++            '--transformation=replace-dependent-typedef --counter=1',
++        )
++
+     def test_replace_derived_class_replace_derived1(self):
+         self.check_clang_delta(
+             'replace-derived-class/replace-derived1.cpp',
+             '--transformation=replace-derived-class --counter=1',
+diff -rNU4 cvise-2.12.0--orig/clang_delta/Transformation.cpp cvise-2.12.0/clang_delta/Transformation.cpp
+--- cvise-2.12.0--orig/clang_delta/Transformation.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/Transformation.cpp	2026-07-17 14:27:56.908516927 +0200
+@@ -603,10 +603,15 @@
+       return TD->getTemplatedDecl();
+ 
+     if (const UnresolvedUsingValueDecl *UUD =
+         dyn_cast<UnresolvedUsingValueDecl>(*I)) {
++#if LLVM_VERSION_MAJOR < 22
+       const NestedNameSpecifier *NNS = UUD->getQualifier();
+       const DeclContext *DeclCtx = getDeclContextFromSpecifier(NNS);
++#else
++      const NestedNameSpecifier NNS = UUD->getQualifier();
++      const DeclContext *DeclCtx = getDeclContextFromSpecifier(&NNS);
++#endif
+       if (!DeclCtx)
+         continue;
+       if (const FunctionDecl *FD =
+           lookupFunctionDecl(DName, DeclCtx, VisitedCtxs))
+@@ -662,24 +667,44 @@
+ 
+ const DeclContext *Transformation::getDeclContextFromSpecifier(
+         const NestedNameSpecifier *NNS)
+ {
++#if LLVM_VERSION_MAJOR < 22
+   for (; NNS; NNS = NNS->getPrefix()) {
+     NestedNameSpecifier::SpecifierKind Kind = NNS->getKind();
++#else
++  for (NestedNameSpecifier CurNNS = *NNS; CurNNS;
++       CurNNS = CurNNS.getAsNamespaceAndPrefix().Prefix) {
++    NestedNameSpecifier *NNS = &CurNNS;
++    NestedNameSpecifier::Kind Kind = NNS->getKind();
++#endif
+ 
+     switch (Kind) {
++#if LLVM_VERSION_MAJOR < 22
+       case NestedNameSpecifier::Namespace: {
+         return NNS->getAsNamespace()->getCanonicalDecl();
+       }
+       case NestedNameSpecifier::NamespaceAlias: {
+         const NamespaceAliasDecl *NAD = NNS->getAsNamespaceAlias();
+         return NAD->getNamespace()->getCanonicalDecl();
+       }
+       case NestedNameSpecifier::TypeSpec: // Fall-through
+-      case NestedNameSpecifier::TypeSpecWithTemplate: {
++      case NestedNameSpecifier::TypeSpecWithTemplate:
++#else
++      case NestedNameSpecifier::Kind::Namespace: {
++        const NamespaceDecl *NS = dyn_cast_if_present<NamespaceDecl>(
++            NNS->getAsNamespaceAndPrefix().Namespace);
++        if (!NS)
++          break;
++        return NS->getCanonicalDecl();
++      }
++      case NestedNameSpecifier::Kind::Type: 
++#endif
++      {
+         const Type *Ty = NNS->getAsType();
+-        if (const RecordType *RT = Ty->getAs<RecordType>())
++        if (const RecordType *RT = Ty->getAs<RecordType>()) {
+           return RT->getDecl();
++        }
+         if (const TypedefType *TT = Ty->getAs<TypedefType>()) {
+           const TypedefNameDecl *TypeDecl = TT->getDecl();
+           const Type *UnderlyingTy = TypeDecl->getUnderlyingType().getTypePtr();
+           if (const RecordType *RT = UnderlyingTy->getAs<RecordType>())
+@@ -741,8 +766,9 @@
+       dyn_cast<TemplateSpecializationType>(Ty);
+     return getBaseDeclFromTemplateSpecializationType(TSTy);
+   }
+ 
++#if LLVM_VERSION_MAJOR < 22
+   case Type::DependentTemplateSpecialization: {
+     return NULL;
+   }
+ 
+@@ -750,8 +776,9 @@
+     const ElaboratedType *ETy = dyn_cast<ElaboratedType>(Ty);
+     const Type *NamedT = ETy->getNamedType().getTypePtr();
+     return getBaseDeclFromType(NamedT);
+   }
++#endif
+ 
+   case Type::Paren: {
+     const ParenType *PT = dyn_cast<ParenType>(Ty);
+     const Type *InnerTy = PT->getInnerType().getTypePtr();
+@@ -931,12 +958,19 @@
+   const DependentNameType *DNT = dyn_cast<DependentNameType>(Ty);
+   const IdentifierInfo *IdInfo = DNT->getIdentifier();
+   if (!IdInfo)
+     return false;
++#if LLVM_VERSION_MAJOR < 22
+   const NestedNameSpecifier *Specifier = DNT->getQualifier();
+   if (!Specifier)
+     return false;
+   const Type *DependentTy = Specifier->getAsType();
++#else
++  const NestedNameSpecifier Specifier = DNT->getQualifier();
++  if (!Specifier)
++    return false;
++  const Type *DependentTy = Specifier.getAsType();
++#endif
+   if (!DependentTy)
+     return false;
+ 
+   const TemplateTypeParmType *ParmTy =
+@@ -1028,12 +1062,19 @@
+ {
+   const IdentifierInfo *IdInfo = DNT->getIdentifier();
+   if (!IdInfo)
+     return false;
++#if LLVM_VERSION_MAJOR < 22
+   const NestedNameSpecifier *Specifier = DNT->getQualifier();
+   if (!Specifier)
+     return false;
+   const Type *Ty = Specifier->getAsType();
++#else
++  const NestedNameSpecifier Specifier = DNT->getQualifier();
++  if (!Specifier)
++    return false;
++  const Type *Ty = Specifier.getAsType();
++#endif
+   if (!Ty)
+     return false;
+   const CXXRecordDecl *Base = getBaseDeclFromType(Ty);
+   if (!Base)
+@@ -1066,12 +1107,14 @@
+       dyn_cast<SubstTemplateTypeParmType>(Ty);
+     return getTypeString(TP->getReplacementType(), Str, Typename);
+   }
+ 
++#if LLVM_VERSION_MAJOR < 22
+   case Type::Elaborated: {
+     const ElaboratedType *ETy = dyn_cast<ElaboratedType>(Ty);
+     return getTypeString(ETy->getNamedType(), Str, Typename);
+   }
++#endif
+ 
+   case Type::Typedef: {
+     const TypedefType *TdefTy = dyn_cast<TypedefType>(Ty);
+     const TypedefNameDecl *TdefD = TdefTy->getDecl();
+@@ -1082,10 +1125,19 @@
+     const DependentNameType *DNT = dyn_cast<DependentNameType>(Ty);
+     return getDependentNameTypeString(DNT, Str, Typename);
+   }
+ 
+-  case Type::Record:
+-  case Type::Builtin: { // fall-through
++  case Type::Record: {
++#if LLVM_VERSION_MAJOR >= 22
++    const RecordType *RT = dyn_cast<RecordType>(Ty);
++    QualType DQT = RT->desugar();
++    if (DQT != QT)
++      return getTypeString(DQT, Str, Typename);
++#endif
++    [[fallthrough]];
++  }
++
++  case Type::Builtin: {
+     QT.getAsStringInternal(Str, getPrintingPolicy());
+     return true;
+   }
+ 
+diff -rNU4 cvise-2.12.0--orig/clang_delta/TransformationManager.cpp cvise-2.12.0/clang_delta/TransformationManager.cpp
+--- cvise-2.12.0--orig/clang_delta/TransformationManager.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/TransformationManager.cpp	2026-07-17 14:14:42.081613846 +0200
+@@ -97,13 +97,16 @@
+ 
+   ClangInstance = new CompilerInstance();
+   assert(ClangInstance);
+   
+-  ClangInstance->createDiagnostics(
+-#if LLVM_VERSION_MAJOR >= 20
+-    *llvm::vfs::getRealFileSystem()
++#if LLVM_VERSION_MAJOR < 20
++  ClangInstance->createDiagnostics();
++#elif LLVM_VERSION_MAJOR < 22
++  ClangInstance->createDiagnostics(*llvm::vfs::getRealFileSystem());
++#else
++  ClangInstance->createVirtualFileSystem(llvm::vfs::getRealFileSystem());
++  ClangInstance->createDiagnostics();
+ #endif
+-  );
+ 
+   TargetOptions &TargetOpts = ClangInstance->getTargetOpts();
+   if (const char *env = getenv("CVISE_TARGET_TRIPLE")) {
+     TargetOpts.Triple = std::string(env);
+@@ -162,9 +165,14 @@
+ 
+     ClangInstance->createFileManager();
+ 
+     if(CLCPath != NULL && ClangInstance->hasFileManager() &&
+-       ClangInstance->getFileManager().getDirectory(CLCPath, false)) {
++#if LLVM_VERSION_MAJOR > 20
++       ClangInstance->getFileManager().getDirectoryRef(CLCPath, false)
++#else
++       ClangInstance->getFileManager().getDirectory(CLCPath, false)
++#endif
++      ) {
+         Args.push_back("-I");
+         Args.push_back(CLCPath);
+     }
+ 
+@@ -185,9 +193,14 @@
+   }
+ 
+   TargetInfo *Target = 
+     TargetInfo::CreateTargetInfo(ClangInstance->getDiagnostics(),
+-                                 ClangInstance->getInvocation().TargetOpts);
++#if LLVM_VERSION_MAJOR > 20
++                                 ClangInstance->getInvocation().getTargetOpts()
++#else
++                                 ClangInstance->getInvocation().TargetOpts
++#endif
++                                );
+   ClangInstance->setTarget(Target);
+ 
+   if (const char *env = getenv("CVISE_INCLUDE_PATH")) {
+     HeaderSearchOptions &HeaderSearchOpts = ClangInstance->getHeaderSearchOpts();
+@@ -204,9 +217,13 @@
+     } while(next != npos);
+   }
+ 
+   ClangInstance->createFileManager();
++#if LLVM_VERSION_MAJOR < 22
+   ClangInstance->createSourceManager(ClangInstance->getFileManager());
++#else
++  ClangInstance->createSourceManager();
++#endif
+   ClangInstance->createPreprocessor(TU_Complete);
+ 
+   DiagnosticConsumer &DgClient = ClangInstance->getDiagnosticClient();
+   DgClient.BeginSourceFile(ClangInstance->getLangOpts(),
+diff -rNU4 cvise-2.12.0--orig/clang_delta/UnionToStruct.cpp cvise-2.12.0/clang_delta/UnionToStruct.cpp
+--- cvise-2.12.0--orig/clang_delta/UnionToStruct.cpp	2025-09-23 22:51:29.000000000 +0200
++++ cvise-2.12.0/clang_delta/UnionToStruct.cpp	2026-07-17 14:00:33.567272221 +0200
+@@ -407,9 +407,9 @@
+   TransAssert(RDTy && "Bad RecordType!");
+   if (RDTy->isIncompleteType())
+     return;
+ 
+-  const RecordDecl *RD = RDTy->getDecl(); 
++  const RecordDecl *RD = RDTy->getDecl();
+   const RecordDecl *CanonicalRD = 
+     dyn_cast<RecordDecl>(RD->getCanonicalDecl());
+   TransAssert(CanonicalRD && "NULL CanonicalRD!");
+   if (CanonicalRD->getNameAsString() == "") {

diff --git a/sources b/sources
index bc77a5d..569811b 100644
--- a/sources
+++ b/sources
@@ -1 +1 @@
-SHA512 (v2.11.0.tar.gz) = 4c0844f1ce0596a7aed84018ecf63fbed31e7fb474d341f9947e99ee61274713ad8ae5dce619fcbc7b2acdddb950b1418989e9cd6cd6d7a2031e56226ccf9f57
+SHA512 (v2.12.0.tar.gz) = 1561e8e7c96cfb4d24be4ffb3b8ee3c9148a715a636252a52d79f02e10ea61db285979c53ad51c797b39bc750e74682942af858187fdbf3d96d9978f8f8301b2