Fixed the generated C# for public fields with type a dependent pointer.

ddobrev · ddobrev · commit 6dec97fd99e7 · 2017-12-24T18:46:46.000+02:00
Signed-off-by: Dimitar Dobrev &lt;dpldobrev@protonmail.com&gt;
diff --git a/src/Generator/Generators/CSharp/CSharpSources.cs b/src/Generator/Generators/CSharp/CSharpSources.cs
@@ -896,7 +896,8 @@ private void GenerateFieldSetter(Field field, Class @class, QualifiedType fieldT
             var marshal = new CSharpMarshalManagedToNativePrinter(ctx);
             ctx.Declaration = field;
 
-            var arrayType = field.Type.Desugar() as ArrayType;
+            Type type = field.Type.Desugar();
+            var arrayType = type as ArrayType;
 
             if (arrayType != null && @class.IsValueType)
             {
@@ -923,13 +924,20 @@ private void GenerateFieldSetter(Field field, Class @class, QualifiedType fieldT
 
             if (marshal.Context.Return.StringBuilder.Length > 0)
             {
-                WriteLine("{0} = {1}{2};", ctx.ReturnVarName,
-                    field.Type.IsPointer() && field.Type.GetFinalPointee().IsPrimitiveType() &&
-                    !CSharpTypePrinter.IsConstCharString(field.Type) ?
-                        string.Format("({0}) ", CSharpTypePrinter.IntPtrType) :
-                        string.Empty,
-                    marshal.Context.Return);
-
+                Write($"{ctx.ReturnVarName} = ");
+                if (type.IsPointer())
+                {
+                    Type pointee = type.GetFinalPointee();
+                    if (pointee.IsPrimitiveType() &&
+                        !CSharpTypePrinter.IsConstCharString(type))
+                    {
+                        Write($"({CSharpTypePrinter.IntPtrType}) ");
+                        var templateSubstitution = pointee.Desugar(false) as TemplateParameterSubstitutionType;
+                        if (templateSubstitution != null)
+                            Write($"(object) ");
+                    }
+                }
+                WriteLine($"{marshal.Context.Return};");
             }
 
             if ((arrayType != null && @class.IsValueType) || ctx.HasCodeBlock)
@@ -1191,21 +1199,26 @@ private void GenerateFieldGetter(Field field, Class @class, QualifiedType return
             if (ctx.HasCodeBlock)
                 PushIndent();
 
+            Write("return ");
+
             var @return = marshal.Context.Return.ToString();
             if (field.Type.IsPointer())
             {
-                var final = field.Type.GetFinalPointee().Desugar();
-                if (final.IsPrimitiveType() && !final.IsPrimitiveType(PrimitiveType.Void) &&
+                var final = field.Type.GetFinalPointee().Desugar(resolveTemplateSubstitution: false);
+                var templateSubstitution = final as TemplateParameterSubstitutionType;
+                if (templateSubstitution != null)
+                    Write($"({templateSubstitution.ReplacedParameter.Parameter.Name}) (object) ");
+                if ((final.IsPrimitiveType() && !final.IsPrimitiveType(PrimitiveType.Void) &&
                     (!final.IsPrimitiveType(PrimitiveType.Char) &&
                      !final.IsPrimitiveType(PrimitiveType.WideChar) ||
                      (!Context.Options.MarshalCharAsManagedChar &&
-                      !((PointerType) field.Type).QualifiedPointee.Qualifiers.IsConst)))
-                    @return = string.Format("({0}*) {1}", field.Type.GetPointee().Desugar(), @return);
-                if (!((PointerType) field.Type).QualifiedPointee.Qualifiers.IsConst &&
-                    final.IsPrimitiveType(PrimitiveType.WideChar))
-                    @return = string.Format("({0}*) {1}", field.Type.GetPointee().Desugar(), @return);
+                      !((PointerType) field.Type).QualifiedPointee.Qualifiers.IsConst)) &&
+                    templateSubstitution == null) ||
+                    (!((PointerType) field.Type).QualifiedPointee.Qualifiers.IsConst &&
+                     final.IsPrimitiveType(PrimitiveType.WideChar)))
+                    Write($"({field.Type.GetPointee().Desugar()}*) ");
             }
-            WriteLine("return {0};", @return);
+            WriteLine($"{@return};");
 
             if ((arrayType != null && @class.IsValueType) || ctx.HasCodeBlock)
                 WriteCloseBraceIndent();
diff --git a/src/Generator/Generators/CSharp/CSharpSourcesExtensions.cs b/src/Generator/Generators/CSharp/CSharpSourcesExtensions.cs
@@ -35,12 +35,12 @@ public static void GenerateField(this CSharpSources gen, Class @class,
         {
             if (@class.IsDependent)
             {
-                if (@class.Fields.Any(f => f.Type.Desugar() is TemplateParameterType))
+                if (@class.Fields.Any(f => f.Type.IsDependent))
                 {
                     foreach (var parameter in @class.TemplateParameters)
                         gen.WriteLine($"var __{parameter.Name} = typeof({parameter.Name});");
 
-                    foreach (var specialization in @class.Specializations.Where(s => !s.Ignore))
+                    foreach (var specialization in @class.Specializations.Where(s => s.IsGenerated))
                     {
                         WriteTemplateSpecializationCheck(gen, @class, specialization);
                         gen.WriteStartBraceIndent();
diff --git a/src/Generator/Passes/MultipleInheritancePass.cs b/src/Generator/Passes/MultipleInheritancePass.cs
@@ -135,7 +135,8 @@ where property.IsDeclared
                         Namespace = @interface,
                         Name = "Dispose",
                         ReturnType = new QualifiedType(new BuiltinType(PrimitiveType.Void)),
-                        SynthKind = FunctionSynthKind.InterfaceDispose
+                        SynthKind = FunctionSynthKind.InterfaceDispose,
+                        Mangled = string.Empty
                     };
 
                 @interface.Methods.Add(dispose);
diff --git a/tests/CSharp/CSharp.Tests.cs b/tests/CSharp/CSharp.Tests.cs
@@ -904,6 +904,14 @@ public void TestExtensionsOfSpecializationsAsSecondaryBases()
         }
     }
 
+    [Test]
+    public void TestFieldWithDependentPointerType()
+    {
+        using (var dependentPointerFields = new DependentPointerFields<float>())
+        {
+        }
+    }
+
     [Test]
     public void TestAbstractImplementatonsInPrimaryAndSecondaryBases()
     {
diff --git a/tests/CSharp/CSharpTemplates.h b/tests/CSharp/CSharpTemplates.h
@@ -211,10 +211,22 @@ class DLL_API DerivedFromSpecializationOfUnsupportedTemplate : public DependentV
 template <typename T>
 class DLL_API DependentPointerFields
 {
-private:
+public:
+    DependentPointerFields();
+    ~DependentPointerFields();
     T* field;
 };
 
+template <typename T>
+DependentPointerFields<T>::DependentPointerFields()
+{
+}
+
+template <typename T>
+DependentPointerFields<T>::~DependentPointerFields()
+{
+}
+
 template <typename K, typename V>
 class TwoTemplateArgs
 {
@@ -576,7 +588,8 @@ void forceUseSpecializations(IndependentFields<int> _1, IndependentFields<bool>
                              TemplateWithIndexer<int> _10, TemplateWithIndexer<T1> _11,
                              TemplateWithIndexer<T2*> _12, TemplateWithIndexer<UsedInTemplatedIndexer> _13,
                              TemplateDerivedFromRegularDynamic<RegularDynamic> _14,
-                             IndependentFields<OnlySpecialisedInTypeArg<double>> _15, std::string s);
+                             IndependentFields<OnlySpecialisedInTypeArg<double>> _15,
+                             DependentPointerFields<float> _16, std::string s);
 
 void hasIgnoredParam(DependentValueFields<IndependentFields<Ignored>> ii);
 
@@ -592,6 +605,7 @@ template class DLL_API IndependentFields<std::string>;
 template class DLL_API Base<int>;
 template class DLL_API DependentValueFields<int>;
 template class DLL_API DependentValueFields<float>;
+template class DLL_API DependentPointerFields<float>;
 template class DLL_API VirtualTemplate<int>;
 template class DLL_API VirtualTemplate<bool>;
 template class DLL_API HasDefaultTemplateArgument<int, int>;

Original file line number	Diff line number	Diff line change
`@@ -35,12 +35,12 @@ public static void GenerateField(this CSharpSources gen, Class @class,`
`35`	`35`	`{`
`36`	`36`	`if (@class.IsDependent)`
`37`	`37`	`{`
`38`		`- if (@class.Fields.Any(f => f.Type.Desugar() is TemplateParameterType))`
	`38`	`+ if (@class.Fields.Any(f => f.Type.IsDependent))`
`39`	`39`	`{`
`40`	`40`	`foreach (var parameter in @class.TemplateParameters)`
`41`	`41`	`gen.WriteLine($"var __{parameter.Name} = typeof({parameter.Name});");`
`42`	`42`
`43`		`- foreach (var specialization in @class.Specializations.Where(s => !s.Ignore))`
	`43`	`+ foreach (var specialization in @class.Specializations.Where(s => s.IsGenerated))`
`44`	`44`	`{`
`45`	`45`	`WriteTemplateSpecializationCheck(gen, @class, specialization);`
`46`	`46`	`gen.WriteStartBraceIndent();`
Original file line number	Diff line number	Diff line change
`@@ -904,6 +904,14 @@ public void TestExtensionsOfSpecializationsAsSecondaryBases()`
`904`	`904`	`}`
`905`	`905`	`}`
`906`	`906`
	`907`	`+ [Test]`
	`908`	`+ public void TestFieldWithDependentPointerType()`
	`909`	`+ {`
	`910`	`+ using (var dependentPointerFields = new DependentPointerFields<float>())`
	`911`	`+ {`
	`912`	`+ }`
	`913`	`+ }`
	`914`	`+`
`907`	`915`	`[Test]`
`908`	`916`	`public void TestAbstractImplementatonsInPrimaryAndSecondaryBases()`
`909`	`917`	`{`