FindClass patch

Author: duckdoom5

src/AST/ASTContext.cs

@@ -75,20 +75,18 @@ public Enumeration FindCompleteEnum(string name)
         }
 
         /// 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.

src/AST/Namespace.cs

@@ -203,17 +203,33 @@ Class CreateClass(string name, bool isComplete)
             };
         }
 
-        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,

src/Generator/Passes/MoveFunctionToClassPass.cs

@@ -61,7 +61,7 @@ private Class FindClassToMoveFunctionTo(Function function)
                 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 @@ public override bool VisitASTContext(ASTContext context)
             // 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)