Merge pull request #229 from azeno/unnamed-enum-support

Unnamed enum support

src/AST/Namespace.cs

@@ -180,6 +180,11 @@ namespace CppSharp.AST
             return @namespace.FindEnum(enumName, createDecl);
         }
 
+        public Enumeration FindEnum(IntPtr ptr)
+        {
+            return Enums.FirstOrDefault(f => f.OriginalPtr == ptr);
+        }
+
         public Function FindFunction(string name, bool createDecl = false)
         {
             if (string.IsNullOrEmpty(name)) 
@@ -348,7 +353,12 @@ namespace CppSharp.AST
 
         public Enumeration FindEnumWithItem(string name)
         {
-            return Enums.Find(e => e.ItemsByName.ContainsKey(name));
+            var result = Enums.Find(e => e.ItemsByName.ContainsKey(name));
+            if (result == null)
+                result = Namespaces.Select(ns => ns.FindEnumWithItem(name)).FirstOrDefault();
+            if (result == null)
+                result = Classes.Select(c => c.FindEnumWithItem(name)).FirstOrDefault();
+            return result;
         }
 
         public virtual IEnumerable<Function> FindOperator(CXXOperatorKind kind)

src/Core/Parser/ASTConverter.cs

@@ -1023,7 +1023,7 @@ namespace CppSharp
             {
                 var item = decl.getItems(i);
                 var _item = Visit(item) as AST.Enumeration.Item;
-                _enum.Items.Add(_item);
+                _enum.AddItem(_item);
             }
 
             return _enum;

src/CppParser/AST.cpp

@@ -270,6 +270,17 @@ Class* DeclarationContext::FindClass(const std::string& Name, bool IsComplete,
     return newClass;
 }
 
+Enumeration* DeclarationContext::FindEnum(void* OriginalPtr)
+{
+    auto foundEnum = std::find_if(Enums.begin(), Enums.end(),
+        [&](Enumeration* enumeration) { return enumeration->OriginalPtr == OriginalPtr; });
+
+    if (foundEnum != Enums.end())
+        return *foundEnum;
+
+    return nullptr;
+}
+
 Enumeration* DeclarationContext::FindEnum(const std::string& Name, bool Create)
 {
     auto entries = split<std::string>(Name, "::");
@@ -304,6 +315,27 @@ Enumeration* DeclarationContext::FindEnum(const std::string& Name, bool Create)
     return _namespace->FindEnum(enumName, Create);
 }
 
+Enumeration* DeclarationContext::FindEnumWithItem(const std::string& Name)
+{
+    auto foundEnumIt = std::find_if(Enums.begin(), Enums.end(), 
+        [&](Enumeration* _enum) { return _enum->FindItemByName(Name) != nullptr; });
+    if (foundEnumIt != Enums.end())
+        return *foundEnumIt;
+    for (auto it = Namespaces.begin(); it != Namespaces.end(); ++it)
+    {
+        auto foundEnum = (*it)->FindEnumWithItem(Name);
+        if (foundEnum != nullptr)
+            return foundEnum;
+    }
+    for (auto it = Classes.begin(); it != Classes.end(); ++it)
+    {
+        auto foundEnum = (*it)->FindEnumWithItem(Name);
+        if (foundEnum != nullptr)
+            return foundEnum;
+    }
+    return nullptr;
+}
+
 Function* DeclarationContext::FindFunction(const std::string& Name, bool Create)
 {
     auto foundFunction = std::find_if(Functions.begin(), Functions.end(),
@@ -384,6 +416,8 @@ DEF_VECTOR(Function, Parameter*, Parameters)
 Method::Method() : IsDefaultConstructor(false), IsCopyConstructor(false),
     IsMoveConstructor(false) { Kind = DeclarationKind::Method; }
 
+// Enumeration
+
 Enumeration::Enumeration() : Declaration(DeclarationKind::Enumeration),
     Modifiers((EnumModifiers)0), Type(0), BuiltinType(0) {}
 
@@ -396,6 +430,15 @@ Enumeration::Item::Item(const Item& rhs) : Declaration(rhs),
 
 DEF_STRING(Enumeration::Item, Expression)
 
+Enumeration::Item* Enumeration::FindItemByName(const std::string& Name)
+{
+    auto foundEnumItem = std::find_if(Items.begin(), Items.end(),
+        [&](Item _item) { return _item.Name == Name; });
+    if (foundEnumItem != Items.end())
+        return &*foundEnumItem;
+    return nullptr;
+}
+
 Variable::Variable() : Declaration(DeclarationKind::Variable) {}
 
 DEF_STRING(Variable, Mangled)

src/CppParser/AST.h

@@ -402,7 +402,9 @@ struct CS_API DeclarationContext : public Declaration
     CS_IGNORE FunctionTemplate* FindFunctionTemplate(const std::string& Name,
         const std::vector<TemplateParameter>& Params);
 
+    CS_IGNORE Enumeration* FindEnum(void* OriginalPtr);
     CS_IGNORE Enumeration* FindEnum(const std::string& Name, bool Create = false);
+    CS_IGNORE Enumeration* FindEnumWithItem(const std::string& Name);
 
     CS_IGNORE Function* FindFunction(const std::string& Name, bool Create = false);
 
@@ -560,6 +562,8 @@ struct CS_API Enumeration : public Declaration
     CppSharp::CppParser::AST::Type* Type;
     CppSharp::CppParser::AST::BuiltinType* BuiltinType;
     VECTOR(Item, Items)
+
+    Item* FindItemByName(const std::string& Name);
 };
 
 struct CS_API Variable : public Declaration

src/CppParser/Parser.cpp

@@ -1705,18 +1705,48 @@ Type* Parser::WalkType(clang::QualType QualType, clang::TypeLoc* TL,
 
 Enumeration* Parser::WalkEnum(clang::EnumDecl* ED)
 {
+    using namespace clang;
+
     auto NS = GetNamespace(ED);
     assert(NS && "Expected a valid namespace");
 
+    auto E = NS->FindEnum(ED->getCanonicalDecl());
+    if (E && !E->IsIncomplete)
+        return E;
+
+    if (!E)
+    {
         auto Name = GetTagDeclName(ED);
-    auto E = NS->FindEnum(Name, /*Create=*/false);
+        if (!Name.empty())
+            E = NS->FindEnum(Name, /*Create=*/false);
+        else
+        {
+            // Enum with no identifier - try to find existing enum through enum items
+            for (auto it = ED->enumerator_begin(); it != ED->enumerator_end(); ++it)
+            {
+                EnumConstantDecl* ECD = (*it);
+                auto EnumItemName = ECD->getNameAsString();
+                E = NS->FindEnumWithItem(EnumItemName);
+                break;
+            }
+        }
+    }
 
     if (E && !E->IsIncomplete)
         return E;
 
     if (!E)
     {
+        auto Name = GetTagDeclName(ED);
+        if (!Name.empty())
             E = NS->FindEnum(Name, /*Create=*/true);
+        else
+        {
+            E = new Enumeration();
+            E->Name = Name;
+            E->_Namespace = NS;
+            NS->Enums.push_back(E);
+        }
         HandleDeclaration(ED, E);
     }
 

src/Generator.Tests/AST/TestAST.cs

@@ -160,5 +160,13 @@ namespace CppSharp.Generator.Tests.AST
                 .First();
             Assert.IsTrue(plusOperator.Visit(testVisitor));
         }
+
+        [Test]
+        public void TestASTEnumItemByName()
+        {
+            var @enum = AstContext.FindEnum("TestASTEnumItemByName").Single();
+            Assert.NotNull(@enum);
+            Assert.IsTrue(@enum.ItemsByName.ContainsKey("TestItemByName"));
+        }
     }
 }

src/Generator.Tests/Passes/TestPasses.cs

@@ -1,4 +1,5 @@
 using System.Linq;
+using CppSharp;
 using CppSharp.Passes;
 using NUnit.Framework;
 
@@ -95,6 +96,40 @@ namespace CppSharp.Generator.Tests.Passes
             Assert.That(@enum.Items[0].Name, Is.EqualTo("_0"));
         }
 
+        [Test]
+        public void TestUnnamedEnumSupport()
+        {
+            passBuilder.AddPass(new CleanInvalidDeclNamesPass());
+            passBuilder.RunPasses(pass => pass.VisitLibrary(AstContext));
+
+            var unnamedEnum1 = AstContext.FindEnum("Unnamed_Enum_1").Single();
+            var unnamedEnum2 = AstContext.FindEnum("Unnamed_Enum_2").Single();
+            Assert.IsNotNull(unnamedEnum1);
+            Assert.IsNotNull(unnamedEnum2);
+
+            Assert.AreEqual(2, unnamedEnum1.Items.Count);
+            Assert.AreEqual(2, unnamedEnum2.Items.Count);
+
+            Assert.AreEqual(1, unnamedEnum1.Items[0].Value);
+            Assert.AreEqual(2, unnamedEnum1.Items[1].Value);
+            Assert.AreEqual(3, unnamedEnum2.Items[0].Value);
+            Assert.AreEqual(4, unnamedEnum2.Items[1].Value);
+        }
+
+        [Test]
+        public void TestUniqueNamesAcrossTranslationUnits()
+        {
+            passBuilder.AddPass(new CleanInvalidDeclNamesPass());
+            passBuilder.RunPasses(pass => pass.VisitLibrary(AstContext));
+
+            var unnamedEnum1 = AstContext.GetEnumWithMatchingItem("UnnamedEnumA1");
+            var unnamedEnum2 = AstContext.GetEnumWithMatchingItem("UnnamedEnumB1");
+            Assert.IsNotNull(unnamedEnum1);
+            Assert.IsNotNull(unnamedEnum2);
+
+            Assert.AreNotEqual(unnamedEnum1.Name, unnamedEnum2.Name);
+        }
+
         [Test]
         public void TestStructInheritance()
         {

src/Generator/Passes/CleanInvalidDeclNamesPass.cs

@@ -68,23 +68,30 @@ namespace CppSharp.Passes
                 }
             }
 
-            return base.VisitClassDecl(@class);
+            var currentUniqueName = this.uniqueName;
+            this.uniqueName = 0;
+            var ret = base.VisitClassDecl(@class);
+            this.uniqueName = currentUniqueName;
+
+            return ret;
         }
 
         public override bool VisitFunctionDecl(Function function)
         {
-            uniqueName = 0;
+            var currentUniqueName = this.uniqueName;
+            this.uniqueName = 0;
             var ret = base.VisitFunctionDecl(function);
-            uniqueName = 0;
+            this.uniqueName = currentUniqueName;
 
             return ret;
         }
 
         public override bool VisitEvent(Event @event)
         {
-            uniqueName = 0;
+            var currentUniqueName = this.uniqueName;
+            this.uniqueName = 0;
             var ret = base.VisitEvent(@event);
-            uniqueName = 0;
+            this.uniqueName = currentUniqueName;
 
             return ret;
         }
@@ -92,9 +99,10 @@ namespace CppSharp.Passes
         public override bool VisitFunctionType(FunctionType type,
             TypeQualifiers quals)
         {
-            uniqueName = 0;
+            var currentUniqueName = this.uniqueName;
+            this.uniqueName = 0;
             var ret = base.VisitFunctionType(type, quals);
-            uniqueName = 0;
+            this.uniqueName = currentUniqueName;
 
             return ret;
         }

src/Parser/Parser.cpp

@@ -1719,15 +1719,43 @@ CppSharp::AST::Enumeration^ Parser::WalkEnum(clang::EnumDecl* ED)
     auto NS = GetNamespace(ED);
     assert(NS && "Expected a valid namespace");
 
+    auto E = NS->FindEnum(System::IntPtr(ED->getCanonicalDecl()));
+    if (E && !E->IsIncomplete)
+        return E;
+
+    if (!E)
+    {
         auto Name = marshalString<E_UTF8>(GetTagDeclName(ED));
-    auto E = NS->FindEnum(Name, /*Create=*/false);
+        if (!System::String::IsNullOrEmpty(Name))
+            E = NS->FindEnum(Name, /*Create=*/false);
+        else
+        {
+            // Enum with no identifier - try to find existing enum through enum items
+            for (auto it = ED->enumerator_begin(); it != ED->enumerator_end(); ++it)
+            {
+                EnumConstantDecl* ECD = (*it);
+                auto EnumItemName = marshalString<E_UTF8>(ECD->getNameAsString());
+                E = NS->FindEnumWithItem(EnumItemName);
+                break;
+            }
+        }
+    }
 
     if (E && !E->IsIncomplete)
         return E;
 
     if (!E)
     {
+        auto Name = marshalString<E_UTF8>(GetTagDeclName(ED));
+        if (!System::String::IsNullOrEmpty(Name))
             E = NS->FindEnum(Name, /*Create=*/true);
+        else
+        {
+            E = gcnew CppSharp::AST::Enumeration();
+            E->Name = Name;
+            E->Namespace = NS;
+            NS->Enums->Add(E);
+        }
         HandleDeclaration(ED, E);
     }
 

tests/Native/AST.h

@@ -20,3 +20,6 @@ namespace Math
         return Complex(re + other.re, im + other.im);
     }
 }
+
+// Tests Enum.ItemByName
+enum TestASTEnumItemByName { TestItemByName };

tests/Native/Enums.h

@@ -0,0 +1,9 @@
+enum
+{
+    UnnamedEnumA1,
+    EnumUnnamedA2
+};
+
+// This line will make sure that a visitor won't enumerate all enums across
+// different translation units at once.
+struct TestUniqueNames {};

tests/Native/Passes.h

@@ -40,3 +40,15 @@ struct TestReadOnlyProperties
 // TestStructInheritance
 struct S1 { int F1, F2; };
 struct S2 : S1 { int F3; };
+
+// Tests unnamed enums
+enum { Unnamed_Enum_1_A = 1, Unnamed_Enum_1_B = 2 };
+enum { Unnamed_Enum_2_A = 3, Unnamed_Enum_2_B = 4 };
+
+// Tests unique name for unnamed enums across translation units
+#include "Enums.h"
+enum
+{
+    UnnamedEnumB1,
+    EnumUnnamedB2
+};