Support foreigen untyped records

src/Generation/Generator/Generator/Internal/ForeignUntypedRecordHandle.cs

@@ -0,0 +1,29 @@
+using Generator.Model;
+
+namespace Generator.Generator.Internal;
+
+internal class ForeignUntypedRecordHandle : Generator<GirModel.Record>
+{
+    private readonly Publisher _publisher;
+
+    public ForeignUntypedRecordHandle(Publisher publisher)
+    {
+        _publisher = publisher;
+    }
+
+    public void Generate(GirModel.Record obj)
+    {
+        if (!Record.IsForeignUntyped(obj))
+            return;
+
+        var source = Renderer.Internal.ForeignUntypedRecordHandle.Render(obj);
+        var codeUnit = new CodeUnit(
+            Project: Namespace.GetCanonicalName(obj.Namespace),
+            Name: Model.ForeignTypedRecord.GetInternalHandle(obj),
+            Source: source,
+            IsInternal: true
+        );
+
+        _publisher.Publish(codeUnit);
+    }
+}

src/Generation/Generator/Generator/Public/ForeignUntypedRecord.cs

@@ -0,0 +1,29 @@
+using Generator.Model;
+
+namespace Generator.Generator.Public;
+
+internal class ForeignUntypedRecord : Generator<GirModel.Record>
+{
+    private readonly Publisher _publisher;
+
+    public ForeignUntypedRecord(Publisher publisher)
+    {
+        _publisher = publisher;
+    }
+
+    public void Generate(GirModel.Record record)
+    {
+        if (!Record.IsForeignUntyped(record))
+            return;
+
+        var source = Renderer.Public.ForeignUntypedRecord.Render(record);
+        var codeUnit = new CodeUnit(
+            Project: Namespace.GetCanonicalName(record.Namespace),
+            Name: Record.GetPublicClassName(record),
+            Source: source,
+            IsInternal: false
+        );
+
+        _publisher.Publish(codeUnit);
+    }
+}

src/Generation/Generator/Model/ForeignUntypedRecord.cs

@@ -0,0 +1,34 @@
+namespace Generator.Model;
+
+internal static class ForeignUntypedRecord
+{
+    public static string GetPublicClassName(GirModel.Record record)
+        => record.Name;
+
+    public static string GetFullyQualifiedPublicClassName(GirModel.Record record)
+        => Namespace.GetPublicName(record.Namespace) + "." + GetPublicClassName(record);
+
+    public static string GetFullyQualifiedInternalClassName(GirModel.Record record)
+        => Namespace.GetInternalName(record.Namespace) + "." + record.Name;
+
+    public static string GetInternalHandle(GirModel.Record record)
+        => $"{Type.GetName(record)}Handle";
+
+    public static string GetInternalOwnedHandle(GirModel.Record record)
+        => $"{Type.GetName(record)}OwnedHandle";
+
+    public static string GetInternalUnownedHandle(GirModel.Record record)
+        => $"{Type.GetName(record)}UnownedHandle";
+
+    public static string GetFullyQuallifiedInternalHandle(GirModel.Record record)
+        => $"{Namespace.GetInternalName(record.Namespace)}.{GetInternalHandle(record)}";
+
+    public static string GetFullyQuallifiedOwnedHandle(GirModel.Record record)
+        => $"{Namespace.GetInternalName(record.Namespace)}.{GetInternalOwnedHandle(record)}";
+
+    public static string GetFullyQuallifiedUnownedHandle(GirModel.Record record)
+        => $"{Namespace.GetInternalName(record.Namespace)}.{GetInternalUnownedHandle(record)}";
+
+    public static string GetFullyQuallifiedNullHandle(GirModel.Record record)
+        => $"{Namespace.GetInternalName(record.Namespace)}.{GetInternalUnownedHandle(record)}.NullHandle";
+}

src/Generation/Generator/Model/Record.cs

@@ -4,13 +4,18 @@ internal static partial class Record
 {
     public static bool IsStandard(GirModel.Record record)
     {
-        return !IsForeignTyped(record) && !IsOpaqueTyped(record) && !IsOpaqueUntyped(record) && !IsTyped(record) && !IsUntyped(record);
+        return !IsForeignTyped(record) && !IsForeignUntyped(record) && !IsOpaqueTyped(record) && !IsOpaqueUntyped(record) && !IsTyped(record) && !IsUntyped(record);
     }
 
     public static bool IsForeignTyped(GirModel.Record record)
     {
         return record is { Foreign: true, TypeFunction.CIdentifier: not null };
     }
+
+    public static bool IsForeignUntyped(GirModel.Record record)
+    {
+        return record is { Foreign: true, TypeFunction: null or { CIdentifier: "intern" } };
+    }
 
     public static bool IsOpaqueTyped(GirModel.Record record)
     {

src/Generation/Generator/Records.cs

@@ -17,29 +17,33 @@ public static void Generate(IEnumerable<GirModel.Record> records, string path)
             new Generator.Internal.UntypedRecordData(publisher),
             new Generator.Internal.UntypedRecordHandle(publisher),
             new Generator.Public.UntypedRecord(publisher),
-
+
+            //Foreign untyped records
+            new Generator.Internal.ForeignUntypedRecordHandle(publisher),
+            new Generator.Public.ForeignUntypedRecord(publisher),
+
             //Foreign typed records
             new Generator.Internal.ForeignTypedRecord(publisher),
             new Generator.Internal.ForeignTypedRecordHandle(publisher),
             new Generator.Public.ForeignTypedRecord(publisher),
-            
+
             //Opaque typed records
             new Generator.Internal.OpaqueTypedRecord(publisher),
             new Generator.Internal.OpaqueTypedRecordHandle(publisher),
             new Generator.Public.OpaqueTypedRecord(publisher),
-            
+
             //Opaque untyped records
             new Generator.Internal.OpaqueUntypedRecord(publisher),
             new Generator.Internal.OpaqueUntypedRecordHandle(publisher),
             new Generator.Public.OpaqueUntypedRecord(publisher),
-            
+
             //Typed records
             new Generator.Internal.TypedRecord(publisher),
             new Generator.Internal.TypedRecordDelegates(publisher),
             new Generator.Internal.TypedRecordHandle(publisher),
             new Generator.Internal.TypedRecordData(publisher),
             new Generator.Public.TypedRecord(publisher),
-            
+
             //Regular records
             new Generator.Internal.RecordDelegates(publisher),
             new Generator.Internal.RecordHandle(publisher),

src/Generation/Generator/Renderer/Internal/ForeignTypedRecordHandle.cs

@@ -53,7 +53,7 @@ public class {unownedHandleTypeName} : {typeName}
     internal {unownedHandleTypeName}() : base(false) {{ }}
 
     /// <summary>
-    /// Creates a new instance of {ownedHandleTypeName}. Assumes that the given pointer is unowned by the runtime.
+    /// Creates a new instance of {unownedHandleTypeName}. Assumes that the given pointer is unowned by the runtime.
     /// </summary>
     public {unownedHandleTypeName}(IntPtr ptr) : base(false)
     {{

src/Generation/Generator/Renderer/Internal/ForeignUntypedRecordHandle.cs

@@ -0,0 +1,74 @@
+using Generator.Model;
+
+namespace Generator.Renderer.Internal;
+
+internal static class ForeignUntypedRecordHandle
+{
+    public static string Render(GirModel.Record record)
+    {
+        var typeName = Model.ForeignUntypedRecord.GetInternalHandle(record);
+        var unownedHandleTypeName = Model.ForeignUntypedRecord.GetInternalUnownedHandle(record);
+        var ownedHandleTypeName = Model.ForeignUntypedRecord.GetInternalOwnedHandle(record);
+
+        return $@"using System;
+using GObject;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+
+#nullable enable
+
+namespace {Namespace.GetInternalName(record.Namespace)};
+
+// AUTOGENERATED FILE - DO NOT MODIFY
+
+{PlatformSupportAttribute.Render(record as GirModel.PlatformDependent)}
+public abstract class {typeName} : SafeHandle
+{{    
+    public sealed override bool IsInvalid => handle == IntPtr.Zero;
+
+    protected {typeName}(bool ownsHandle) : base(IntPtr.Zero, ownsHandle) {{ }}
+}}
+
+public class {unownedHandleTypeName} : {typeName}
+{{
+    private static {unownedHandleTypeName}? nullHandle;
+    public static {unownedHandleTypeName} NullHandle => nullHandle ??= new {unownedHandleTypeName}();
+
+    /// <summary>
+    /// Creates a new instance of {unownedHandleTypeName}. Used automatically by PInvoke.
+    /// </summary>
+    internal {unownedHandleTypeName}() : base(false) {{ }}
+
+    /// <summary>
+    /// Creates a new instance of {unownedHandleTypeName}. Assumes that the given pointer is unowned by the runtime.
+    /// </summary>
+    public {unownedHandleTypeName}(IntPtr ptr) : base(false)
+    {{
+        SetHandle(ptr);
+    }}
+
+    protected override bool ReleaseHandle()
+    {{
+        throw new System.Exception(""UnownedHandle must not be freed"");
+    }}
+}}
+
+public partial class {ownedHandleTypeName} : {typeName}
+{{
+    /// <summary>
+    /// Creates a new instance of {ownedHandleTypeName}. Used automatically by PInvoke.
+    /// </summary>
+    internal {ownedHandleTypeName}() : base(true) {{ }}
+
+    /// <summary>
+    /// Creates a new instance of {ownedHandleTypeName}. Assumes that the given pointer is owned by the runtime.
+    /// </summary>
+    public {ownedHandleTypeName}(IntPtr ptr) : base(true)
+    {{
+        SetHandle(ptr);
+    }}
+
+    protected override partial bool ReleaseHandle();
+}}";
+    }
+}

src/Generation/Generator/Renderer/Internal/InstanceParameter/InstanceParameters.cs

@@ -9,6 +9,7 @@ internal static class InstanceParameters
     {
         new InstanceParameter.Class(),
         new InstanceParameter.ForeignTypedRecord(),
+        new InstanceParameter.ForeignUntypedRecord(),
         new InstanceParameter.Interface(),
         new InstanceParameter.OpaqueTypedRecord(),
         new InstanceParameter.OpaqueUntypedRecord(),

src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRenderer.cs

@@ -11,6 +11,7 @@ internal static class ReturnTypeRenderer
         new ReturnType.ClassArray(),
         new ReturnType.Enumeration(),
         new ReturnType.ForeignTypedRecord(),
+        new ReturnType.ForeignUntypedRecord(),
         new ReturnType.Interface(),
         new ReturnType.InterfaceGLibPtrArray(),
         new ReturnType.OpaqueTypedRecord(),

src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/ForeignTypedRecord.cs

@@ -15,7 +15,7 @@ public string GetString(GirModel.ReturnType returnType, string fromVariableName)
             { Transfer: GirModel.Transfer.None, Nullable: false } => $"{fromVariableName}.Handle.DangerousGetHandle()",
             { Transfer: GirModel.Transfer.Full, Nullable: true } => $"{fromVariableName}?.Handle.UnownedCopy().DangerousGetHandle() ?? IntPtr.Zero",
             { Transfer: GirModel.Transfer.Full, Nullable: false } => $"{fromVariableName}.Handle.UnownedCopy().DangerousGetHandle()",
-            _ => throw new Exception($"Unknown transfer type for opaque record return type which should be converted to native.")
+            _ => throw new Exception($"Unknown transfer type for foreigen typed record return type which should be converted to native.")
         };
     }
 }

src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/ReturnTypeToNativeExpression.cs

@@ -10,6 +10,7 @@ internal static class ReturnTypeToNativeExpression
         new ReturnTypeToNativeExpressions.Class(),
         new ReturnTypeToNativeExpressions.Enumeration(),
         new ReturnTypeToNativeExpressions.ForeignTypedRecord(),
+        new ReturnTypeToNativeExpressions.ForeignUntypedRecord(),
         new ReturnTypeToNativeExpressions.Interface(),
         new ReturnTypeToNativeExpressions.OpaqueTypedRecord(),
         new ReturnTypeToNativeExpressions.OpaqueUntypedRecord(),

src/Generation/Generator/Renderer/Public/ForeignUntypedRecord.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Linq;
+using Generator.Model;
+
+namespace Generator.Renderer.Public;
+
+internal static class ForeignUntypedRecord
+{
+    public static string Render(GirModel.Record record)
+    {
+        var name = Model.ForeignUntypedRecord.GetPublicClassName(record);
+        var internalHandleName = Model.ForeignUntypedRecord.GetFullyQuallifiedOwnedHandle(record);
+
+        return $@"
+using System;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+
+#nullable enable
+
+namespace {Namespace.GetPublicName(record.Namespace)};
+
+// AUTOGENERATED FILE - DO NOT MODIFY
+
+{PlatformSupportAttribute.Render(record as GirModel.PlatformDependent)}
+public partial class {name}
+{{
+    public {internalHandleName} Handle {{ get; }}
+
+    public {name}({internalHandleName} handle)
+    {{
+        Handle = handle;
+    }}
+}}";
+    }
+}

src/Generation/Generator/Renderer/Public/Parameter/Converter/ForeignTypedRecord.cs

@@ -26,6 +26,6 @@ private static string GetNullableTypeName(GirModel.Parameter parameter)
     private static string GetDirection(GirModel.Parameter parameter) => parameter switch
     {
         { Direction: GirModel.Direction.In } => ParameterDirection.In(),
-        _ => throw new Exception("Opaque records with direction != in not yet supported")
+        _ => throw new Exception("Foreign typed records with direction != in not yet supported")
     };
 }

src/Generation/Generator/Renderer/Public/Parameter/ParameterRenderer.cs

@@ -13,6 +13,7 @@ internal static class ParameterRenderer
         new Parameter.Enumeration(),
         new Parameter.ForeignTypedRecord(),
         new Parameter.ForeignTypedRecordArray(),
+        new Parameter.ForeignUntypedRecord(),
         new Parameter.Interface(),
         new Parameter.InterfaceArray(),
         new Parameter.OpaqueTypedRecord(),

src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/ForeignTypedRecord.cs

@@ -24,7 +24,7 @@ public void Initialize(ParameterToNativeData parameter, IEnumerable<ParameterToN
             { Nullable: false, Transfer: GirModel.Transfer.None } => $"{signatureName}.Handle",
             { Nullable: true, Transfer: GirModel.Transfer.Full } => $"{signatureName}?.Handle.UnownedCopy() ?? {nullHandle}",
             { Nullable: false, Transfer: GirModel.Transfer.Full } => $"{signatureName}.Handle.UnownedCopy()",
-            _ => throw new Exception($"Can't detect call name for parameter opaque parameter {parameter.Parameter.Name}")
+            _ => throw new Exception($"Can't detect call name for foreign typed parameter {parameter.Parameter.Name}")
         };
 
         parameter.SetSignatureName(() => signatureName);

src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/ParameterToNativeExpression.cs

@@ -15,6 +15,7 @@ internal static class ParameterToNativeExpression
         new ParameterToNativeExpressions.Enumeration(),
         new ParameterToNativeExpressions.ForeignTypedRecord(),
         new ParameterToNativeExpressions.ForeignTypedRecordArray(),
+        new ParameterToNativeExpressions.ForeignUntypedRecord(),
         new ParameterToNativeExpressions.Interface(),
         new ParameterToNativeExpressions.InterfaceArray(),
         new ParameterToNativeExpressions.OpaqueTypedRecord(),

src/Generation/Generator/Renderer/Public/ReturnType/ReturnTypeRenderer.cs

@@ -11,6 +11,7 @@ internal static class ReturnTypeRenderer
         new ReturnType.Class(),
         new ReturnType.Enumeration(),
         new ReturnType.ForeignTypedRecord(),
+        new ReturnType.ForeignUntypedRecord(),
         new ReturnType.Interface(),
         new ReturnType.OpaqueTypedRecord(),
         new ReturnType.OpaqueUntypedRecord(),

src/Generation/Generator/Renderer/Public/ReturnType/ReturnTypeRendererCallback.cs

@@ -10,6 +10,7 @@ internal static class ReturnTypeRendererCallback
         new ReturnType.Class(),
         new ReturnType.Enumeration(),
         new ReturnType.ForeignTypedRecord(),
+        new ReturnType.ForeignUntypedRecord(),
         new ReturnType.Interface(),
         new ReturnType.OpaqueTypedRecord(),
         new ReturnType.OpaqueUntypedRecord(),

src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/ReturnTypeToManagedExpression.cs

@@ -10,6 +10,7 @@ internal static class ReturnTypeToManagedExpression
         new ReturnTypeToManagedExpressions.Class(),
         new ReturnTypeToManagedExpressions.Enumeration(),
         new ReturnTypeToManagedExpressions.ForeignTypedRecord(),
+        new ReturnTypeToManagedExpressions.ForeignUntypedRecord(),
         new ReturnTypeToManagedExpressions.Interface(),
         new ReturnTypeToManagedExpressions.OpaqueTypedRecord(),
         new ReturnTypeToManagedExpressions.OpaqueUntypedRecord(),

src/Libs/cairo-1.0/Internal/Matrix.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Runtime.InteropServices;
+using System.Runtime.InteropServices;
 
 namespace Cairo.Internal;