Fixed the filling of missing operators to account for operator overloads.

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

src/AST/Type.cs

@@ -641,6 +641,8 @@ namespace CppSharp.AST
         {
             var type = obj as InjectedClassNameType;
             if (type == null) return false;
+            if (TemplateSpecialization == null || type.TemplateSpecialization == null)
+                return TemplateSpecialization == type.TemplateSpecialization;
 
             return TemplateSpecialization.Equals(type.TemplateSpecialization)
                 && Class.Equals(type.Class);

src/Generator/Passes/CheckOperatorsOverloads.cs

@@ -73,21 +73,18 @@ namespace CppSharp.Passes
 
         static void HandleMissingOperatorOverloadPair(Class @class, CXXOperatorKind op1,
             CXXOperatorKind op2)
+        {
+            foreach (var op in @class.Operators.Where(
+                o => o.OperatorKind == op1 || o.OperatorKind == op2).ToList())
             {
                 int index;
-            var missingKind = CheckMissingOperatorOverloadPair(@class, out index, op1, op2);
+                var missingKind = CheckMissingOperatorOverloadPair(@class, out index, op1, op2,
+                                                                   op.Parameters.Last().Type);
 
                 if (missingKind == CXXOperatorKind.None)
                     return;
 
-            var existingKind = missingKind == op2 ? op1 : op2;
-
-            // FIXME: We have to check for missing overloads per overload instance.
-            foreach (var overload in @class.FindOperator(existingKind).ToList())
-            {
-                if (overload.Ignore) continue;
-
-                var @params = overload.Parameters;
+                if (op.Ignore) continue;
 
                 bool isBuiltin;
                 var method = new Method()
@@ -97,8 +94,8 @@ namespace CppSharp.Passes
                         IsSynthetized = true,
                         Kind = CXXMethodKind.Operator,
                         OperatorKind = missingKind,
-                    ReturnType = overload.ReturnType,
-                    Parameters = @params
+                        ReturnType = op.ReturnType,
+                        Parameters = op.Parameters
                     };
 
                 @class.Methods.Insert(index, method);
@@ -106,23 +103,25 @@ namespace CppSharp.Passes
         }
 
         static CXXOperatorKind CheckMissingOperatorOverloadPair(Class @class,
-            out int index, CXXOperatorKind op1, CXXOperatorKind op2)
+            out int index, CXXOperatorKind op1, CXXOperatorKind op2, Type type)
         {
-            var first = @class.FindOperator(op1).ToList();
-            var second = @class.FindOperator(op2).ToList();
+            var first = @class.Operators.FirstOrDefault(o => o.OperatorKind == op1 &&
+                                                             o.Parameters.Last().Type.Equals(type));
+            var second = @class.Operators.FirstOrDefault(o => o.OperatorKind == op2 &&
+                                                              o.Parameters.Last().Type.Equals(type));
 
-            var hasFirst = first.Count > 0;
-            var hasSecond = second.Count > 0;
+            var hasFirst = first != null;
+            var hasSecond = second != null;
 
-            if (hasFirst && !hasSecond)
+            if (hasFirst && (!hasSecond || second.Ignore))
             {
-                index = @class.Methods.IndexOf(first.Last());
+                index = @class.Methods.IndexOf(first);
                 return op2;
             }
 
-            if (hasSecond && !hasFirst)
+            if (hasSecond && (!hasFirst || first.Ignore))
             {
-                index = @class.Methods.IndexOf(second.First());
+                index = @class.Methods.IndexOf(second);
                 return op1;
             }