Minor formatting fixes.

src/Generator/Generators/CSharp/CSharpTextTemplate.cs

@@ -950,6 +950,7 @@ namespace CppSharp.Generators.CSharp
                     PopBlock(NewLineKind.BeforeNextBlock);
                     return;
                 }
+
                 NewLine();
                 WriteStartBraceIndent();
                 var method = function as Method;
@@ -965,7 +966,7 @@ namespace CppSharp.Generators.CSharp
                         TypePrinter.PushContext(CSharpTypePrinterContextKind.PrimitiveIndexer);
                     GenerateInternalFunctionCall(function);
                     if (isPrimitiveIndexer)
-                        TypePrinter.PopContext();   
+                        TypePrinter.PopContext();
                 }
             }
             else if (decl is Field)
@@ -1077,8 +1078,10 @@ namespace CppSharp.Generators.CSharp
             foreach (var prop in @class.Properties.Where(p => !p.Ignore))
             {
                 PushBlock(CSharpBlockKind.Property);
+
+                // If this is an indexer that returns an address use the real type
+                // because there is a setter anyway.
                 var type = prop.Type;
-                // if it's an indexer that returns an address use the real type because there is a setter anyway
                 if (prop.Parameters.Count > 0 && prop.Type.IsPointerToPrimitiveType())
                     type = ((PointerType) prop.Type).Pointee;
 
@@ -1086,19 +1089,23 @@ namespace CppSharp.Generators.CSharp
                 if (prop.ExplicitInterfaceImpl == null)
                 {
                     Write(Helpers.GetAccess(prop.Access));
+
                     if (prop.IsStatic)
                         Write("static ");
+
                     if (prop.IsOverride)
                         Write("override ");
                     else if (prop.IsPure && Driver.Options.GenerateAbstractImpls)
                         Write("abstract ");
                     else if (prop.IsVirtual)
                         Write("virtual ");
+
                     WriteLine("{0} {1}", type, GetPropertyName(prop));
                 }
                 else
                 {
-                    WriteLine("{0} {1}.{2}", type, prop.ExplicitInterfaceImpl.Name, GetPropertyName(prop));
+                    WriteLine("{0} {1}.{2}", type, prop.ExplicitInterfaceImpl.Name,
+                        GetPropertyName(prop));
                 }
                 WriteStartBraceIndent();
 
@@ -1108,7 +1115,8 @@ namespace CppSharp.Generators.CSharp
                         GeneratePropertyGetter(prop.Field, @class);
 
                     if (prop.HasSetter)
-                        GeneratePropertySetter(prop.Field.QualifiedType, prop.Field, @class);
+                        GeneratePropertySetter(prop.Field.QualifiedType, prop.Field,
+                            @class);
                 }
                 else
                 {
@@ -1116,7 +1124,8 @@ namespace CppSharp.Generators.CSharp
                         GeneratePropertyGetter(prop.GetMethod, @class);
 
                     if (prop.HasSetter)
-                        GeneratePropertySetter(prop.GetMethod.ReturnType, prop.SetMethod, @class);
+                        GeneratePropertySetter(prop.GetMethod.ReturnType, prop.SetMethod,
+                            @class);
                 }
 
                 WriteCloseBraceIndent();

src/Generator/Passes/GenerateAbstractImplementationsPass.cs

@@ -10,20 +10,24 @@ namespace CppSharp.Passes
 {
     /// <summary>
     /// This pass generates internal classes that implement abstract classes.
-    /// When the return type of a function is abstract, these internal classes provide - 
+    /// When the return type of a function is abstract, these internal
-    /// since the real type cannot be resolved while binding - an allocatable class that supports proper polymorphism.
+    /// classes provide since the real type cannot be resolved while binding
+    /// an allocatable class that supports proper polymorphism.
     /// </summary>
     public class GenerateAbstractImplementationsPass : TranslationUnitPass
     {
         /// <summary>
-        /// Collects all internal implementations in a unit to be added at the end because the unit cannot be changed while it's being iterated though.
+        /// Collects all internal implementations in a unit to be added at
+        /// the end because the unit cannot be changed while it's being
+        /// iterated though.
         /// </summary>
         private readonly List<Class> internalImpls = new List<Class>();
 
         public override bool VisitTranslationUnit(TranslationUnit unit)
         {
-            bool result = base.VisitTranslationUnit(unit);
+            var result = base.VisitTranslationUnit(unit);
             unit.Classes.AddRange(internalImpls);
+
             internalImpls.Clear();
             return result;
         }
@@ -44,6 +48,7 @@ namespace CppSharp.Passes
                     ctor.Access = AccessSpecifier.Protected;
                 internalImpls.Add(AddInternalImplementation(@class));
             }
+
             return base.VisitClassDecl(@class);
         }
 
@@ -57,6 +62,7 @@ namespace CppSharp.Passes
             {
                 var method = new Method(abstractMethod) { Namespace = internalImpl };
                 internalImpl.Methods.Add(method);
+
                 var @delegate = new TypedefDecl
                                 {
                                     Name = ASTHelpers.GetDelegateName(abstractMethod),
@@ -77,6 +83,7 @@ namespace CppSharp.Passes
                 method.IsOverride = true;
                 method.IsSynthetized = true;
             }
+
             return internalImpl;
         }
 
@@ -88,8 +95,10 @@ namespace CppSharp.Passes
                                     Access = @class.Access,
                                     Namespace = @class.Namespace
                                 };
+
             var @base = new BaseClassSpecifier { Type = new TagType(@class) };
             internalImpl.Bases.Add(@base);
+
             return internalImpl;
         }
 
@@ -98,7 +107,8 @@ namespace CppSharp.Passes
             var abstractMethods = GetAbstractMethods(@class);
             var overriddenMethods = GetOverriddenMethods(@class);
             var paramTypeCmp = new ParameterTypeComparer();
-            for (int i = abstractMethods.Count - 1; i >= 0; i--)
+
+            for (var i = abstractMethods.Count - 1; i >= 0; i--)
             {
                 var @abstract = abstractMethods[i];
                 if (overriddenMethods.Find(m => m.Name == @abstract.Name &&
@@ -109,6 +119,7 @@ namespace CppSharp.Passes
                     abstractMethods.RemoveAt(i);
                 }
             }
+
             return abstractMethods;
         }
 
@@ -117,6 +128,7 @@ namespace CppSharp.Passes
             var abstractMethods = @class.Methods.Where(m => m.IsPure).ToList();
             foreach (var @base in @class.Bases)
                 abstractMethods.AddRange(GetAbstractMethods(@base.Class));
+
             return abstractMethods;
         }
 
@@ -125,6 +137,7 @@ namespace CppSharp.Passes
             var abstractMethods = @class.Methods.Where(m => m.IsOverride).ToList();
             foreach (var @base in @class.Bases)
                 abstractMethods.AddRange(GetOverriddenMethods(@base.Class));
+
             return abstractMethods;
         }
 
@@ -144,57 +157,63 @@ namespace CppSharp.Passes
         private static void CreateVTableMS(Class @class,
             IList<Method> abstractMethods, Class internalImplementation)
         {
-            var vTables = GetVTables(@class);
+            var vtables = GetVTables(@class);
             for (int i = 0; i < abstractMethods.Count; i++)
             {
-                for (int j = 0; j < vTables.Count; j++)
+                for (int j = 0; j < vtables.Count; j++)
                 {
-                    var vTable = vTables[j];
+                    var vTable = vtables[j];
                     var k = vTable.Layout.Components.FindIndex(v => v.Method == abstractMethods[i]);
                     if (k >= 0)
                     {
                         var vTableComponent = vTable.Layout.Components[k];
                         vTableComponent.Declaration = internalImplementation.Methods[i];
                         vTable.Layout.Components[k] = vTableComponent;
-                        vTables[j] = vTable;
+                        vtables[j] = vTable;
                     }
                 }
             }
+
             internalImplementation.Layout.VFTables.Clear();
-            internalImplementation.Layout.VFTables.AddRange(vTables);
+            internalImplementation.Layout.VFTables.AddRange(vtables);
         }
 
         private static void CreateVTableItanium(Class @class,
             IList<Method> abstractMethods, Class internalImplementation)
         {
-            var vTableComponents = GetVTableComponents(@class);
+            var vtableComponents = GetVTableComponents(@class);
-            for (int i = 0; i < abstractMethods.Count; i++)
+            for (var i = 0; i < abstractMethods.Count; i++)
             {
-                var j = vTableComponents.FindIndex(v => v.Method == abstractMethods[i]);
+                var j = vtableComponents.FindIndex(v => v.Method == abstractMethods[i]);
-                var vTableComponent = vTableComponents[j];
+                var vtableComponent = vtableComponents[j];
-                vTableComponent.Declaration = internalImplementation.Methods[i];
+                vtableComponent.Declaration = internalImplementation.Methods[i];
-                vTableComponents[j] = vTableComponent;
+                vtableComponents[j] = vtableComponents[j];
             }
+
             internalImplementation.Layout.Layout.Components.Clear();
-            internalImplementation.Layout.Layout.Components.AddRange(vTableComponents);
+            internalImplementation.Layout.Layout.Components.AddRange(vtableComponents);
         }
 
         private static List<VTableComponent> GetVTableComponents(Class @class)
         {
-            var vTableComponents = new List<VTableComponent>(
+            var vtableComponents = new List<VTableComponent>(
                 @class.Layout.Layout.Components);
+
             foreach (var @base in @class.Bases)
-                vTableComponents.AddRange(GetVTableComponents(@base.Class));
+                vtableComponents.AddRange(GetVTableComponents(@base.Class));
-            return vTableComponents;
+
+            return vtableComponents;
         }
 
         private static List<VFTableInfo> GetVTables(Class @class)
         {
-            var vTables = new List<VFTableInfo>(
+            var vtables = new List<VFTableInfo>(
                 @class.Layout.VFTables);
+
             foreach (var @base in @class.Bases)
-                vTables.AddRange(GetVTables(@base.Class));
+                vtables.AddRange(GetVTables(@base.Class));
-            return vTables;
+
+            return vtables;
         }
     }
 }

tests/CSharpTemp/CSharpTemp.cs

@@ -34,15 +34,17 @@ namespace CppSharp.Tests
     {
         public override bool VisitFunctionDecl(Function function)
         {
-            if (!AlreadyVisited(function) && function.Name == "obsolete")
+            if (AlreadyVisited(function) || function.Name != "obsolete")
+                return false;
+
+            var attribute = new Attribute
             {
-                Attribute attribute = new Attribute
+                Type = typeof(ObsoleteAttribute),
-                {
+                Value = string.Format("\"{0} is obsolete.\"", function.Name)
-                    Type = typeof(ObsoleteAttribute),
+            };
-                    Value = string.Format("\"{0} is obsolete.\"", function.Name)
+
-                };
+            function.Attributes.Add(attribute);
-                function.Attributes.Add(attribute);
+
-            }
             return base.VisitFunctionDecl(function);
         }
     }