From b3b04e5a7e4e36e579973fd4438dd579761cba7a Mon Sep 17 00:00:00 2001
From: Deadlocklogic <deadlocklogic@gmail.com>
Date: Tue, 2 Jan 2024 07:28:20 +0200
Subject: [PATCH] Parser.cpp: use nullptr TypeLoc fallthrough when semantics
 are unexpected

---
 src/CppParser/Parser.cpp | 112 +++++++++++++++++++--------------------
 1 file changed, 54 insertions(+), 58 deletions(-)

diff --git a/src/CppParser/Parser.cpp b/src/CppParser/Parser.cpp
index 6f06249a..04bae6c9 100644
--- a/src/CppParser/Parser.cpp
+++ b/src/CppParser/Parser.cpp
@@ -2640,40 +2640,38 @@ Type* Parser::WalkType(clang::QualType QualType, const clang::TypeLoc* TL,
 
         TemplateArgumentList TArgs(TemplateArgumentList::OnStack, TS->template_arguments());
 
-        if (LocValid)
+        do
         {
-            TypeLoc UTL, ETL, ITL;
-            if (TL->getTypeLocClass() == TypeLoc::Qualified)
-            {
-                UTL = TL->getUnqualifiedLoc();
-                TL = &UTL;
-            }
-            if (TL->getTypeLocClass() == TypeLoc::Elaborated)
+            if (LocValid)
             {
-                ETL = TL->getAs<ElaboratedTypeLoc>();
-                ITL = ETL.getNextTypeLoc();
-                TL = &ITL;
-            }
+                TypeLoc UTL, ETL, ITL;
+                if (TL->getTypeLocClass() == TypeLoc::Qualified)
+                {
+                    UTL = TL->getUnqualifiedLoc();
+                    TL = &UTL;
+                }
+                if (TL->getTypeLocClass() == TypeLoc::Elaborated)
+                {
+                    ETL = TL->getAs<ElaboratedTypeLoc>();
+                    ITL = ETL.getNextTypeLoc();
+                    TL = &ITL;
+                }
 
-            if (TL->getTypeLocClass() == TypeLoc::DependentTemplateSpecialization)
-            {
-                DependentTemplateSpecializationTypeLoc TSpecTL = TL->getAs<DependentTemplateSpecializationTypeLoc>();
-                TST->Arguments = WalkTemplateArgumentList(&TArgs, &TSpecTL);
-            }
-            else if (TL->getTypeLocClass() == TypeLoc::TemplateSpecialization)
-            {
-                TemplateSpecializationTypeLoc TSpecTL = TL->getAs<TemplateSpecializationTypeLoc>();
-                TST->Arguments = WalkTemplateArgumentList(&TArgs, &TSpecTL);
-            }
-            else
-            {
-                llvm_unreachable("Unexpected semantics");
+                if (TL->getTypeLocClass() == TypeLoc::DependentTemplateSpecialization)
+                {
+                    DependentTemplateSpecializationTypeLoc TSpecTL = TL->getAs<DependentTemplateSpecializationTypeLoc>();
+                    TST->Arguments = WalkTemplateArgumentList(&TArgs, &TSpecTL);
+                    break;
+                }
+                else if (TL->getTypeLocClass() == TypeLoc::TemplateSpecialization)
+                {
+                    TemplateSpecializationTypeLoc TSpecTL = TL->getAs<TemplateSpecializationTypeLoc>();
+                    TST->Arguments = WalkTemplateArgumentList(&TArgs, &TSpecTL);
+                    break;
+                }
             }
-        }
-        else
-        {
             TST->Arguments = WalkTemplateArgumentList(&TArgs, (TemplateSpecializationTypeLoc*)nullptr);
-        }
+        } while (false);
 
         Ty = TST;
         break;
@@ -2688,40 +2686,38 @@ Type* Parser::WalkType(clang::QualType QualType, const clang::TypeLoc* TL,
 
         TemplateArgumentList TArgs(TemplateArgumentList::OnStack, TS->template_arguments());
 
-        if (LocValid)
+        do
         {
-            TypeLoc UTL, ETL, ITL;
-            if (TL->getTypeLocClass() == TypeLoc::Qualified)
-            {
-                UTL = TL->getUnqualifiedLoc();
-                TL = &UTL;
-            }
-            if (TL->getTypeLocClass() == TypeLoc::Elaborated)
+            if (LocValid)
             {
-                ETL = TL->getAs<ElaboratedTypeLoc>();
-                ITL = ETL.getNextTypeLoc();
-                TL = &ITL;
-            }
+                TypeLoc UTL, ETL, ITL;
+                if (TL->getTypeLocClass() == TypeLoc::Qualified)
+                {
+                    UTL = TL->getUnqualifiedLoc();
+                    TL = &UTL;
+                }
+                if (TL->getTypeLocClass() == TypeLoc::Elaborated)
+                {
+                    ETL = TL->getAs<ElaboratedTypeLoc>();
+                    ITL = ETL.getNextTypeLoc();
+                    TL = &ITL;
+                }
 
-            if (TL->getTypeLocClass() == TypeLoc::DependentTemplateSpecialization)
-            {
-                DependentTemplateSpecializationTypeLoc TSpecTL = TL->getAs<DependentTemplateSpecializationTypeLoc>();
-                TST->Arguments = WalkTemplateArgumentList(&TArgs, &TSpecTL);
-            }
-            else if (TL->getTypeLocClass() == TypeLoc::TemplateSpecialization)
-            {
-                TemplateSpecializationTypeLoc TSpecTL = TL->getAs<TemplateSpecializationTypeLoc>();
-                TST->Arguments = WalkTemplateArgumentList(&TArgs, &TSpecTL);
-            }
-            else
-            {
-                llvm_unreachable("Unexpected semantics");
+                if (TL->getTypeLocClass() == TypeLoc::DependentTemplateSpecialization)
+                {
+                    DependentTemplateSpecializationTypeLoc TSpecTL = TL->getAs<DependentTemplateSpecializationTypeLoc>();
+                    TST->Arguments = WalkTemplateArgumentList(&TArgs, &TSpecTL);
+                    break;
+                }
+                else if (TL->getTypeLocClass() == TypeLoc::TemplateSpecialization)
+                {
+                    TemplateSpecializationTypeLoc TSpecTL = TL->getAs<TemplateSpecializationTypeLoc>();
+                    TST->Arguments = WalkTemplateArgumentList(&TArgs, &TSpecTL);
+                    break;
+                }
             }
-        }
-        else
-        {
             TST->Arguments = WalkTemplateArgumentList(&TArgs, (DependentTemplateSpecializationTypeLoc*)nullptr);
-        }
+        } while (false);
 
         Ty = TST;
         break;