`FindClass` patch

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,
+        public IEnumerable<Class> FindClass(string name, bool create = false)
-            bool ignoreCase = false)
         {
             return TranslationUnits.Select(
-                module => module.FindClass(name,
+                module => module.FindClass(name))
-                    ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal))
                 .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(
+            return FindClass(name)
-                @class => !@class.IsIncomplete);
+                .FirstOrDefault(@class => !@class.IsIncomplete);
         }
 
         /// Finds an existing function in the library modules.

src/AST/Namespace.cs

@@ -203,17 +203,33 @@ namespace CppSharp.AST
             };
         }
 
-        public Class FindClass(string name,
+        public Class FindClass(string name)
-            StringComparison stringComparison = StringComparison.Ordinal)
         {
-            if (string.IsNullOrEmpty(name)) return null;
+            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);
+            var entries = name.Split(new[] { "::" }, StringSplitOptions.RemoveEmptyEntries)
-            if (@class != null)
+                .ToArray();
-                return @class.CompleteDeclaration == null ?
+
-                    @class : (Class)@class.CompleteDeclaration;
+            if (entries.Length <= 1)
-            return null;
+            {
+                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,

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);
             }

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)