Progress

Author: PathogenDavid

Biohazrd.CSharp/#TypeReferences/ByRefTypeReference.cs

@@ -0,0 +1,55 @@
+using Biohazrd.CSharp.Infrastructure;
+using Biohazrd.Transformation;
+using Biohazrd.Transformation.Infrastructure;
+using System;
+
+namespace Biohazrd.CSharp;
+
+public sealed record ByRefTypeReference : TypeReference, ICustomTypeReference, ICustomCSharpTypeReference
+{
+    private ByRefKind _Kind;
+    public ByRefKind Kind
+    {
+        get => _Kind;
+        init
+        {
+            if (!Enum.IsDefined(value))
+            { throw new ArgumentOutOfRangeException(nameof(value)); }
+
+            _Kind = value;
+        }
+    }
+
+    public TypeReference Inner { get; init; }
+
+    public string Keyword => Kind.GetKeyword();
+
+    public ByRefTypeReference(ByRefKind kind, TypeReference inner)
+    {
+        if (!Enum.IsDefined(kind))
+        { throw new ArgumentOutOfRangeException(nameof(kind)); }
+
+        _Kind = kind;
+        Inner = inner;
+    }
+
+    TypeTransformationResult ICustomTypeReference.TransformChildren(ITypeTransformation transformation, TypeTransformationContext context)
+    {
+        DiagnosticAccumulator diagnostics = new();
+        SingleTypeTransformHelper newInnerType = new(Inner, ref diagnostics);
+
+        // Transform inner type
+        newInnerType.SetValue(transformation.TransformTypeRecursively(context, Inner));
+
+        // Create the result
+        TypeTransformationResult result = newInnerType.WasChanged ? this with { Inner = newInnerType.NewValue } : this;
+        result.AddDiagnostics(diagnostics.MoveToImmutable());
+        return result;
+    }
+
+    string ICustomCSharpTypeReference.GetTypeAsString(ICSharpOutputGenerator outputGenerator, VisitorContext context, TranslatedDeclaration declaration)
+        => $"{Keyword} {outputGenerator.GetTypeAsString(context, declaration, Inner)}";
+
+    public override string ToString()
+        => $"{Keyword} {Inner}";
+}

Biohazrd.CSharp/BiohzardExtensions.cs

@@ -99,5 +99,17 @@ internal static ParameterOutputMode GetParameterOutputMode(this TranslatedParame
 
         public static Trampoline GetPrimaryTrampoline(this TranslatedFunction function)
             => function.TryGetPrimaryTrampoline() ?? throw new InvalidOperationException("Tried to get the primary trampoline of a function with no trampoline metadata.");
+
+        public static TranslatedFunction WithSecondaryTrampoline(this TranslatedFunction function, Trampoline secondaryTrampoline)
+        {
+            if (!function.Metadata.TryGet(out TrampolineCollection trampolines))
+            { throw new InvalidOperationException("Cannot add a secondary trampoline to a function which has no trampolines."); }
+
+            trampolines = trampolines.WithTrampoline(secondaryTrampoline);
+            return function with
+            {
+                Metadata = function.Metadata.Set(trampolines)
+            };
+        }
     }
 }

Biohazrd.CSharp/ByRefKind.cs

@@ -1,8 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Biohazrd.CSharp;
 
@@ -12,3 +8,15 @@ public enum ByRefKind
     In,
     Out
 }
+
+public static class ByRefKindExtensions
+{
+    public static string GetKeyword(this ByRefKind kind)
+        => kind switch
+        {
+            ByRefKind.Ref => "ref",
+            ByRefKind.In => "in",
+            ByRefKind.Out => "out",
+            _ => throw new ArgumentOutOfRangeException(nameof(kind))
+        };
+}

Biohazrd.CSharp/Trampolines/ByRefAdapter.cs

@@ -22,30 +22,14 @@ public ByRefAdapter(Adapter target, ByRefKind kind)
         { throw new ArgumentOutOfRangeException(nameof(kind)); }
 
         OutputType = pointerType;
-        InputType = pointerType.Inner; //TODO: This is somewhat misleading because it's actually ByRef
+        InputType = new ByRefTypeReference(kind, pointerType.Inner);
         ParameterName = target.ParameterName;
         TemporaryName = $"__{ParameterName}P";
         Kind = kind;
     }
 
     public override void WriteInputParameter(TrampolineContext context, CSharpCodeWriter writer, bool emitDefaultValue)
     {
-        switch (Kind)
-        {
-            case ByRefKind.In:
-                writer.Write("in ");
-                break;
-            case ByRefKind.Out:
-                writer.Write("out ");
-                break;
-            case ByRefKind.Ref:
-                writer.Write("ref ");
-                break;
-            default:
-                Debug.Fail("Invalid byref kind!");
-                break;
-        }
-
         context.WriteType(InputType);
         writer.Write(' ');
         writer.WriteIdentifier(ParameterName);

Biohazrd.CSharp/Trampolines/PassthroughAdapter.cs

@@ -40,5 +40,15 @@ public override bool WriteBlockBeforeCall(TrampolineContext context, CSharpCodeW
         => false;
 
     public override void WriteOutputArgument(TrampolineContext context, CSharpCodeWriter writer)
-        => writer.WriteIdentifier(ParameterName);
+    {
+        if (InputType is ByRefTypeReference byRefType)
+        {
+            // In theory we don't have to do this for `in` parameters, but C# allows you to overload between byref in and by value.
+            // Detecting if this was done is more effort than it's wroth to save 3 characters, so we write out an explicit `in` keyword to ensure the correct overload is chosen.
+            writer.Write(byRefType.Kind.GetKeyword());
+            writer.Write(' ');
+        }
+
+        writer.WriteIdentifier(ParameterName);
+    }
 }

Biohazrd.CSharp/Trampolines/Trampoline.cs

@@ -49,23 +49,34 @@ internal Trampoline(TrampolineBuilder builder)
         { ReturnAdapter = builder.ReturnAdapter; }
         else if (template?.ReturnAdapter is not null)
         { ReturnAdapter = template.ReturnAdapter; }
-        else if (Target.ReturnAdapter is VoidReturnAdapter)
+        else if (Target.ReturnAdapter.OutputType is VoidTypeReference)
         { ReturnAdapter = VoidReturnAdapter.Instance; }
         else
         { ReturnAdapter = new PassthroughReturnAdapter(Target.ReturnAdapter); }
 
         // Add parameter adapters
-        int expectedLength = template is not null ? template.Adapters.Length : Target.Adapters.Length;
+        int expectedLength;
+        if (template is not null)
+        { expectedLength = template.Adapters.Length; }
+        else
+        {
+            expectedLength = 0;
+            foreach (Adapter adapter in Target.Adapters)
+            {
+                if (adapter.AcceptsInput)
+                { expectedLength++; }
+            }
+        }
         ImmutableArray<Adapter>.Builder adapters = ImmutableArray.CreateBuilder<Adapter>(expectedLength);
 
         foreach (Adapter targetAdapter in template?.Adapters ?? Target.Adapters)
         {
             // If the builder adapted this adapter, insert its adapter
             if (builder.Adapters?.TryGetValue(targetAdapter, out Adapter? adapter) ?? false)
-            { adapters.Add(adapter); }
+            { adapters.Add(adapter); } //TODO: Debug.Assert(template is not null || targetAdapter.AcceptsInput); ? Is it enough this is done in Adapter's constructor? (Probably.)
             else if (builder.TargetIsTemplate)
             { adapters.Add(targetAdapter); }
-            else
+            else if (targetAdapter.AcceptsInput)
             { adapters.Add(new PassthroughAdapter(targetAdapter)); }
         }
 
@@ -109,7 +120,7 @@ internal void Write(ICSharpOutputGenerator outputGenerator, VisitorContext conte
         string? virtualMethodAccess = null;
         string? virtualMethodAccessFailure = null;
 
-        if (declaration.IsVirtual)
+        if (declaration.IsVirtual && Target is not null && Target.IsNativeFunction)
         {
             // Figure out how to access the VTable entry
             if (context.ParentDeclaration is not TranslatedRecord record)