From e57c4354263878a60124b7b609f37cae6bfe7812 Mon Sep 17 00:00:00 2001
From: triton <ripzonetriton@gmail.com>
Date: Sat, 18 May 2013 17:54:19 +0100
Subject: [PATCH] Fixed some incorrect behavior with nested types in the
 CheckAmbiguousOverloads pass by fixing GetFunctionOverloads to be dynamically
 dispatched instead of using some weird manual type checking.

---
 src/Bridge/Class.cs                                 |  2 +-
 src/Bridge/Namespace.cs                             |  2 +-
 src/Generator/AST/Utils.cs                          | 12 ------------
 .../Generators/CSharp/CSharpTextTemplate.cs         |  4 ++--
 src/Generator/Passes/CheckAmbiguousOverloads.cs     | 13 +++++--------
 5 files changed, 9 insertions(+), 24 deletions(-)

diff --git a/src/Bridge/Class.cs b/src/Bridge/Class.cs
index f89594a6..42540a13 100644
--- a/src/Bridge/Class.cs
+++ b/src/Bridge/Class.cs
@@ -185,7 +185,7 @@ namespace CppSharp
             return Variables.Where(v => v.OriginalName == originalName);
         }
 
-        public new IEnumerable<Function> GetFunctionOverloads(Function function)
+        public override IEnumerable<Function> GetFunctionOverloads(Function function)
         {
             return Methods.Where(method => method.Name == function.Name)
                 .Cast<Function>();
diff --git a/src/Bridge/Namespace.cs b/src/Bridge/Namespace.cs
index 58470734..0568e13f 100644
--- a/src/Bridge/Namespace.cs
+++ b/src/Bridge/Namespace.cs
@@ -202,7 +202,7 @@ namespace CppSharp
             return Enums.Find(e => e.ItemsByName.ContainsKey(name));
         }
 
-        public IList<Function> GetFunctionOverloads(Function function)
+        public virtual IEnumerable<Function> GetFunctionOverloads(Function function)
         {
             return Functions.Where(fn => fn.Name == function.Name)
                 .ToList();
diff --git a/src/Generator/AST/Utils.cs b/src/Generator/AST/Utils.cs
index 681f369c..ffa7c01f 100644
--- a/src/Generator/AST/Utils.cs
+++ b/src/Generator/AST/Utils.cs
@@ -4,18 +4,6 @@ namespace CppSharp.AST
 {
     public static class Utils
     {
-        public static IEnumerable<Function> GetFunctionOverloads(Function function,
-            Class @class = null)
-        {
-            var overloads = new List<Function>();
 
-            if (@class == null)
-            {
-                var @namespace = function.Namespace;
-                return @namespace.GetFunctionOverloads(function);
-            }
-
-            return @class.GetFunctionOverloads(function);
-        }
     }
 }
diff --git a/src/Generator/Generators/CSharp/CSharpTextTemplate.cs b/src/Generator/Generators/CSharp/CSharpTextTemplate.cs
index 0f1e67db..3050881c 100644
--- a/src/Generator/Generators/CSharp/CSharpTextTemplate.cs
+++ b/src/Generator/Generators/CSharp/CSharpTextTemplate.cs
@@ -134,7 +134,7 @@ namespace CppSharp.Generators.CSharp
         {
             if (Transform != null)
             {
-                Transform.GenerateStart(this);
+                //Transform.GenerateStart(this);
                 return;
             }
 
@@ -1448,7 +1448,7 @@ namespace CppSharp.Generators.CSharp
                     identifier = GetOperatorIdentifier(method.OperatorKind);
             }
 
-            var overloads = AST.Utils.GetFunctionOverloads(function, @class).ToList();
+            var overloads = function.Namespace.GetFunctionOverloads(function).ToList();
 
             var index = overloads.IndexOf(function);
             if (isNativeContext && index >= 0)
diff --git a/src/Generator/Passes/CheckAmbiguousOverloads.cs b/src/Generator/Passes/CheckAmbiguousOverloads.cs
index 9a8aa0f5..fa2a64af 100644
--- a/src/Generator/Passes/CheckAmbiguousOverloads.cs
+++ b/src/Generator/Passes/CheckAmbiguousOverloads.cs
@@ -1,7 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using CppSharp.Generators;
-using CppSharp.Types;
 
 namespace CppSharp.Passes
 {
@@ -56,7 +55,6 @@ namespace CppSharp.Passes
 
     public class CheckAmbiguousOverloads : TranslationUnitPass
     {
-        private Class currentClass;
         private readonly ISet<Function> visited;
 
         public CheckAmbiguousOverloads()
@@ -76,8 +74,6 @@ namespace CppSharp.Passes
         public override bool VisitClassDecl(Class @class)
         {
             visited.Clear();
-
-            currentClass = @class;
             return base.VisitClassDecl(@class);
         }
 
@@ -101,7 +97,7 @@ namespace CppSharp.Passes
             if (function.Ignore)
                 return false;
 
-            var overloads = AST.Utils.GetFunctionOverloads(function, currentClass);
+            var overloads = function.Namespace.GetFunctionOverloads(function);
             var signatures = overloads.Select(fn => new OverloadSignature(fn)).ToList();
 
             foreach (var sig1 in signatures)
@@ -116,12 +112,13 @@ namespace CppSharp.Passes
                     if (sig2.Function.Ignore)
                         continue;
 
-                    if (!OverloadSignature.IsAmbiguous(sig1, sig2, currentClass))
+                    var @class = function.Namespace as Class;
+                    if (!OverloadSignature.IsAmbiguous(sig1, sig2, @class))
                         continue;
 
                     Driver.Diagnostics.EmitWarning(DiagnosticId.AmbiguousOverload,
-                        "Overload {0}::{1} is ambiguous, renaming automatically",
-                        currentClass.OriginalName, sig1.Function.QualifiedOriginalName);
+                        "Overload {0} is ambiguous, renaming automatically",
+                        sig1.Function.QualifiedOriginalName);
 
                     RenameOverload(sig1.Function);
                     return false;