From d1a3141f5b17b871f407f96a84fdf61553854005 Mon Sep 17 00:00:00 2001
From: Elias Holzer <elias@vvvv.org>
Date: Wed, 7 May 2014 19:48:00 +0200
Subject: [PATCH] The unique name set by the CleanInvalidDeclNames pass will
 now truly be unique across translation units.

---
 src/Generator.Tests/Passes/TestPasses.cs      | 15 +++++++++++++
 .../Passes/CleanInvalidDeclNamesPass.cs       | 22 +++++++++++++------
 tests/Native/Enums.h                          |  9 ++++++++
 tests/Native/Passes.h                         |  8 +++++++
 4 files changed, 47 insertions(+), 7 deletions(-)
 create mode 100644 tests/Native/Enums.h

diff --git a/src/Generator.Tests/Passes/TestPasses.cs b/src/Generator.Tests/Passes/TestPasses.cs
index f03e25dc..a1c83436 100644
--- a/src/Generator.Tests/Passes/TestPasses.cs
+++ b/src/Generator.Tests/Passes/TestPasses.cs
@@ -1,4 +1,5 @@
 using System.Linq;
+using CppSharp;
 using CppSharp.Passes;
 using NUnit.Framework;
 
@@ -115,6 +116,20 @@ namespace CppSharp.Generator.Tests.Passes
             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()
         {
diff --git a/src/Generator/Passes/CleanInvalidDeclNamesPass.cs b/src/Generator/Passes/CleanInvalidDeclNamesPass.cs
index 8e1be9e0..113b871f 100644
--- a/src/Generator/Passes/CleanInvalidDeclNamesPass.cs
+++ b/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;
         }
diff --git a/tests/Native/Enums.h b/tests/Native/Enums.h
new file mode 100644
index 00000000..1043d58a
--- /dev/null
+++ b/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 {};
\ No newline at end of file
diff --git a/tests/Native/Passes.h b/tests/Native/Passes.h
index f2a44b04..8268c8b9 100644
--- a/tests/Native/Passes.h
+++ b/tests/Native/Passes.h
@@ -37,3 +37,11 @@ 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
+};
\ No newline at end of file