Fixed a crash when a constructor takes a template or specialisation.

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

Author: ddobrev

src/AST/ClassExtensions.cs

@@ -178,6 +178,28 @@ private static IEnumerable<Class> GetSpecializedClassesOf(this Class dependentCl
                 c => c.Name == dependentClass.Name)).ToList();
         }
 
+        public static Class GetInterface(this Class @class)
+        {
+            var specialization = @class as ClassTemplateSpecialization;
+            Class @interface = null;
+            if (specialization == null)
+            {
+                @interface = @class.Namespace.Classes.Find(
+                    c => c.OriginalClass == @class && c.IsInterface);
+            }
+            else
+            {
+                Class template = specialization.TemplatedDecl.TemplatedClass;
+                Class templatedInterface = @class.Namespace.Classes.Find(
+                   c => c.OriginalClass == template && c.IsInterface);
+                if (templatedInterface != null)
+                    @interface = templatedInterface.Specializations.FirstOrDefault(
+                        s => s.OriginalClass == specialization && s.IsInterface);
+            }
+
+            return @interface;
+        }
+
         public static bool HasDependentValueFieldInLayout(this Class @class)
         {
             if (@class.Fields.Any(f => IsValueDependent(f.Type)))

src/Generator/Generators/CSharp/CSharpSources.cs

@@ -2595,7 +2595,7 @@ private void GenerateOperator(Method method, QualifiedType returnType)
                     Class paramClass;
                     Class @interface = null;
                     if (paramType.TryGetClass(out paramClass))
-                        @interface = paramClass.Namespace.Classes.Find(c => c.OriginalClass == paramClass);
+                        @interface = paramClass.GetInterface();
 
                     var paramName = string.Format("{0}{1}",
                         method.Parameters[0].Type.IsPrimitiveTypeConvertibleToRef() ?

src/Generator/Passes/ParamTypeToInterfacePass.cs

@@ -59,22 +59,7 @@ private static void ChangeToInterfaceType(ref QualifiedType type)
             if (!finalType.TryGetClass(out @class))
                 return;
 
-            var specialization = @class as ClassTemplateSpecialization;
-            Class @interface = null;
-            if (specialization == null)
-            {
-                @interface = @class.Namespace.Classes.Find(
-                    c => c.OriginalClass == @class && c.IsInterface);
-            }
-            else
-            {
-                Class template = specialization.TemplatedDecl.TemplatedClass;
-                Class templatedInterface = @class.Namespace.Classes.Find(
-                   c => c.OriginalClass == template && c.IsInterface);
-                if (templatedInterface != null)
-                    @interface = templatedInterface.Specializations.FirstOrDefault(
-                        s => s.OriginalClass == specialization);
-            }
+            Class @interface = @class.GetInterface();
             if (@interface == null)
                 return;
 

tests/CSharp/CSharpTemplates.h

@@ -137,6 +137,7 @@ class DLL_API DependentValueFields : public Base<T>
         T field;
     };
     DependentValueFields();
+    DependentValueFields(IndependentFields<T> i);
     ~DependentValueFields();
     DependentValueFields& returnInjectedClass();
     DependentValueFields returnValue();
@@ -163,6 +164,11 @@ DependentValueFields<T>::~DependentValueFields()
 {
 }
 
+template <typename T>
+DependentValueFields<T>::DependentValueFields(IndependentFields<T> i)
+{
+}
+
 template <typename T>
 T DependentValueFields<T>::getDependentValue()
 {
@@ -404,6 +410,7 @@ class VirtualTemplate
 {
 public:
     VirtualTemplate();
+    VirtualTemplate(IndependentFields<int> i);
     VirtualTemplate(OptionalTemplateArgs<T> optionalTemplateArgs);
     virtual ~VirtualTemplate();
     virtual int function();
@@ -415,6 +422,11 @@ VirtualTemplate<T>::VirtualTemplate()
 {
 }
 
+template <typename T>
+VirtualTemplate<T>::VirtualTemplate(IndependentFields<int> i)
+{
+}
+
 template <typename T>
 VirtualTemplate<T>::VirtualTemplate(OptionalTemplateArgs<T> optionalTemplateArgs)
 {