Generate valid C# for template indexers taking const char*

ddobrev · ddobrev · commit 9bc39c44abd0 · 2019-04-13T06:18:19.000+03:00
Signed-off-by: Dimitar Dobrev &lt;dpldobrev@protonmail.com&gt;
diff --git a/src/AST/Type.cs b/src/AST/Type.cs
@@ -866,10 +866,12 @@ public override bool Equals(object obj)
             var type = obj as TemplateParameterSubstitutionType;
             if (type == null) return false;
 
-            return Replacement.Equals(type.Replacement);
+            return ReplacedParameter.Equals(type.ReplacedParameter) &&
+                Replacement.Equals(type.Replacement);
         }
 
-        public override int GetHashCode() => Replacement.GetHashCode();
+        public override int GetHashCode() =>
+            ReplacedParameter.GetHashCode() ^ Replacement.GetHashCode();
     }
 
     /// <summary>
diff --git a/src/Generator/Generators/CSharp/CSharpMarshal.cs b/src/Generator/Generators/CSharp/CSharpMarshal.cs
@@ -312,7 +312,8 @@ public override bool VisitTemplateParameterSubstitutionType(TemplateParameterSub
             Type finalType = (returnType.GetFinalPointee() ?? returnType).Desugar();
             if (finalType.IsDependent)
                 Context.Return.Write($"({param.ReplacedParameter.Parameter.Name}) (object) ");
-            if (param.Replacement.Type.Desugar().IsPointerToPrimitiveType())
+            Type replacement = param.Replacement.Type.Desugar();
+            if (replacement.IsPointerToPrimitiveType() && !replacement.IsConstCharString())
                 Context.Return.Write($"({typePrinter.IntPtrType}) ");
             return base.VisitTemplateParameterSubstitutionType(param, quals);
         }
@@ -623,9 +624,10 @@ public override bool VisitTypedefType(TypedefType typedef, TypeQualifiers quals)
         public override bool VisitTemplateParameterSubstitutionType(TemplateParameterSubstitutionType param, TypeQualifiers quals)
         {
             var replacement = param.Replacement.Type.Desugar();
-            if (replacement.IsPrimitiveType() ||
-                replacement.IsPointerToPrimitiveType() ||
-                replacement.IsEnum())
+            if ((replacement.IsPrimitiveType() ||
+                 replacement.IsPointerToPrimitiveType() ||
+                 replacement.IsEnum()) &&
+                !replacement.IsConstCharString())
             {
                 Context.Return.Write($"({replacement}) ");
                 if (replacement.IsPointerToPrimitiveType())
diff --git a/src/Generator/Generators/CSharp/CSharpSources.cs b/src/Generator/Generators/CSharp/CSharpSources.cs
@@ -1049,15 +1049,15 @@ private void GenerateIndexerSetter(Function function)
             if (type.IsPrimitiveType())
             {
                 WriteLine($@"*{@internal}.{internalFunction}({
-                    GetInstanceParam(function)}, {(paramMarshal.Context == null ?
-                    paramMarshal.Name : paramMarshal.Context.Return)}) = {marshal.Context.Return};");
+                    GetInstanceParam(function)}, {paramMarshal.Context.ArgumentPrefix}{
+                    paramMarshal.Name}) = {marshal.Context.Return};");
             }
             else
             {
                 var typeInternal = TypePrinter.PrintNative(type);
                 WriteLine($@"*({typeInternal}*) {@internal}.{internalFunction}({
-                    GetInstanceParam(function)}, {(paramMarshal.Context == null ?
-                    paramMarshal.Name : paramMarshal.Context.Return)}) = {marshal.Context.Return};");
+                    GetInstanceParam(function)}, {paramMarshal.Context.ArgumentPrefix}{
+                    paramMarshal.Name}) = {marshal.Context.Return};");
             }
         }
 
diff --git a/src/Generator/Generators/CSharp/CSharpSourcesExtensions.cs b/src/Generator/Generators/CSharp/CSharpSourcesExtensions.cs
@@ -139,7 +139,7 @@ private static void WriteTemplateSpecializationCheck(CSharpSources gen,
                 i =>
                 {
                     CppSharp.AST.Type type = specialization.Arguments[i].Type.Type;
-                    return type.IsPointerToPrimitiveType() ?
+                    return type.IsPointerToPrimitiveType() && !type.IsConstCharString() ?
                         $"__{@class.TemplateParameters[i].Name}.FullName == \"System.IntPtr\"" :
                         $"__{@class.TemplateParameters[i].Name}.IsAssignableFrom(typeof({type}))";
                 })));
diff --git a/src/Generator/Types/Std/Stdlib.cs b/src/Generator/Types/Std/Stdlib.cs
@@ -167,24 +167,31 @@ public override Type CSharpSignatureType(TypePrinterContext ctx)
 
         public override void CSharpMarshalToNative(CSharpMarshalContext ctx)
         {
+            string param = ctx.Parameter.Name;
             if (ctx.Parameter.Usage == ParameterUsage.Unknown &&
                 !ctx.Parameter.Type.IsReference() &&
+                !(ctx.Parameter.Type is TemplateParameterSubstitutionType) &&
                 ctx.MarshalKind != MarshalKind.NativeField &&
                 ctx.MarshalKind != MarshalKind.VTableReturnValue &&
                 ctx.MarshalKind != MarshalKind.Variable)
             {
-                ctx.Return.Write(ctx.Parameter.Name);
+                ctx.Return.Write(param);
                 return;
             }
+
+            var substitution = Type as TemplateParameterSubstitutionType;
+            if (substitution != null)
+                param = $"({substitution.Replacement}) (object) {param}";
+
             if (Equals(Context.Options.Encoding, Encoding.ASCII))
             {
-                ctx.Return.Write($"Marshal.StringToHGlobalAnsi({ctx.Parameter.Name})");
+                ctx.Return.Write($"Marshal.StringToHGlobalAnsi({param})");
                 return;
             }
             if (Equals(Context.Options.Encoding, Encoding.Unicode) ||
                 Equals(Context.Options.Encoding, Encoding.BigEndianUnicode))
             {
-                ctx.Return.Write($"Marshal.StringToHGlobalUni({ctx.Parameter.Name})");
+                ctx.Return.Write($"Marshal.StringToHGlobalUni({param})");
                 return;
             }
             throw new System.NotSupportedException(
@@ -200,7 +207,7 @@ public override void CSharpMarshalToManaged(CSharpMarshalContext ctx)
                 return;
             }
 
-            Type type = ctx.ReturnType.Type.Desugar();
+            Type type = Type.Desugar();
             Type pointee = type.GetPointee().Desugar();
             var isChar = type.IsPointerToPrimitiveType(PrimitiveType.Char) ||
                 (pointee.IsPointerToPrimitiveType(PrimitiveType.Char) &&
@@ -211,27 +218,31 @@ public override void CSharpMarshalToManaged(CSharpMarshalContext ctx)
             if (Equals(encoding, Encoding.ASCII))
                 encoding = Context.Options.Encoding;
 
+            string returnVarName = ctx.Function != null &&
+                ctx.Function.ReturnType.Type.Desugar().IsAddress() ?
+                $"(global::System.IntPtr) {ctx.ReturnVarName}" : ctx.ReturnVarName;
+
             if (Equals(encoding, Encoding.ASCII))
             {
-                ctx.Return.Write($"Marshal.PtrToStringAnsi({ctx.ReturnVarName})");
+                ctx.Return.Write($"Marshal.PtrToStringAnsi({returnVarName})");
                 return;
             }
             if (Equals(encoding, Encoding.UTF8))
             {
-                ctx.Return.Write($"Marshal.PtrToStringUTF8({ctx.ReturnVarName})");
+                ctx.Return.Write($"Marshal.PtrToStringUTF8({returnVarName})");
                 return;
             }
 
             // If we reach this, we know the string is Unicode.
             if (isChar || ctx.Context.TargetInfo.WCharWidth == 16)
             {
-                ctx.Return.Write($"Marshal.PtrToStringUni({ctx.ReturnVarName})");
+                ctx.Return.Write($"Marshal.PtrToStringUni({returnVarName})");
                 return;
             }
             // If we reach this, we should have an UTF-32 wide string.
             const string encodingName = "System.Text.Encoding.UTF32";
             ctx.Return.Write($@"CppSharp.Runtime.Helpers.MarshalEncodedString({
-                ctx.ReturnVarName}, {encodingName})");
+                returnVarName}, {encodingName})");
         }
     }
 
diff --git a/tests/CSharp/CSharpTemplates.h b/tests/CSharp/CSharpTemplates.h
@@ -715,7 +715,8 @@ void forceUseSpecializations(IndependentFields<int> _1, IndependentFields<bool>
                              TemplateDerivedFromRegularDynamic<RegularDynamic> _14,
                              IndependentFields<OnlySpecialisedInTypeArg<double>> _15,
                              DependentPointerFields<float> _16, IndependentFields<const T1&> _17,
-                             TemplateWithIndexer<T2*> _18, IndependentFields<int(*)(int)>, std::string s);
+                             TemplateWithIndexer<T2*> _18, IndependentFields<int(*)(int)> _19,
+                             TemplateWithIndexer<const char*> _20, std::string s);
 
 void hasIgnoredParam(DependentValueFields<IndependentFields<Ignored>> ii);
 
@@ -750,6 +751,7 @@ template class DLL_API TemplateWithIndexer<UsedInTemplatedIndexer>;
 template class DLL_API TemplateWithIndexer<T1>;
 template class DLL_API TemplateWithIndexer<T2*>;
 template class DLL_API TemplateWithIndexer<float>;
+template class DLL_API TemplateWithIndexer<const char*>;
 template class DLL_API TemplateDerivedFromRegularDynamic<RegularDynamic>;
 template class DLL_API HasCtorWithMappedToEnum<TestFlag>;
 

Original file line number	Diff line number	Diff line change
`@@ -866,10 +866,12 @@ public override bool Equals(object obj)`
`866`	`866`	`var type = obj as TemplateParameterSubstitutionType;`
`867`	`867`	`if (type == null) return false;`
`868`	`868`
`869`		`- return Replacement.Equals(type.Replacement);`
	`869`	`+ return ReplacedParameter.Equals(type.ReplacedParameter) &&`
	`870`	`+ Replacement.Equals(type.Replacement);`
`870`	`871`	`}`
`871`	`872`
`872`		`- public override int GetHashCode() => Replacement.GetHashCode();`
	`873`	`+ public override int GetHashCode() =>`
	`874`	`+ ReplacedParameter.GetHashCode() ^ Replacement.GetHashCode();`
`873`	`875`	`}`
`874`	`876`
`875`	`877`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -1049,15 +1049,15 @@ private void GenerateIndexerSetter(Function function)`
`1049`	`1049`	`if (type.IsPrimitiveType())`
`1050`	`1050`	`{`
`1051`	`1051`	`WriteLine($@"*{@internal}.{internalFunction}({`
`1052`		`- GetInstanceParam(function)}, {(paramMarshal.Context == null ?`
`1053`		`- paramMarshal.Name : paramMarshal.Context.Return)}) = {marshal.Context.Return};");`
	`1052`	`+ GetInstanceParam(function)}, {paramMarshal.Context.ArgumentPrefix}{`
	`1053`	`+ paramMarshal.Name}) = {marshal.Context.Return};");`
`1054`	`1054`	`}`
`1055`	`1055`	`else`
`1056`	`1056`	`{`
`1057`	`1057`	`var typeInternal = TypePrinter.PrintNative(type);`
`1058`	`1058`	`WriteLine($@"({typeInternal}) {@internal}.{internalFunction}({`
`1059`		`- GetInstanceParam(function)}, {(paramMarshal.Context == null ?`
`1060`		`- paramMarshal.Name : paramMarshal.Context.Return)}) = {marshal.Context.Return};");`
	`1059`	`+ GetInstanceParam(function)}, {paramMarshal.Context.ArgumentPrefix}{`
	`1060`	`+ paramMarshal.Name}) = {marshal.Context.Return};");`
`1061`	`1061`	`}`
`1062`	`1062`	`}`
`1063`	`1063`
Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,7 @@ private static void WriteTemplateSpecializationCheck(CSharpSources gen,`
`139`	`139`	`i =>`
`140`	`140`	`{`
`141`	`141`	`CppSharp.AST.Type type = specialization.Arguments[i].Type.Type;`
`142`		`- return type.IsPointerToPrimitiveType() ?`
	`142`	`+ return type.IsPointerToPrimitiveType() && !type.IsConstCharString() ?`
`143`	`143`	`$"__{@class.TemplateParameters[i].Name}.FullName == \"System.IntPtr\"" :`
`144`	`144`	`$"__{@class.TemplateParameters[i].Name}.IsAssignableFrom(typeof({type}))";`
`145`	`145`	`})));`
Original file line number	Diff line number	Diff line change
`@@ -167,24 +167,31 @@ public override Type CSharpSignatureType(TypePrinterContext ctx)`
`167`	`167`
`168`	`168`	`public override void CSharpMarshalToNative(CSharpMarshalContext ctx)`
`169`	`169`	`{`
	`170`	`+ string param = ctx.Parameter.Name;`
`170`	`171`	`if (ctx.Parameter.Usage == ParameterUsage.Unknown &&`
`171`	`172`	`!ctx.Parameter.Type.IsReference() &&`
	`173`	`+ !(ctx.Parameter.Type is TemplateParameterSubstitutionType) &&`
`172`	`174`	`ctx.MarshalKind != MarshalKind.NativeField &&`
`173`	`175`	`ctx.MarshalKind != MarshalKind.VTableReturnValue &&`
`174`	`176`	`ctx.MarshalKind != MarshalKind.Variable)`
`175`	`177`	`{`
`176`		`- ctx.Return.Write(ctx.Parameter.Name);`
	`178`	`+ ctx.Return.Write(param);`
`177`	`179`	`return;`
`178`	`180`	`}`
	`181`	`+`
	`182`	`+ var substitution = Type as TemplateParameterSubstitutionType;`
	`183`	`+ if (substitution != null)`
	`184`	`+ param = $"({substitution.Replacement}) (object) {param}";`
	`185`	`+`
`179`	`186`	`if (Equals(Context.Options.Encoding, Encoding.ASCII))`
`180`	`187`	`{`
`181`		`- ctx.Return.Write($"Marshal.StringToHGlobalAnsi({ctx.Parameter.Name})");`
	`188`	`+ ctx.Return.Write($"Marshal.StringToHGlobalAnsi({param})");`
`182`	`189`	`return;`
`183`	`190`	`}`
`184`	`191`	`if (Equals(Context.Options.Encoding, Encoding.Unicode) \|\|`
`185`	`192`	`Equals(Context.Options.Encoding, Encoding.BigEndianUnicode))`
`186`	`193`	`{`
`187`		`- ctx.Return.Write($"Marshal.StringToHGlobalUni({ctx.Parameter.Name})");`
	`194`	`+ ctx.Return.Write($"Marshal.StringToHGlobalUni({param})");`
`188`	`195`	`return;`
`189`	`196`	`}`
`190`	`197`	`throw new System.NotSupportedException(`
`@@ -200,7 +207,7 @@ public override void CSharpMarshalToManaged(CSharpMarshalContext ctx)`
`200`	`207`	`return;`
`201`	`208`	`}`
`202`	`209`
`203`		`- Type type = ctx.ReturnType.Type.Desugar();`
	`210`	`+ Type type = Type.Desugar();`
`204`	`211`	`Type pointee = type.GetPointee().Desugar();`
`205`	`212`	`var isChar = type.IsPointerToPrimitiveType(PrimitiveType.Char) \|\|`
`206`	`213`	`(pointee.IsPointerToPrimitiveType(PrimitiveType.Char) &&`
`@@ -211,27 +218,31 @@ public override void CSharpMarshalToManaged(CSharpMarshalContext ctx)`
`211`	`218`	`if (Equals(encoding, Encoding.ASCII))`
`212`	`219`	`encoding = Context.Options.Encoding;`
`213`	`220`
	`221`	`+ string returnVarName = ctx.Function != null &&`
	`222`	`+ ctx.Function.ReturnType.Type.Desugar().IsAddress() ?`
	`223`	`+ $"(global::System.IntPtr) {ctx.ReturnVarName}" : ctx.ReturnVarName;`
	`224`	`+`
`214`	`225`	`if (Equals(encoding, Encoding.ASCII))`
`215`	`226`	`{`
`216`		`- ctx.Return.Write($"Marshal.PtrToStringAnsi({ctx.ReturnVarName})");`
	`227`	`+ ctx.Return.Write($"Marshal.PtrToStringAnsi({returnVarName})");`
`217`	`228`	`return;`
`218`	`229`	`}`
`219`	`230`	`if (Equals(encoding, Encoding.UTF8))`
`220`	`231`	`{`
`221`		`- ctx.Return.Write($"Marshal.PtrToStringUTF8({ctx.ReturnVarName})");`
	`232`	`+ ctx.Return.Write($"Marshal.PtrToStringUTF8({returnVarName})");`
`222`	`233`	`return;`
`223`	`234`	`}`
`224`	`235`
`225`	`236`	`// If we reach this, we know the string is Unicode.`
`226`	`237`	`if (isChar \|\| ctx.Context.TargetInfo.WCharWidth == 16)`
`227`	`238`	`{`
`228`		`- ctx.Return.Write($"Marshal.PtrToStringUni({ctx.ReturnVarName})");`
	`239`	`+ ctx.Return.Write($"Marshal.PtrToStringUni({returnVarName})");`
`229`	`240`	`return;`
`230`	`241`	`}`
`231`	`242`	`// If we reach this, we should have an UTF-32 wide string.`
`232`	`243`	`const string encodingName = "System.Text.Encoding.UTF32";`
`233`	`244`	`ctx.Return.Write($@"CppSharp.Runtime.Helpers.MarshalEncodedString({`
`234`		`- ctx.ReturnVarName}, {encodingName})");`
	`245`	`+ returnVarName}, {encodingName})");`
`235`	`246`	`}`
`236`	`247`	`}`
`237`	`248`