Move enums nested in classes to their parents

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

Author: ddobrev

src/AST/Declaration.cs

@@ -201,13 +201,15 @@ public virtual string LogicalOriginalName
         public string GetQualifiedName(Func<Declaration, string> getName,
             Func<Declaration, DeclarationContext> getNamespace)
         {
-            if (Namespace == null)
+            DeclarationContext declarationContext = getNamespace(this);
+
+            if (declarationContext == null)
                 return getName(this);
 
-            if (Namespace.IsRoot)
+            if (declarationContext.IsRoot)
                 return getName(this);
 
-            var namespaces = GatherNamespaces(getNamespace(this));
+            var namespaces = GatherNamespaces(declarationContext);
 
             var names = namespaces.Select(getName).ToList();
             names.Add(getName(this));

src/Generator/Driver.cs

@@ -235,6 +235,7 @@ public void SetupPasses(ILibrary library)
             TranslationUnitPasses.AddPass(new FindSymbolsPass());
             TranslationUnitPasses.AddPass(new CheckMacroPass());
             TranslationUnitPasses.AddPass(new CheckStaticClass());
+            TranslationUnitPasses.AddPass(new MoveNonScopedNestedEnumsToParentPass());
             TranslationUnitPasses.AddPass(new MoveOperatorToClassPass());
             TranslationUnitPasses.AddPass(new MoveFunctionToClassPass());
             TranslationUnitPasses.AddPass(new CheckAmbiguousFunctions());

src/Generator/Passes/MoveNonScopedNestedEnumsToParentPass.cs

@@ -0,0 +1,46 @@
+using CppSharp.AST;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace CppSharp.Passes
+{
+    /// <summary>
+    /// This pass moves enumerations nested in classes to the parents of those classes.
+    /// Historically enumerations have been placed in classes, in the overwhelming 
+    /// majority of cases, only because enumerations used to lack scoping before C++11.
+    /// </summary>
+    public class MoveNonScopedNestedEnumsToParentPass : TranslationUnitPass
+    {
+        public override bool VisitASTContext(ASTContext context)
+        {
+            bool result = base.VisitASTContext(context);
+
+            foreach (var movableEnum in movableEnums)
+            {
+                DeclarationContext declarationContext = movableEnum.Namespace;
+                declarationContext.Declarations.Remove(movableEnum);
+                declarationContext.Namespace.Declarations.Add(movableEnum);
+                movableEnum.Namespace = declarationContext.Namespace;
+            }
+
+            return result;
+        }
+
+        public override bool VisitEnumDecl(Enumeration @enum)
+        {
+            if (!base.VisitEnumDecl(@enum) ||
+                string.IsNullOrEmpty(@enum.OriginalName))
+                return false;
+
+            if (@enum.Namespace is Class &&
+                @enum.Access == AccessSpecifier.Public &&
+                @enum.Namespace.Namespace.Declarations.All(
+                    d => d.OriginalName != @enum.OriginalName))
+                movableEnums.Add(@enum);
+
+            return true;
+        }
+
+        private List<Enumeration> movableEnums = new List<Enumeration>();
+    }
+}

tests/CSharp/CSharp.Tests.cs

@@ -38,10 +38,10 @@ public void TestUncompilableCode()
         new HasCtorWithMappedToEnum<TestFlag>(TestFlag.Flag1).Dispose();
         using (var testOverrideFromSecondaryBase = new TestOverrideFromSecondaryBase())
         {
-            testOverrideFromSecondaryBase.function();
+            testOverrideFromSecondaryBase.Function();
             var ok = false;
-            testOverrideFromSecondaryBase.function(ref ok);
-            var property = testOverrideFromSecondaryBase.property;
+            testOverrideFromSecondaryBase.Function(ref ok);
+            var property = testOverrideFromSecondaryBase.Property;
             testOverrideFromSecondaryBase.VirtualMember();
         }
         using (var foo = new Foo())
@@ -670,12 +670,12 @@ public void TestEnumProperty()
     {
         using (var proprietor = new Proprietor())
         {
-            Assert.That(proprietor.Items, Is.EqualTo(Bar.Items.Item1));
-            proprietor.Items = Bar.Items.Item2;
-            Assert.That(proprietor.Items, Is.EqualTo(Bar.Items.Item2));
-            Assert.That(proprietor.ItemsByValue, Is.EqualTo(Bar.Items.Item1));
-            proprietor.ItemsByValue = Bar.Items.Item2;
-            Assert.That(proprietor.ItemsByValue, Is.EqualTo(Bar.Items.Item2));
+            Assert.That(proprietor.Items, Is.EqualTo(Items.Item1));
+            proprietor.Items = Items.Item2;
+            Assert.That(proprietor.Items, Is.EqualTo(Items.Item2));
+            Assert.That(proprietor.ItemsByValue, Is.EqualTo(Items.Item1));
+            proprietor.ItemsByValue = Items.Item2;
+            Assert.That(proprietor.ItemsByValue, Is.EqualTo(Items.Item2));
         }
     }
 

tests/Common/Common.Tests.cs

@@ -23,7 +23,7 @@ public unsafe void TestCodeGeneration()
         using (var foo = new Foo())
         {
             Bar bar = foo;
-            Assert.IsTrue(Bar.Item.Item1 == bar);
+            Assert.IsTrue(Item.Item1 == bar);
 
             using (var hasOverloadsWithDifferentPointerKindsToSameType =
                 new HasOverloadsWithDifferentPointerKindsToSameType())
@@ -101,7 +101,7 @@ public void TestHello()
 
         var bar = new Bar { A = 4, B = 7 };
         Assert.That(hello.AddBar(bar), Is.EqualTo(11));
-        Assert.That(bar.RetItem1(), Is.EqualTo(Bar.Item.Item1));
+        Assert.That(bar.RetItem1(), Is.EqualTo(Item.Item1));
 
         var retFoo = hello.RetFoo(7, 2.0f);
         Assert.That(retFoo.A, Is.EqualTo(7));
@@ -245,7 +245,7 @@ public void TestLeftShiftOperator()
     {
         var foo2 = new Foo2 { C = 2 };
         Foo2 result = foo2 << 3;
-        foo2.TestKeywordParam(IntPtr.Zero, Bar.Item.Item1, 1);
+        foo2.TestKeywordParam(IntPtr.Zero, Item.Item1, 1);
         Assert.That(result.C, Is.EqualTo(16));
     }
 
@@ -501,8 +501,8 @@ public void TestProperties()
             prop.VirtualSetterReturnsBoolean = 45;
             Assert.That(prop.VirtualSetterReturnsBoolean, Is.EqualTo(45));
 
-            Assert.That(prop.nestedEnum(), Is.EqualTo(5));
-            Assert.That(prop.nestedEnum(55), Is.EqualTo(55));
+            Assert.That(prop.NestedEnum(), Is.EqualTo(5));
+            Assert.That(prop.NestedEnum(55), Is.EqualTo(55));
         }
     }