Changed how the type ignore check visitor return results so it does not conflict with the AST visiting patterns.

src/Generator/Passes/ResolveIncompleteDeclsPass.cs

@@ -168,13 +168,17 @@ namespace Cxxi.Passes
         bool IsTypeIgnored(Type type)
         {
             var checker = new TypeIgnoreChecker(typeMapDatabase);
-            return type.Visit(checker);
+            type.Visit(checker);
+
+            return checker.IsIgnored;
         }
 
         bool IsDeclIgnored(Declaration decl)
         {
             var checker = new TypeIgnoreChecker(typeMapDatabase);
-            return decl.Visit(checker);
+            decl.Visit(checker);
+
+            return checker.IsIgnored;
         }
 
         #endregion

src/Generator/Types/Types.cs

@@ -56,60 +56,61 @@ namespace Cxxi
     public class TypeIgnoreChecker : AstVisitor
     {
         ITypeMapDatabase TypeMapDatabase { get; set; }
+        public bool IsIgnored;
 
         public TypeIgnoreChecker(ITypeMapDatabase database)
         {
             TypeMapDatabase = database;
+            IsIgnored = false;
         }
 
-        public override bool VisitDeclaration(Declaration decl)
+        void Ignore()
         {
-            return decl.Ignore;
+            IsIgnored = true;
         }
 
-        public override bool VisitBuiltinType(BuiltinType builtin, TypeQualifiers quals)
+        public override bool VisitDeclaration(Declaration decl)
         {
-            return false;
+            if (decl.Ignore)
-        }
+                Ignore();
 
-        public override bool VisitFunctionType(FunctionType function, TypeQualifiers quals)
+            return true;
-        {
+        }
-            if (!function.ReturnType.Visit(this))
-                return false;
 
-            foreach (var arg in function.Arguments)
+        public override bool VisitClassDecl(Class @class)
         {
-                if (!arg.Type.Visit(this))
+            if (AlreadyVisited(@class))
                 return false;
-            }
 
+            VisitDeclaration(@class);
             return true;
         }
 
-        public override bool VisitFunctionDecl(Function function)
+        public override bool VisitTypedefType(TypedefType typedef,
+            TypeQualifiers quals)
         {
-            if (!function.ReturnType.Visit(this))
+            TypeMap typeMap = null;
-                return false;
+            if (TypeMapDatabase.FindTypeMap(typedef, out typeMap)
-
+                && typeMap.IsIgnored)
-            foreach (var param in function.Parameters)
             {
-                if (!param.Visit(this))
+                Ignore();
                 return false;
             }
 
-            return true;
+            return base.VisitTypedefType(typedef, quals);
         }
 
-        public override bool VisitTypedefType(TypedefType typedef,
+        public override bool VisitTypedefDecl(TypedefDecl typedef)
-            TypeQualifiers quals)
         {
-            var decl = typedef.Declaration;
-
             TypeMap typeMap = null;
-            if (TypeMapDatabase.FindTypeMap(decl, out typeMap))
+            if (TypeMapDatabase.FindTypeMap(typedef, out typeMap)
-                return typeMap.IsIgnored;
+                && typeMap.IsIgnored)
+            {
+                Ignore();
+                return false;
+            }
 
-            return base.VisitTypedefType(typedef, quals);
+            return base.VisitTypedefDecl(typedef);
         }
 
         public override bool VisitTemplateSpecializationType(
@@ -118,10 +119,11 @@ namespace Cxxi
             var decl = template.Template.TemplatedDecl;
 
             TypeMap typeMap = null;
-            if (TypeMapDatabase.FindTypeMap(decl, out typeMap))
+            if (TypeMapDatabase.FindTypeMap(decl, out typeMap)
+                && typeMap.IsIgnored)
             {
-                if (typeMap.IsIgnored)
+                Ignore();
-                    return true;
+                return false;
             }
 
             return base.VisitTemplateSpecializationType(template, quals);