Update the existing passes to use the new pass interface.

src/Generator/Passes/CheckFlagEnumsPass.cs

@@ -9,19 +9,19 @@ namespace Cxxi.Passes
             // If the enumeration only has power of two values, assume it's
             // a flags enum.
 
-            bool isFlags = true;
+            var isFlags = true;
-            bool hasBigRange = false;
+            var hasBigRange = false;
 
             foreach (var item in @enum.Items)
             {
-                if (item.Name.Length >= 1 && Char.IsDigit(item.Name[0]))
+                var value = item.Value;
-                    item.Name = String.Format("_{0}", item.Name);
 
-                long value = item.Value;
                 if (value >= 4)
                     hasBigRange = true;
+
                 if (value <= 1 || value.IsPowerOfTwo())
                     continue;
+
                 isFlags = false;
             }
 
@@ -31,7 +31,7 @@ namespace Cxxi.Passes
             return isFlags && hasBigRange;
         }
 
-        public override bool ProcessEnum(Enumeration @enum)
+        public override bool VisitEnumDecl(Enumeration @enum)
         {
             if (IsFlagEnum(@enum))
             {
@@ -39,7 +39,7 @@ namespace Cxxi.Passes
                 return true;
             }
 
-            return false;
+            return base.VisitEnumDecl(@enum);
         }
     }
 

src/Generator/Passes/CleanInvalidDeclNamesPass.cs

@@ -14,31 +14,12 @@ namespace Cxxi.Passes
             typeRefs = new TypeRefsVisitor();
         }
 
-        public override bool ProcessUnit(TranslationUnit unit)
+        public override bool VisitTranslationUnit(TranslationUnit unit)
         {
-            if (unit.Ignore)
-                return false;
-
-            if (unit.IsSystemHeader)
-                return false;
-
             typeRefs = new TypeRefsVisitor();
-            ProcessNamespace(unit);
-
             unit.TypeReferences = typeRefs;
 
-            return true;
+            return base.VisitTranslationUnit(unit);
-        }
-
-        private void ProcessNamespace(Namespace @namespace)
-        {
-            ProcessEnums(@namespace.Enums);
-            ProcessFunctions(@namespace.Functions);
-            ProcessClasses(@namespace.Classes);
-            ProcessTypedefs(@namespace, @namespace.Typedefs);
-
-            foreach (var inner in @namespace.Namespaces)
-                ProcessNamespace(inner);
         }
 
         string CheckName(string name)
@@ -56,90 +37,29 @@ namespace Cxxi.Passes
             return name;
         }
 
-        public override bool ProcessDeclaration(Declaration decl)
+        public override bool VisitDeclaration(Declaration decl)
         {
             typeRefs.Process(decl);
             decl.Name = CheckName(decl.Name);
 
             StringHelpers.CleanupText(ref decl.DebugText);
-            return true;
+            return base.VisitDeclaration(decl);
-        }
-
-        private void ProcessDeclarations<T>(IEnumerable<T> decls)
-            where T : Declaration
-        {
-            foreach (T decl in decls)
-                ProcessDeclaration(decl);
-        }
-
-        private void ProcessClasses(List<Class> classes)
-        {
-            ProcessDeclarations(classes);
-
-            foreach (var @class in classes)
-            {
-                ProcessFields(@class.Fields);
-                ProcessMethods(@class.Methods);
-            }
-        }
-
-        private void ProcessFields(List<Field> fields)
-        {
-            ProcessDeclarations(fields);
-
-            foreach (var field in fields)
-                ProcessField(field);
         }
 
-        private void ProcessMethods(List<Method> methods)
+        public override bool VisitTypedefDecl(TypedefDecl typedef)
         {
-            ProcessDeclarations(methods);
+            var @class = typedef.Namespace.FindClass(typedef.Name);
 
-            foreach (var method in methods)
+            // Clang will walk the typedef'd tag decl and the typedef decl,
-                ProcessFunction(method);
+            // so we ignore the class and process just the typedef.
-        }
-
-        private void ProcessFunctions(List<Function> functions)
-        {
-            ProcessDeclarations(functions);
-
-            foreach (var function in functions)
-                ProcessFunction(function);
-        }
-
-        public override bool ProcessFunction(Function function)
-        {
-            foreach (var param in function.Parameters)
-                ProcessDeclaration(param);
-
-            return true;
-        }
 
-        private void ProcessTypedefs(Namespace @namespace, List<TypedefDecl> typedefs)
+            if (@class != null)
-        {
+                typedef.ExplicityIgnored = true;
-            ProcessDeclarations(typedefs);
-
-            foreach (var typedef in typedefs)
-            {
-                var @class = @namespace.FindClass(typedef.Name);
-
-                // Clang will walk the typedef'd tag decl and the typedef decl,
-                // so we ignore the class and process just the typedef.
 
-                if (@class != null)
+            if (typedef.Type == null)
-                    typedef.ExplicityIgnored = true;
+                typedef.ExplicityIgnored = true;
 
-                if (typedef.Type == null)
+            return base.VisitTypedefDecl(typedef);
-                    typedef.ExplicityIgnored = true;
-            }
-        }
-
-        public void ProcessEnums(List<Enumeration> enumerations)
-        {
-            ProcessDeclarations(enumerations);
-
-            foreach (var @enum in enumerations)
-                ProcessEnum(@enum);
         }
 
         private static void CheckEnumName(Enumeration @enum)
@@ -161,21 +81,16 @@ namespace Cxxi.Passes
             @enum.Name = prefix;
         }
 
-        public override bool ProcessEnum(Enumeration @enum)
+        public override bool VisitEnumDecl(Enumeration @enum)
         {
             CheckEnumName(@enum);
-            var result = base.ProcessEnum(@enum);
+            return base.VisitEnumDecl(@enum);
-
-            foreach (var item in @enum.Items)
-                ProcessEnumItem(item);
-
-            return result;
         }
 
-        public override bool ProcessEnumItem(Enumeration.Item item)
+        public override bool VisitEnumItem(Enumeration.Item item)
         {
             item.Name = CheckName(item.Name);
-            return true;
+            return base.VisitEnumItem(item);
         }
     }
 

src/Generator/Passes/DuplicatedNamesCheckerPass.cs

@@ -12,30 +12,18 @@ namespace Cxxi.Passes
             names = new Dictionary<string, Declaration>();
         }
 
-        public override bool ProcessClass(Class @class)
+        public override bool VisitClassDecl(Class @class)
         {
             if (@class.Ignore) return false;
 
             names.Clear();
-
+            return base.VisitClassDecl(@class);
-            foreach (var baseClass in @class.Bases)
-                if (baseClass.IsClass)
-                    ProcessClass(baseClass.Class);
-
-            CheckDuplicates(@class.Fields);
-            CheckDuplicates(@class.Methods);
-            CheckDuplicates(@class.Properties);
-
-            return true;
         }
 
-        void CheckDuplicates(IEnumerable<Declaration> decls)
+        public override bool VisitDeclaration(Declaration decl)
         {
-            foreach (var decl in decls)
+            CheckDuplicate(decl);
-            {
+            return base.VisitDeclaration(decl);
-                if (decl.Ignore) continue;
-                CheckDuplicate(decl);
-            }
         }
 
         void CheckDuplicate(Declaration decl)

src/Generator/Passes/FunctionToInstanceMethodPass.cs

@@ -11,7 +11,7 @@ namespace Cxxi.Passes
         /// <summary>
         /// Processes a function declaration.
         /// </summary>
-        public override bool ProcessFunction(Function function)
+        public override bool VisitFunctionDecl(Function function)
         {
             if (function.Ignore)
                 return false;

src/Generator/Passes/FunctionToStaticMethodPass.cs

@@ -12,7 +12,7 @@ namespace Cxxi.Passes
         /// <summary>
         /// Processes a function declaration.
         /// </summary>
-        public override bool ProcessFunction(Function function)
+        public override bool VisitFunctionDecl(Function function)
         {
             if (function.Ignore)
                 return false;
@@ -26,14 +26,14 @@ namespace Cxxi.Passes
                 return false;
 
             // Clean up the name of the function now that it will be a static method.
-            function.Name = function.Name.Substring(@class.Name.Length);
+            var name = function.Name.Substring(@class.Name.Length);
             function.ExplicityIgnored = true;
 
             // Create a new fake method so it acts as a static method.
             var method = new Method()
             {
                 Namespace = @class.Namespace,
-                Name = function.Name,
+                Name = name,
                 OriginalName = function.OriginalName,
                 Access = AccessSpecifier.Public,
                 Kind = CXXMethodKind.Normal,

src/Generator/Passes/RenamePass.cs

@@ -19,6 +19,57 @@ namespace Cxxi.Passes
         {
             Targets = targets;
         }
+
+        public abstract bool Rename(string name, out string newName);
+
+        public override bool VisitDeclaration(Declaration decl)
+        {
+            if (!Targets.HasFlag(RenameTargets.Any))
+                return true;
+
+            string newName;
+            if (Rename(decl.Name, out newName))
+            {
+                decl.Name = newName;
+                return true;
+            }
+
+            return true;
+        }
+
+        public override bool VisitEnumItem(Enumeration.Item item)
+        {
+            if (!Targets.HasFlag(RenameTargets.EnumItem))
+                return false;
+
+            string newName;
+            if (Rename(item.Name, out newName))
+            {
+                item.Name = newName;
+                return true;
+            }
+
+            return true;
+        }
+
+        public override bool VisitFieldDecl(Field field)
+        {
+            if (!Targets.HasFlag(RenameTargets.Field))
+                return false;
+
+            return base.VisitFieldDecl(field);
+        }
+
+        public override bool VisitMethodDecl(Method method)
+        {
+            if (!Targets.HasFlag(RenameTargets.Method))
+                return false;
+
+            if (method.Kind != CXXMethodKind.Normal)
+                return false;
+
+            return base.VisitMethodDecl(method);
+        }
     }
 
     [Flags]
@@ -54,52 +105,7 @@ namespace Cxxi.Passes
             Targets = targets;
         }
 
-        public override bool ProcessDeclaration(Declaration decl)
+        public override bool Rename(string name, out string newName)
-        {
-            if (!Targets.HasFlag(RenameTargets.Any))
-                return false;
-
-            string newName;
-            if (Rename(decl.Name, out newName))
-            {
-                decl.Name = newName;
-                return true;
-            }
-
-            return false;
-        }
-
-        public override bool ProcessEnumItem(Enumeration.Item item)
-        {
-            if (!Targets.HasFlag(RenameTargets.EnumItem))
-                return false;
-
-            string newName;
-            if (Rename(item.Name, out newName))
-            {
-                item.Name = newName;
-                return true;
-            }
-
-            return false;
-        }
-
-        public override bool ProcessField(Field field)
-        {
-            if (!Targets.HasFlag(RenameTargets.Field))
-                return false;
-
-            string newName;
-            if (Rename(field.Name, out newName))
-            {
-                field.Name = newName;
-                return true;
-            }
-
-            return false;
-        }
-
-        bool Rename(string name, out string newName)
         {
             var replace = Regex.Replace(name, Pattern, Replacement);
 
@@ -133,59 +139,23 @@ namespace Cxxi.Passes
             Pattern = pattern;
         }
 
-        private void Rename<T>(ref T decl) where T : Declaration
+        public override bool Rename(string name, out string newName)
         {
+            newName = null;
+
             switch (Pattern)
             {
-                case RenameCasePattern.LowerCamelCase:
+            case RenameCasePattern.LowerCamelCase:
-                    decl.Name = ConvertCaseString(decl.Name, RenameCasePattern.LowerCamelCase);
+                newName = ConvertCaseString(name, RenameCasePattern.LowerCamelCase);
-                    break;
+                return true;
-                case RenameCasePattern.UpperCamelCase:
+            case RenameCasePattern.UpperCamelCase:
-                    decl.Name = ConvertCaseString(decl.Name, RenameCasePattern.UpperCamelCase);
+                newName = ConvertCaseString(name, RenameCasePattern.UpperCamelCase);
-                    break;
+                return true;
             }
-        }
-
-        public override bool ProcessDeclaration(Declaration decl)
-        {
-            if (!Targets.HasFlag(RenameTargets.Any))
-                return false;
-
-            Rename(ref decl);
-            return true;
-        }
-
-        public override bool ProcessFunction(Function function)
-        {
-            if (!Targets.HasFlag(RenameTargets.Function))
-                return false;
-
-            Rename(ref function);
-            return true;
-        }
-
-        public override bool ProcessField(Field field)
-        {
-            if (!Targets.HasFlag(RenameTargets.Field))
-                return false;
-
-            Rename(ref field);
 
             return false;
         }
 
-        public override bool ProcessMethod(Method method)
-        {
-            if (!Targets.HasFlag(RenameTargets.Method))
-                return false;
-
-            if (method.Kind != CXXMethodKind.Normal)
-                return false;
-
-            Rename(ref method);
-            return true;
-        }
-
         /// <summary>
         /// Converts the phrase to specified convention.
         /// </summary>

src/Generator/Passes/ResolveIncompleteDeclsPass.cs

@@ -12,35 +12,26 @@ namespace Cxxi.Passes
             typeMapDatabase = database;
         }
 
-        public override bool ProcessClass(Class @class)
+        public override bool VisitClassDecl(Class @class)
         {
             if (@class.Ignore)
-                return true;
+                return false;
 
             if (!@class.IsIncomplete)
-                return true;
+                return false;
 
             if (@class.CompleteDeclaration != null)
-                return true;
+                return false;
 
             @class.CompleteDeclaration = Library.FindCompleteClass(@class.Name);
 
             if (@class.CompleteDeclaration == null)
                 Console.WriteLine("Unresolved declaration: {0}", @class.Name);
 
-            foreach (var field in @class.Fields)
+            return base.VisitClassDecl(@class);
-                ProcessField(field);
-
-            foreach (var method in @class.Methods)
-                ProcessMethod(method);
-
-            //foreach (var prop in @class.Properties)
-            //    ProcessProperty(prop);
-
-            return true;
         }
 
-        public override bool ProcessField(Field field)
+        public override bool VisitFieldDecl(Field field)
         {
             var type = field.Type;
 
@@ -56,7 +47,7 @@ namespace Cxxi.Passes
             return true;
         }
 
-        public override bool ProcessFunction(Function function)
+        public override bool VisitFunctionDecl(Function function)
         {
             var ret = function.ReturnType;
 
@@ -76,19 +67,12 @@ namespace Cxxi.Passes
                     Console.WriteLine("Function '{0}' was ignored due to {1} param",
                         function.Name, msg);
                 }
-
-                ProcessDeclaration(param);
             }
 
             return true;
         }
 
-        public override bool ProcessMethod(Method method)
+        public override bool VisitTypedefDecl(TypedefDecl typedef)
-        {
-            return ProcessFunction(method);
-        }
-
-        public override bool ProcessTypedef(TypedefDecl typedef)
         {
             string msg;
             if (HasInvalidType(typedef.Type, out msg))

src/Generator/Passes/SortDeclarationsPass.cs

@@ -18,7 +18,7 @@ namespace Cxxi.Passes
                 SortDeclarations(childNamespace);
         }
 
-        public override bool ProcessUnit(TranslationUnit unit)
+        public override bool VisitTranslationUnit(TranslationUnit unit)
         {
             SortDeclarations(unit);
             return true;