Differentiate between Long and CLong

GirModel.CLong is 32 bit on all windows platforms, 32 bit on 32 bit unix platforms and 64 bit on 64bit unix platforms. GirModel.Long ist 64 bit on all platforms.

This reverts the changes from #1067 and only adds the CLong / CULong handling for "glong" / "gulong". All other long types stay like originally intended.

Fixes #1098

src/Generation/Generator/Model/Type.cs

@@ -19,9 +19,11 @@ public static string GetName(GirModel.Type type)
             GirModel.SignedByte => "sbyte",
             GirModel.Short => "short",
             GirModel.Long => "long",
+            GirModel.CLong => "long",
             GirModel.UnsignedShort => "ushort",
             GirModel.UnsignedInteger => "uint",
             GirModel.UnsignedLong => "ulong",
+            GirModel.UnsignedCLong => "ulong",
             GirModel.Byte => "byte",
             GirModel.Bool => "bool",
             GirModel.Void => "void",

src/Generation/Generator/Renderer/Internal/Field/Converter/CLong.cs

@@ -0,0 +1,25 @@
+namespace Generator.Renderer.Internal.Field;
+
+internal class CLong : FieldConverter
+{
+    public bool Supports(GirModel.Field field)
+    {
+        return field.AnyTypeOrCallback.TryPickT0(out var anyType, out _) && anyType.Is<GirModel.CLong>();
+    }
+
+    public RenderableField Convert(GirModel.Field field)
+    {
+        return new RenderableField(
+            Name: Model.Field.GetName(field),
+            Attribute: null,
+            NullableTypeName: GetNullableTypeName(field)
+        );
+    }
+
+    private static string GetNullableTypeName(GirModel.Field field)
+    {
+        return field.IsPointer
+            ? Model.Type.Pointer
+            : "CLong";
+    }
+}

src/Generation/Generator/Renderer/Internal/Field/Converter/Long.cs

@@ -20,6 +20,6 @@ private static string GetNullableTypeName(GirModel.Field field)
     {
         return field.IsPointer
             ? Model.Type.Pointer
-            : "CLong";
+            : Model.Type.GetName(field.AnyTypeOrCallback.AsT0.AsT0);
     }
 }

src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedCLong.cs

@@ -0,0 +1,25 @@
+namespace Generator.Renderer.Internal.Field;
+
+internal class UnsignedCLong : FieldConverter
+{
+    public bool Supports(GirModel.Field field)
+    {
+        return field.AnyTypeOrCallback.TryPickT0(out var anyType, out _) && anyType.Is<GirModel.UnsignedCLong>();
+    }
+
+    public RenderableField Convert(GirModel.Field field)
+    {
+        return new RenderableField(
+            Name: Model.Field.GetName(field),
+            Attribute: null,
+            NullableTypeName: GetNullableTypeName(field)
+        );
+    }
+
+    private static string GetNullableTypeName(GirModel.Field field)
+    {
+        return field.IsPointer
+            ? Model.Type.Pointer
+            : "CULong";
+    }
+}

src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedLong.cs

@@ -20,6 +20,6 @@ private static string GetNullableTypeName(GirModel.Field field)
     {
         return field.IsPointer
             ? Model.Type.Pointer
-            : "CULong";
+            : Model.Type.GetName(field.AnyTypeOrCallback.AsT0.AsT0);
     }
 }

src/Generation/Generator/Renderer/Internal/Field/Fields.cs

@@ -21,6 +21,8 @@ internal static class Fields
         new Field.PointerArray(),
         new Field.Long(), //Must be before primitive value
         new Field.UnsignedLong(), //Must be before primitive value
+        new Field.CLong(), //Must be before primitive value
+        new Field.UnsignedCLong(), //Must be before primitive value
         new Field.PrimitiveValueType(),
         new Field.PrimitiveValueTypeAlias(),
         new Field.PrimitiveValueTypeArray(),

src/Generation/Generator/Renderer/Internal/Parameter/CallbackParameters.cs

@@ -27,6 +27,8 @@ internal static class CallbackParameters
         new Parameter.PointerGLibPtrArray(),
         new Parameter.Long(), //Must be before primitive value type
         new Parameter.UnsignedLong(), //Must be before primitive value type
+        new Parameter.CLong(), //Must be before primitive value type
+        new Parameter.UnsignedCLong(), //Must be before primitive value type
         new Parameter.PrimitiveValueType(),
         new Parameter.PrimitiveValueTypeAlias(),
         new Parameter.PrimitiveValueTypeArray(),

src/Generation/Generator/Renderer/Internal/Parameter/Converter/CLong.cs

@@ -0,0 +1,44 @@
+using System;
+
+namespace Generator.Renderer.Internal.Parameter;
+
+internal class CLong : ParameterConverter
+{
+    public bool Supports(GirModel.AnyType anyType)
+    {
+        return anyType.Is<GirModel.CLong>();
+    }
+
+    public RenderableParameter Convert(GirModel.Parameter parameter)
+    {
+        // If the parameter is both nullable and optional this implies a parameter type like 'int **' and possibly
+        // ownership transfer (this combination does not currently occur for any functions).
+        if (parameter is { Nullable: true, Optional: true })
+            throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Long value type with nullable=true and optional=true not yet supported");
+
+        // Nullable-only parameters likely have incorrect annotations and should be marked optional instead.
+        if (parameter.Nullable)
+            Log.Information($"Long value type '{parameter.Name}' with nullable=true is likely an incorrect annotation");
+
+        // The caller-allocates flag is not meaningful for primitive types (https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/446)
+        if (parameter.CallerAllocates)
+            Log.Information($"Long value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation");
+
+        return new RenderableParameter(
+            Attribute: string.Empty,
+            Direction: GetDirection(parameter),
+            NullableTypeName: "CLong",
+            Name: Model.Parameter.GetName(parameter)
+        );
+    }
+
+    private static string GetDirection(GirModel.Parameter parameter) => parameter switch
+    {
+        // - Optional inout and out types are just exposed as non-nullable ref / out parameters which the user can ignore if desired.
+        { Direction: GirModel.Direction.In, IsPointer: true } => ParameterDirection.Ref(),
+        { Direction: GirModel.Direction.InOut } => ParameterDirection.Ref(),
+        { Direction: GirModel.Direction.Out } => ParameterDirection.Out(),
+        { Direction: GirModel.Direction.In } => ParameterDirection.In(),
+        _ => throw new Exception($"Can't figure out direction for internal long value type parameter {parameter}.")
+    };
+}

src/Generation/Generator/Renderer/Internal/Parameter/Converter/Long.cs

@@ -14,20 +14,20 @@ public RenderableParameter Convert(GirModel.Parameter parameter)
         // If the parameter is both nullable and optional this implies a parameter type like 'int **' and possibly
         // ownership transfer (this combination does not currently occur for any functions).
         if (parameter is { Nullable: true, Optional: true })
-            throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Long value type with nullable=true and optional=true not yet supported");
+            throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Primitive value type with nullable=true and optional=true not yet supported");
 
         // Nullable-only parameters likely have incorrect annotations and should be marked optional instead.
         if (parameter.Nullable)
-            Log.Information($"Long value type '{parameter.Name}' with nullable=true is likely an incorrect annotation");
+            Log.Information($"Primitive value type '{parameter.Name}' with nullable=true is likely an incorrect annotation");
 
         // The caller-allocates flag is not meaningful for primitive types (https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/446)
         if (parameter.CallerAllocates)
-            Log.Information($"Long value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation");
+            Log.Information($"Primitive value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation");
 
         return new RenderableParameter(
             Attribute: string.Empty,
             Direction: GetDirection(parameter),
-            NullableTypeName: "CLong",
+            NullableTypeName: Model.Type.GetName(parameter.AnyTypeOrVarArgs.AsT0.AsT0),
             Name: Model.Parameter.GetName(parameter)
         );
     }
@@ -39,6 +39,6 @@ public RenderableParameter Convert(GirModel.Parameter parameter)
         { Direction: GirModel.Direction.InOut } => ParameterDirection.Ref(),
         { Direction: GirModel.Direction.Out } => ParameterDirection.Out(),
         { Direction: GirModel.Direction.In } => ParameterDirection.In(),
-        _ => throw new Exception($"Can't figure out direction for internal long value type parameter {parameter}.")
+        _ => throw new Exception($"Can't figure out direction for internal primitive value type parameter {parameter}.")
     };
 }

src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedCLong.cs

@@ -0,0 +1,44 @@
+using System;
+
+namespace Generator.Renderer.Internal.Parameter;
+
+internal class UnsignedCLong : ParameterConverter
+{
+    public bool Supports(GirModel.AnyType anyType)
+    {
+        return anyType.Is<GirModel.UnsignedCLong>();
+    }
+
+    public RenderableParameter Convert(GirModel.Parameter parameter)
+    {
+        // If the parameter is both nullable and optional this implies a parameter type like 'int **' and possibly
+        // ownership transfer (this combination does not currently occur for any functions).
+        if (parameter is { Nullable: true, Optional: true })
+            throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Unsigned long value type with nullable=true and optional=true not yet supported");
+
+        // Nullable-only parameters likely have incorrect annotations and should be marked optional instead.
+        if (parameter.Nullable)
+            Log.Information($"Unsigned long value type '{parameter.Name}' with nullable=true is likely an incorrect annotation");
+
+        // The caller-allocates flag is not meaningful for primitive types (https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/446)
+        if (parameter.CallerAllocates)
+            Log.Information($"Unsigned long value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation");
+
+        return new RenderableParameter(
+            Attribute: string.Empty,
+            Direction: GetDirection(parameter),
+            NullableTypeName: "CULong",
+            Name: Model.Parameter.GetName(parameter)
+        );
+    }
+
+    private static string GetDirection(GirModel.Parameter parameter) => parameter switch
+    {
+        // - Optional inout and out types are just exposed as non-nullable ref / out parameters which the user can ignore if desired.
+        { Direction: GirModel.Direction.In, IsPointer: true } => ParameterDirection.Ref(),
+        { Direction: GirModel.Direction.InOut } => ParameterDirection.Ref(),
+        { Direction: GirModel.Direction.Out } => ParameterDirection.Out(),
+        { Direction: GirModel.Direction.In } => ParameterDirection.In(),
+        _ => throw new Exception($"Can't figure out direction for internal unsigned long value type parameter {parameter}.")
+    };
+}

src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedLong.cs

@@ -14,20 +14,20 @@ public RenderableParameter Convert(GirModel.Parameter parameter)
         // If the parameter is both nullable and optional this implies a parameter type like 'int **' and possibly
         // ownership transfer (this combination does not currently occur for any functions).
         if (parameter is { Nullable: true, Optional: true })
-            throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Unsigned long value type with nullable=true and optional=true not yet supported");
+            throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Primitive value type with nullable=true and optional=true not yet supported");
 
         // Nullable-only parameters likely have incorrect annotations and should be marked optional instead.
         if (parameter.Nullable)
-            Log.Information($"Unsigned long value type '{parameter.Name}' with nullable=true is likely an incorrect annotation");
+            Log.Information($"Primitive value type '{parameter.Name}' with nullable=true is likely an incorrect annotation");
 
         // The caller-allocates flag is not meaningful for primitive types (https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/446)
         if (parameter.CallerAllocates)
-            Log.Information($"Unsigned long value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation");
+            Log.Information($"Primitive value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation");
 
         return new RenderableParameter(
             Attribute: string.Empty,
             Direction: GetDirection(parameter),
-            NullableTypeName: "CULong",
+            NullableTypeName: Model.Type.GetName(parameter.AnyTypeOrVarArgs.AsT0.AsT0),
             Name: Model.Parameter.GetName(parameter)
         );
     }
@@ -39,6 +39,6 @@ public RenderableParameter Convert(GirModel.Parameter parameter)
         { Direction: GirModel.Direction.InOut } => ParameterDirection.Ref(),
         { Direction: GirModel.Direction.Out } => ParameterDirection.Out(),
         { Direction: GirModel.Direction.In } => ParameterDirection.In(),
-        _ => throw new Exception($"Can't figure out direction for internal unsigned long value type parameter {parameter}.")
+        _ => throw new Exception($"Can't figure out direction for internal primitive value type parameter {parameter}.")
     };
 }

src/Generation/Generator/Renderer/Internal/Parameter/Parameters.cs

@@ -32,6 +32,8 @@ internal static class Parameters
         new Parameter.PointerGLibPtrArray(),
         new Parameter.Long(), //Must be before primitive value type
         new Parameter.UnsignedLong(), //Must be before primitive value type
+        new Parameter.CLong(), //Must be before primitive value type
+        new Parameter.UnsignedCLong(), //Must be before primitive value type
         new Parameter.PrimitiveValueType(),
         new Parameter.PrimitiveValueTypeAlias(),
         new Parameter.PrimitiveValueTypeArray(),

src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/CLong.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+
+namespace Generator.Renderer.Internal.ParameterToManagedExpressions;
+
+internal class CLong : ToManagedParameterConverter
+{
+    public bool Supports(GirModel.AnyType type)
+        => type.Is<GirModel.CLong>();
+
+    public void Initialize(ParameterToManagedData parameterData, IEnumerable<ParameterToManagedData> parameters)
+    {
+        switch (parameterData.Parameter)
+        {
+            case { Direction: GirModel.Direction.In, IsPointer: false }:
+                Direct(parameterData);
+                break;
+            default:
+                throw new NotImplementedException($"This kind of internal long value type (pointed: {parameterData.Parameter.IsPointer}, direction: {parameterData.Parameter.Direction} can't be converted to managed currently.");
+        }
+    }
+
+    private static void Direct(ParameterToManagedData parameterData)
+    {
+        var variableName = Model.Parameter.GetName(parameterData.Parameter);
+
+        parameterData.SetSignatureName(() => variableName);
+        parameterData.SetCallName(() => $"{variableName}.Value");
+    }
+}

src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/Long.cs

@@ -12,19 +12,41 @@ public void Initialize(ParameterToManagedData parameterData, IEnumerable<Paramet
     {
         switch (parameterData.Parameter)
         {
+            case { Direction: GirModel.Direction.In, IsPointer: true }:
+                Ref(parameterData);
+                break;
             case { Direction: GirModel.Direction.In, IsPointer: false }:
                 Direct(parameterData);
                 break;
+            case { Direction: GirModel.Direction.Out, IsPointer: true }:
+                Out(parameterData);
+                break;
             default:
-                throw new NotImplementedException($"This kind of internal long value type (pointed: {parameterData.Parameter.IsPointer}, direction: {parameterData.Parameter.Direction} can't be converted to managed currently.");
+                throw new NotImplementedException($"This kind of internal primitive value type (pointed: {parameterData.Parameter.IsPointer}, direction: {parameterData.Parameter.Direction} can't be converted to managed currently.");
         }
     }
 
+    private static void Ref(ParameterToManagedData parameterData)
+    {
+        var variableName = Model.Parameter.GetName(parameterData.Parameter);
+
+        parameterData.SetSignatureName(() => variableName);
+        parameterData.SetCallName(() => $"ref {variableName}");
+    }
+
     private static void Direct(ParameterToManagedData parameterData)
     {
         var variableName = Model.Parameter.GetName(parameterData.Parameter);
 
         parameterData.SetSignatureName(() => variableName);
-        parameterData.SetCallName(() => $"{variableName}.Value");
+        parameterData.SetCallName(() => variableName);
+    }
+
+    private static void Out(ParameterToManagedData parameterData)
+    {
+        var variableName = Model.Parameter.GetName(parameterData.Parameter);
+
+        parameterData.SetSignatureName(() => variableName);
+        parameterData.SetCallName(() => $"out {variableName}");
     }
 }

src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/UnsignedCLong.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+
+namespace Generator.Renderer.Internal.ParameterToManagedExpressions;
+
+internal class UnsignedCLong : ToManagedParameterConverter
+{
+    public bool Supports(GirModel.AnyType type)
+        => type.Is<GirModel.UnsignedCLong>();
+
+    public void Initialize(ParameterToManagedData parameterData, IEnumerable<ParameterToManagedData> parameters)
+    {
+        switch (parameterData.Parameter)
+        {
+            case { Direction: GirModel.Direction.In, IsPointer: false }:
+                Direct(parameterData);
+                break;
+            default:
+                throw new NotImplementedException($"This kind of internal unsigned long value type (pointed: {parameterData.Parameter.IsPointer}, direction: {parameterData.Parameter.Direction} can't be converted to managed currently.");
+        }
+    }
+
+    private static void Direct(ParameterToManagedData parameterData)
+    {
+        var variableName = Model.Parameter.GetName(parameterData.Parameter);
+
+        parameterData.SetSignatureName(() => variableName);
+        parameterData.SetCallName(() => $"{variableName}.Value");
+    }
+}