Fix the generated C# when a dependent param has a default value

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

src/Generator/Passes/HandleDefaultParamValuesPass.cs

@@ -43,6 +43,15 @@ namespace CppSharp.Passes
             var overloadIndices = new List<int>(function.Parameters.Count);
             foreach (var parameter in function.Parameters.Where(p => p.DefaultArgument != null))
             {
+                Type type = parameter.Type.Desugar(resolveTemplateSubstitution: false);
+                type = (type.GetFinalPointee() ?? type).Desugar(
+                    resolveTemplateSubstitution: false);
+                if (type is TemplateParameterSubstitutionType)
+                {
+                    parameter.DefaultArgument = null;
+                    continue;
+                }
+
                 var result = parameter.DefaultArgument.String;
                 if (PrintExpression(function, parameter.Type,
                         parameter.OriginalDefaultArgument, ref result) == null)

src/Generator/Passes/SpecializationMethodsWithDependentPointersPass.cs

@@ -100,6 +100,14 @@ namespace CppSharp.Passes
             foreach (var parameter in extensionMethod.Parameters)
             {
                 var qualType = parameter.QualifiedType;
+                if (parameter.DefaultArgument != null)
+                {
+                    Type type = qualType.Type.Desugar(resolveTemplateSubstitution: false);
+                    type = (type.GetFinalPointee() ?? type).Desugar(
+                        resolveTemplateSubstitution: false);
+                    if (type is TemplateParameterSubstitutionType)
+                        parameter.DefaultArgument = null;
+                }
                 RemoveTemplateSubstitution(ref qualType);
                 parameter.QualifiedType = qualType;
             }

tests/CSharp/CSharpTemplates.h

@@ -42,6 +42,7 @@ public:
     T getDependent(const T& t);
     const T* propertyReturnDependentPointer();
     static T staticDependent(const T& t);
+    void hasDefaultDependentParam(T* ptr, const T& refT = T());
     template <typename AdditionalDependentType>
     void usesAdditionalDependentType(AdditionalDependentType additionalDependentType);
     static const int independentConst;
@@ -118,6 +119,11 @@ T IndependentFields<T>::staticDependent(const T& t)
     return t;
 }
 
+template <typename T>
+void IndependentFields<T>::hasDefaultDependentParam(T* ptr, const T& refT)
+{
+}
+
 template <typename T>
 int IndependentFields<T>::getIndependent()
 {