From f6ce878071cdeb4faa3a4d217b18ab8312dcddc4 Mon Sep 17 00:00:00 2001
From: duckdoom5 <duckdoom5@users.noreply.github.com>
Date: Fri, 28 Feb 2025 16:40:21 +0100
Subject: [PATCH] `FindClass` patch

---
 src/AST/ASTContext.cs                         | 12 +++----
 src/AST/Namespace.cs                          | 36 +++++++++++++------
 .../Passes/MoveFunctionToClassPass.cs         |  2 +-
 .../Passes/StripUnusedSystemTypesPass.cs      |  2 +-
 4 files changed, 33 insertions(+), 19 deletions(-)

diff --git a/src/AST/ASTContext.cs b/src/AST/ASTContext.cs
index e52107e0..e478a2fe 100644
--- a/src/AST/ASTContext.cs
+++ b/src/AST/ASTContext.cs
@@ -75,20 +75,18 @@ namespace CppSharp.AST
         }
 
         /// Finds an existing struct/class in the library modules.
-        public IEnumerable<Class> FindClass(string name, bool create = false,
-            bool ignoreCase = false)
+        public IEnumerable<Class> FindClass(string name, bool create = false)
         {
             return TranslationUnits.Select(
-                module => module.FindClass(name,
-                    ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal))
+                module => module.FindClass(name))
                 .Where(type => type != null);
         }
 
         /// Finds the complete declaration of a class.
-        public Class FindCompleteClass(string name, bool ignoreCase = false)
+        public Class FindCompleteClass(string name)
         {
-            return FindClass(name, ignoreCase: ignoreCase).FirstOrDefault(
-                @class => !@class.IsIncomplete);
+            return FindClass(name)
+                .FirstOrDefault(@class => !@class.IsIncomplete);
         }
 
         /// Finds an existing function in the library modules.
diff --git a/src/AST/Namespace.cs b/src/AST/Namespace.cs
index 13f9cf32..b7af87fb 100644
--- a/src/AST/Namespace.cs
+++ b/src/AST/Namespace.cs
@@ -203,17 +203,33 @@ namespace CppSharp.AST
             };
         }
 
-        public Class FindClass(string name,
-            StringComparison stringComparison = StringComparison.Ordinal)
+        public Class FindClass(string name)
         {
-            if (string.IsNullOrEmpty(name)) return null;
-
-            var @class = Classes.FirstOrDefault(c => c.Name.Equals(name, stringComparison)) ??
-                Namespaces.Select(n => n.FindClass(name, stringComparison)).FirstOrDefault(c => c != null);
-            if (@class != null)
-                return @class.CompleteDeclaration == null ?
-                    @class : (Class)@class.CompleteDeclaration;
-            return null;
+            if (string.IsNullOrEmpty(name))
+                return null;
+
+            var entries = name.Split(new[] { "::" }, StringSplitOptions.RemoveEmptyEntries)
+                .ToArray();
+
+            if (entries.Length <= 1)
+            {
+                var @class = Classes.FirstOrDefault(e => e.Name.Equals(name));
+
+                if (@class == null)
+                    return null;
+
+                if (@class.CompleteDeclaration == null)
+                    return @class;
+
+                return (Class)@class.CompleteDeclaration;
+            }
+
+            var className = entries[^1];
+            var namespaces = entries.Take(entries.Length - 1);
+
+            var @namespace = FindNamespace(namespaces);
+
+            return @namespace?.FindClass(className);
         }
 
         public Class FindClass(string name, bool isComplete,
diff --git a/src/Generator/Passes/MoveFunctionToClassPass.cs b/src/Generator/Passes/MoveFunctionToClassPass.cs
index ebfe808e..a7297466 100644
--- a/src/Generator/Passes/MoveFunctionToClassPass.cs
+++ b/src/Generator/Passes/MoveFunctionToClassPass.cs
@@ -61,7 +61,7 @@ namespace CppSharp.Passes
                 string name = tu != null ? Options.GenerateFreeStandingFunctionsClassName(tu) :
                     function.Namespace.Name;
                 @class = ASTContext.FindClass(
-                    name, ignoreCase: true).FirstOrDefault(
+                    name).FirstOrDefault(
                         c => c.TranslationUnit.Module == function.TranslationUnit.Module &&
                             !c.IsIncomplete);
             }
diff --git a/src/Generator/Passes/StripUnusedSystemTypesPass.cs b/src/Generator/Passes/StripUnusedSystemTypesPass.cs
index 46aa1c0f..875020de 100644
--- a/src/Generator/Passes/StripUnusedSystemTypesPass.cs
+++ b/src/Generator/Passes/StripUnusedSystemTypesPass.cs
@@ -16,7 +16,7 @@ namespace CppSharp.Passes
             // we need this one for marshalling std::string
             foreach (var name in new[] { "allocator", "char_traits" })
             {
-                var forceIncludedClasses = context.FindClass(name, false, true)
+                var forceIncludedClasses = context.FindClass(name)
                     .Where(a => a.TranslationUnit.IsSystemHeader);
 
                 foreach (var usedStdType in forceIncludedClasses)