Removed the useless marking of supported system template specialisations.

Signed-off-by: Dimitar Dobrev <dpldobrev@protonmail.com>

src/Generator/Driver.cs

@@ -280,10 +280,8 @@ namespace CppSharp
 
             TranslationUnitPasses.AddPass(new SortDeclarationsPass());
             TranslationUnitPasses.AddPass(new ResolveIncompleteDeclsPass());
-            if (Options.IsCSharpGenerator)
-                TranslationUnitPasses.AddPass(new MarkSupportedSpecializationsPass());
-            TranslationUnitPasses.AddPass(new IgnoreSystemDeclarationsPass());
             TranslationUnitPasses.AddPass(new CheckIgnoredDeclsPass());
+            TranslationUnitPasses.AddPass(new IgnoreSystemDeclarationsPass());
 
             if (Options.IsCSharpGenerator)
             {

src/Generator/Passes/IgnoreSystemDeclarationsPass.cs

@@ -9,6 +9,7 @@ namespace CppSharp.Passes
         public IgnoreSystemDeclarationsPass()
         {
             VisitOptions.VisitClassBases = false;
+            VisitOptions.VisitClassTemplateSpecializations = false;
             VisitOptions.VisitClassFields = false;
             VisitOptions.VisitClassMethods = false;
             VisitOptions.VisitClassProperties = false;
@@ -17,6 +18,7 @@ namespace CppSharp.Passes
             VisitOptions.VisitNamespaceEnums = false;
             VisitOptions.VisitNamespaceEvents = false;
             VisitOptions.VisitNamespaceTemplates = false;
+            VisitOptions.VisitNamespaceTypedefs = false;
             VisitOptions.VisitTemplateArguments = false;
         }
 
@@ -44,7 +46,7 @@ namespace CppSharp.Passes
             if (!@class.IsExplicitlyGenerated)
                 @class.ExplicitlyIgnore();
 
-            if (!@class.IsDependent)
+            if (!@class.IsDependent || @class.Specializations.Count == 0)
                 return false;
 
             // we only need a few members for marshalling so strip the rest
@@ -53,54 +55,51 @@ namespace CppSharp.Passes
                 case "basic_string":
                     foreach (var method in @class.Methods.Where(m => !m.IsDestructor && m.OriginalName != "c_str"))
                         method.ExplicitlyIgnore();
-                    foreach (var specialization in @class.Specializations.Where(s => !s.Ignore))
+                    var basicString = @class.Specializations.First(s =>
+                        s.Arguments[0].Type.Type.Desugar().IsPrimitiveType(PrimitiveType.Char));
+                    basicString.GenerationKind = GenerationKind.Generate;
+                    foreach (var method in basicString.Methods)
                     {
-                        foreach (var method in specialization.Methods)
+                        if (method.IsDestructor || method.OriginalName == "c_str" ||
+                            (method.IsConstructor && method.Parameters.Count == 2 &&
+                             method.Parameters[0].Type.Desugar().IsPointerToPrimitiveType(PrimitiveType.Char) &&
+                             !method.Parameters[1].Type.Desugar().IsPrimitiveType()))
                         {
-                            if (method.IsDestructor || method.OriginalName == "c_str" ||
+                            method.GenerationKind = GenerationKind.Generate;
-                                (method.IsConstructor && method.Parameters.Count == 2 &&
+                            method.Namespace.GenerationKind = GenerationKind.Generate;
-                                 method.Parameters[0].Type.Desugar().IsPointerToPrimitiveType(PrimitiveType.Char) &&
+                            method.InstantiatedFrom.GenerationKind = GenerationKind.Generate;
-                                 !method.Parameters[1].Type.Desugar().IsPrimitiveType()))
+                            method.InstantiatedFrom.Namespace.GenerationKind = GenerationKind.Generate;
-                            {
+                        }
-                                method.GenerationKind = GenerationKind.Generate;
+                        else
-                                method.InstantiatedFrom.GenerationKind = GenerationKind.Generate;
+                        {
-                                method.InstantiatedFrom.Namespace.GenerationKind = GenerationKind.Generate;
+                            method.ExplicitlyIgnore();
-                            }
-                            else
-                            {
-                                method.ExplicitlyIgnore();
-                            }
                         }
                     }
                     break;
                 case "allocator":
                     foreach (var method in @class.Methods.Where(m => !m.IsConstructor || m.Parameters.Any()))
                         method.ExplicitlyIgnore();
-                    foreach (var specialization in @class.Specializations.Where(s => !s.Ignore))
+                    var allocator = @class.Specializations.First(s =>
-                    {
+                        s.Arguments[0].Type.Type.Desugar().IsPrimitiveType(PrimitiveType.Char));
-                        foreach (var method in specialization.Methods.Where(m => !m.IsDestructor && m.OriginalName != "c_str"))
+                    allocator.GenerationKind = GenerationKind.Generate;
-                            method.ExplicitlyIgnore();
+                    foreach (var method in allocator.Methods.Where(m => !m.IsDestructor && m.OriginalName != "c_str"))
-                        var ctor = specialization.Methods.Single(m => m.IsConstructor && !m.Parameters.Any());
+                        method.ExplicitlyIgnore();
-                        ctor.GenerationKind = GenerationKind.Generate;
+                    var ctor = allocator.Methods.Single(m => m.IsConstructor && !m.Parameters.Any());
-                        ctor.InstantiatedFrom.GenerationKind = GenerationKind.Generate;
+                    ctor.GenerationKind = GenerationKind.Generate;
-                        ctor.InstantiatedFrom.Namespace.GenerationKind = GenerationKind.Generate;
+                    ctor.InstantiatedFrom.GenerationKind = GenerationKind.Generate;
-                        foreach (var parameter in ctor.Parameters)
+                    ctor.InstantiatedFrom.Namespace.GenerationKind = GenerationKind.Generate;
-                            parameter.DefaultArgument = null;
+                    foreach (var parameter in ctor.Parameters)
-                    }
+                        parameter.DefaultArgument = null;
                     break;
                 case "char_traits":
                     foreach (var method in @class.Methods)
                         method.ExplicitlyIgnore();
-                    foreach (var specialization in @class.Specializations)
+                    var charTraits = @class.Specializations.First(s =>
-                    {
+                        s.Arguments[0].Type.Type.Desugar().IsPrimitiveType(PrimitiveType.Char));
-                        foreach (var method in specialization.Methods)
+                    foreach (var method in charTraits.Methods)
-                            method.ExplicitlyIgnore();
+                        method.ExplicitlyIgnore();
-                        if (specialization.Arguments[0].Type.Type.IsPrimitiveType(PrimitiveType.Char))
+                    charTraits.GenerationKind = GenerationKind.Generate;
-                        {
+                    charTraits.TemplatedDecl.TemplatedDecl.GenerationKind = GenerationKind.Generate;
-                            specialization.GenerationKind = GenerationKind.Generate;
-                            specialization.TemplatedDecl.TemplatedDecl.GenerationKind = GenerationKind.Generate;
-                        }
-                    }
                     break;
             }
             return true;

src/Generator/Passes/MarkSupportedClassTemplateSpecializationsPass.cs

@@ -1,63 +0,0 @@
-using System.Linq;
-using CppSharp.AST;
-using CppSharp.AST.Extensions;
-
-namespace CppSharp.Passes
-{
-    public class MarkSupportedSpecializationsPass : TranslationUnitPass
-    {
-        public override bool VisitClassDecl(Class @class)
-        {
-            if (!base.VisitClassDecl(@class) || !@class.IsDependent)
-                return false;
-
-            foreach (var specialization in @class.Specializations)
-            {
-                if (IsSupportedStdSpecialization(specialization))
-                {
-                    MarkForGeneration(specialization);
-                    @class.GenerationKind = GenerationKind.Generate;
-                }
-            }
-
-            return true;
-        }
-
-        private static bool IsSupportedStdSpecialization(ClassTemplateSpecialization specialization)
-        {
-            return IsSupportedStdType(specialization) &&
-                specialization.Arguments[0].Type.Type.IsPrimitiveType(PrimitiveType.Char);
-        }
-
-        private static bool IsSupportedStdType(Declaration declaration)
-        {
-            return declaration.Namespace != null &&
-                declaration.TranslationUnit.IsSystemHeader &&
-                IsNameSpaceStd(declaration.Namespace) &&
-                supportedStdTypes.Contains(declaration.OriginalName);
-        }
-
-        private static bool IsNameSpaceStd(DeclarationContext declarationContext)
-        {
-            if (declarationContext == null)
-                return false;
-            var @namespace = declarationContext as Namespace;
-            if (@namespace != null && @namespace.IsInline)
-                return IsNameSpaceStd(declarationContext.Namespace);
-            return declarationContext.OriginalName == "std";
-        }
-
-        private static void MarkForGeneration(ClassTemplateSpecialization specialization)
-        {
-            specialization.GenerationKind = GenerationKind.Generate;
-            Declaration declaration = specialization.TemplatedDecl.TemplatedDecl;
-            while (declaration != null)
-            {
-                declaration.GenerationKind = GenerationKind.Generate;
-                declaration = declaration.Namespace;
-            }
-        }
-
-        private static string[] supportedStdTypes = { "basic_string", "allocator", "char_traits" };
-    }
-}