Changed the comparer for parameter types to a singleton.

The class has no fields so the same value was allocated many times, it was wasteful.

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

src/AST/ClassExtensions.cs

@@ -62,7 +62,6 @@ namespace CppSharp.AST
         public static Method GetBaseMethod(this Class @class, Method @override,
             bool onlyPrimaryBase = false, bool getTopmost = false)
         {
-            var parameterTypeComparer = new ParameterTypeComparer();
             foreach (var @base in @class.Bases.Where(
                 b => b.IsClass && b.Class.OriginalClass != @class && (!onlyPrimaryBase || !b.Class.IsInterface)))
             {
@@ -75,7 +74,7 @@ namespace CppSharp.AST
                 }
 
                 baseMethod = (from method in @base.Class.Methods
-                    where @override.CanOverride(method, parameterTypeComparer)
+                    where @override.CanOverride(method)
                     select method).FirstOrDefault();
                 if (baseMethod != null)
                     return baseMethod;
@@ -100,7 +99,6 @@ namespace CppSharp.AST
         public static Property GetBaseProperty(this Class @class, Property @override,
             bool onlyFirstBase = false, bool getTopmost = false)
         {
-            var parameterTypeComparer = new ParameterTypeComparer();
             foreach (var @base in @class.Bases)
             {
                 if (!@base.IsClass || @base.Class.OriginalClass == @class ||
@@ -117,7 +115,8 @@ namespace CppSharp.AST
 
                 baseProperty = (from property in @base.Class.Properties
                     where property.OriginalName == @override.OriginalName &&
-                        property.Parameters.SequenceEqual(@override.Parameters, parameterTypeComparer)
+                        property.Parameters.SequenceEqual(@override.Parameters,
+                            ParameterTypeComparer.Instance)
                     select property).FirstOrDefault();
                 if (baseProperty != null)
                     return baseProperty;

src/AST/Function.cs

@@ -78,6 +78,12 @@ namespace CppSharp.AST
 
     public class ParameterTypeComparer : IEqualityComparer<Parameter>
     {
+        public static readonly ParameterTypeComparer Instance = new ParameterTypeComparer();
+
+        private ParameterTypeComparer()
+        {
+        }
+
         public bool Equals(Parameter x, Parameter y)
         {
             return x.QualifiedType == y.QualifiedType;

src/AST/FunctionExtensions.cs

@@ -73,13 +73,11 @@ namespace CppSharp.AST
             return @params;
         }
 
-        public static bool CanOverride(this Method @override, Method method,
+        public static bool CanOverride(this Method @override, Method method)
-            ParameterTypeComparer parameterTypeComparer = null)
         {
-            parameterTypeComparer = parameterTypeComparer ?? new ParameterTypeComparer();
             return (method.OriginalName == @override.OriginalName &&
                 method.ReturnType == @override.ReturnType &&
-                method.Parameters.SequenceEqual(@override.Parameters, parameterTypeComparer)) ||
+                method.Parameters.SequenceEqual(@override.Parameters, ParameterTypeComparer.Instance)) ||
                 (@override.IsDestructor && method.IsDestructor && method.IsVirtual);
         }
     }

src/Generator/Passes/CheckAmbiguousFunctions.cs

@@ -98,12 +98,12 @@ namespace CppSharp.Passes
 
         private static bool CheckConstnessForAmbiguity(Function function, Function overload)
         {
-            if (function is Method && overload is Method)
+            var method1 = function as Method;
+            var method2 = overload as Method;
+            if (method1 != null && method2 != null)
             {
-                var method1 = function as Method;
+                var sameParams = method1.Parameters.SequenceEqual(method2.Parameters,
-                var method2 = overload as Method;
+                    ParameterTypeComparer.Instance);
-
-                var sameParams = method1.Parameters.SequenceEqual(method2.Parameters, new ParameterTypeComparer());
 
                 if (method1.IsConst && !method2.IsConst && sameParams)
                 {

src/Generator/Passes/GenerateAbstractImplementationsPass.cs

@@ -93,14 +93,13 @@ namespace CppSharp.Passes
         {
             var abstractMethods = GetAbstractMethods(@class);
             var overriddenMethods = GetOverriddenMethods(@class);
-            var paramTypeCmp = new ParameterTypeComparer();
 
             for (var i = abstractMethods.Count - 1; i >= 0; i--)
             {
                 var @abstract = abstractMethods[i];
                 var @override = overriddenMethods.Find(m => m.Name == @abstract.Name && 
                     m.ReturnType == @abstract.ReturnType && 
-                    m.Parameters.SequenceEqual(@abstract.Parameters, paramTypeCmp));
+                    m.Parameters.SequenceEqual(@abstract.Parameters, ParameterTypeComparer.Instance));
                 if (@override != null)
                 {
                     if (@abstract.IsOverride)

src/Generator/Passes/GenerateAnonymousDelegatesPass.cs

@@ -114,12 +114,12 @@ namespace CppSharp.Passes
         /// <param name="typedefs">The typedef list to search.</param>
         /// <param name="functionType">The function to match.</param>
         /// <returns>The matching typedef, or null if not found.</returns>
-        private TypedefDecl FindMatchingTypedef(List<Typedef> typedefs, FunctionType functionType)
+        private static TypedefDecl FindMatchingTypedef(IEnumerable<Typedef> typedefs, FunctionType functionType)
         {
             return (from typedef in typedefs
                 let type = (FunctionType)typedef.Declaration.Type.GetPointee()
                 where type.ReturnType == functionType.ReturnType &&
-                      type.Parameters.SequenceEqual(functionType.Parameters, new ParameterTypeComparer())
+                      type.Parameters.SequenceEqual(functionType.Parameters, ParameterTypeComparer.Instance)
                 select typedef.Declaration).SingleOrDefault();
         }
     }

src/Generator/Passes/MultipleInheritancePass.cs

@@ -146,12 +146,11 @@ namespace CppSharp.Passes
 
         private static void ImplementInterfaceMethods(Class @class, Class @interface)
         {
-            var parameterTypeComparer = new ParameterTypeComparer();
             foreach (var method in @interface.Methods)
             {
                 if (@class.Methods.Any(m => m.OriginalName == method.OriginalName &&
                         m.Parameters.SequenceEqual(method.Parameters.Where(p => !p.Ignore),
-                            parameterTypeComparer)))
+                            ParameterTypeComparer.Instance)))
                     continue;
                 var impl = new Method(method)
                     {