Prototype interfaces dynamic casting

Dntc.Cli/Transpiler.cs

@@ -3,6 +3,7 @@
 using Dntc.Common.Conversion;
 using Dntc.Common.Conversion.Mutators;
 using Dntc.Common.Definitions;
+using Dntc.Common.Definitions.CustomDefinedTypes;
 using Dntc.Common.Definitions.Definers;
 using Dntc.Common.Definitions.Mutators;
 using Dntc.Common.Definitions.ReferenceTypeSupport;
@@ -75,6 +76,7 @@ public async Task RunAsync()
             definitionCatalog.Add(NativeDefinedType.StandardTypes.Values);
             definitionCatalog.Add(NativeDefinedMethod.StandardMethods);
             definitionCatalog.Add(CustomDefinedMethod.StandardCustomMethods);
+            definitionCatalog.Add(CustomDefinedType.StandardCustomTypes);
         }
 
         foreach (var plugin in plugins)

Dntc.Common/Conversion/PlannedFileConverter.cs

@@ -111,7 +111,11 @@ private IReadOnlyList<CStatementSet> GetMethodStatements(
         }
 
         var statements = new List<CStatementSet>();
-
+
+        if (dotNetDefinedMethod.Definition.HasBody == false)
+        {
+            return statements;
+        }
         Instruction methodInstruction = dotNetDefinedMethod.Definition.Body.Instructions.First();
 
         OnBeforeGenerateInstruction(statements, dotNetDefinedMethod, methodInstruction);
@@ -123,7 +127,11 @@ private IReadOnlyList<CStatementSet> GetMethodStatements(
             var local = dotNetDefinedMethod.Locals[x];
             var localType = _conversionCatalog.Find(local.Type);
             var name = Utils.LocalName(dotNetDefinedMethod.Definition, x);
-            var variable = new Variable(localType, name, local.Type.IsPointer());
+            var variable = new Variable(localType, name,
+                local.Type.IsPointer() || localType.OriginalTypeDefinition is DotNetDefinedType
+                {
+                    Definition.IsValueType: false
+                });
 
             if (locals.Add(name))
             {

Dntc.Common/Conversion/TypeConversionInfo.cs

@@ -98,7 +98,12 @@ private void SetupDotNetType(DotNetDefinedType type)
         if (!type.Definition.IsValueType)
         {
             IsReferenceType = true;
-            ReferencedHeaders = [new HeaderName("<stdlib.h>"), new HeaderName("<string.h>")];
+            ReferencedHeaders =
+            [
+                new HeaderName("<stdlib.h>"), 
+                new HeaderName("<string.h>"), 
+                new HeaderName("<stddef.h>")
+            ];
         }
     }
 

Dntc.Common/Definitions/CustomDefinedMethod.cs

@@ -44,6 +44,7 @@ protected CustomDefinedMethod(
     [
         new FloatMinDefinedMethod(),
         new StaticConstructorInitializerDefinedMethod(),
+        new DynamicCastInterfaceDefinedMethod()
     ];
 
     protected override IReadOnlyList<IlTypeName> GetReferencedTypesInternal() => [];

Dntc.Common/Definitions/CustomDefinedMethods/DynamicCastInterfaceDefinedMethod.cs

@@ -0,0 +1,52 @@
+using Dntc.Common.Conversion;
+using Dntc.Common.Definitions.CustomDefinedTypes;
+using Dntc.Common.Definitions.ReferenceTypeSupport;
+using Dntc.Common.Syntax.Statements;
+
+namespace Dntc.Common.Definitions.CustomDefinedMethods;
+
+public class DynamicCastInterfaceDefinedMethod() : CustomDefinedMethod(MethodId,
+    ReferenceTypeConstants.ReferenceTypeBaseId,
+    new IlNamespace("DntC.Platform.Utils"),
+    new HeaderName("dntc.h"),
+    null,
+    new CFunctionName("dynamic_cast_interface"),
+    [
+        new Parameter(ReferenceTypeConstants.ReferenceTypeBaseId, "instance", true),
+        new Parameter(NativeDefinedType.StandardTypes[typeof(uint)].IlName, "interface", false),
+    ], false)
+{
+    public static readonly IlMethodId MethodId = new("[Util: DynamicCastInterface]");
+
+    protected override IReadOnlyList<IlTypeName> GetReferencedTypesInternal()
+    {
+        return [TypeInfoDefinedType.TypeName];
+    }
+
+    public override CustomCodeStatementSet? GetCustomDeclaration()
+    {
+        var baseClass = ReferenceTypeConstants.ReferenceTypeBaseTypeName;
+
+
+         string content = @$"
+static {baseClass}* dynamic_cast_interface({baseClass}* instance, uint32_t interface) {{
+    if (instance && instance->type_info) {{
+        TypeInfo* type_info = instance->type_info;
+        for (size_t i = 0; i < type_info->interface_count; ++i) {{
+            if (type_info->implemented_interfaces[i] == interface) {{
+                // Calculate the address of the interface implementation using the offset
+                return ({baseClass}*)((char*)instance + type_info->interface_offsets[i]);
+            }}
+        }}
+    }}
+    return NULL; // Interface is not implemented
+}}
+";
+        return new CustomCodeStatementSet(content);
+    }
+
+    public override CustomCodeStatementSet? GetCustomImplementation(ConversionCatalog catalog)
+    {
+        return null;
+    }
+}

Dntc.Common/Definitions/CustomDefinedMethods/ReferenceTypeAllocationMethod.cs

@@ -33,7 +33,7 @@ public ReferenceTypeAllocationMethod(TypeDefinition typeDefinition)
 
         foreach (var virtualMethod in _typeDefinition.Methods.Where(x => x.IsVirtual))
         {
-            if (virtualMethod.IsReuseSlot)
+            if (virtualMethod.IsReuseSlot || virtualMethod.IsFinal)
             {
                 InvokedMethods.Add(new InvokedMethod(new IlMethodId(virtualMethod.FullName)));
             }
@@ -52,6 +52,7 @@ public ReferenceTypeAllocationMethod(TypeDefinition typeDefinition)
     public override CStatementSet? GetCustomImplementation(ConversionCatalog catalog)
     {
         var typeInfo = catalog.Find(new IlTypeName(_typeDefinition.FullName));
+        var typeName = typeInfo.NameInC;
         var typeNameExpression = new LiteralValueExpression(typeInfo.NameInC.Value, typeInfo);
         var variable = new Variable(typeInfo, "result", true);
         var statements = new List<CStatementSet>
@@ -61,7 +62,55 @@ public ReferenceTypeAllocationMethod(TypeDefinition typeDefinition)
         };
 
         var sb = new StringBuilder();
-        foreach (var virtualMethod in _typeDefinition.Methods.Where(x => x.IsVirtual))
+
+        sb.AppendLine($@"    {typeName}* result = ({typeName}*) malloc(sizeof({typeName}));
+	memset(result, 0, sizeof({typeName}));");
+
+        var typeInfoName =typeName + "_TypeInfo";
+        sb.AppendLine($"\t((ReferenceType_Base*)result)->type_info = &{typeInfoName};");
+
+        var interfaceMethods = new HashSet<IlMethodId>();
+
+        foreach (var iface in _typeDefinition.Interfaces)
+        {
+            var ifaceType = catalog.Find(new IlTypeName(iface.InterfaceType.FullName));
+            sb.AppendLine($"\tresult->{ifaceType.NameInC}.implementer = result;");
+
+            foreach (var interfaceMethod in iface.InterfaceType.Resolve().Methods)
+            {
+                var implementingMethod = _typeDefinition.Methods.SingleOrDefault(x => interfaceMethod.SignatureCompatibleWith(x));
+
+                if (implementingMethod != null)
+                {
+                    interfaceMethods.Add(new IlMethodId(implementingMethod.FullName));
+                    var interfaceMethodInfo = catalog.Find(new IlMethodId(interfaceMethod.FullName));
+                    var implementingMethodInfo = catalog.Find(new IlMethodId(implementingMethod.FullName));
+
+                    sb.Append($"\tresult->{ifaceType.NameInC}.{interfaceMethodInfo.NameInC} = ");
+
+                    sb.Append($"({interfaceMethodInfo.ReturnTypeInfo.NativeNameWithPossiblePointer()} (*)(");
+
+                    for (var x = 0; x < interfaceMethodInfo.Parameters.Count; x++)
+                    {
+                        if (x > 0) sb.Append(", ");
+                        var param = interfaceMethodInfo.Parameters[x];
+                        var paramType = param.ConversionInfo.NameInC.Value;
+
+                        if (x == 0)
+                        {
+                            paramType = "void";
+                        }
+
+                        var pointerSymbol = param.IsReference ? "*" : "";
+                        sb.Append($"{paramType}{pointerSymbol}");
+                    }
+
+                    sb.AppendLine($")){implementingMethodInfo.NameInC};");
+                }
+            }
+        }
+
+        foreach (var virtualMethod in _typeDefinition.Methods.Where(x => x.IsVirtual && !interfaceMethods.Contains(new IlMethodId(x.FullName))))
         {
             if (virtualMethod.IsReuseSlot)
             {

Dntc.Common/Definitions/CustomDefinedType.cs

@@ -1,4 +1,5 @@
 using Dntc.Common.Conversion;
+using Dntc.Common.Definitions.CustomDefinedTypes;
 using Dntc.Common.Syntax.Statements;
 
 namespace Dntc.Common.Definitions;
@@ -32,4 +33,9 @@ protected CustomDefinedType(
     }
 
     public abstract CustomCodeStatementSet? GetCustomTypeDeclaration(ConversionCatalog catalog);
+
+    public static IReadOnlyList<CustomDefinedType> StandardCustomTypes { get; } =
+    [
+        new TypeInfoDefinedType()
+    ];
 }

Dntc.Common/Definitions/CustomDefinedTypes/ArrayDefinedType.cs

@@ -1,7 +1,6 @@
 using Dntc.Common.Conversion;
 using Dntc.Common.Syntax.Expressions;
 using Dntc.Common.Syntax.Statements;
-using Mono.Cecil;
 
 namespace Dntc.Common.Definitions.CustomDefinedTypes;
 

Dntc.Common/Definitions/CustomDefinedTypes/TypeInfoDefinedType.cs

@@ -0,0 +1,28 @@
+using Dntc.Common.Conversion;
+using Dntc.Common.Definitions.ReferenceTypeSupport.TypeInfo;
+using Dntc.Common.Syntax.Statements;
+
+namespace Dntc.Common.Definitions.CustomDefinedTypes;
+
+public class TypeInfoDefinedType() : CustomDefinedType(TypeName,
+    new HeaderName("dntc.h"),
+    null,
+    new CTypeName("TypeInfo"),
+    [],
+    [])
+{
+    public static readonly IlTypeName TypeName = TypeInfoConstants.TypeInfoTypeId;
+
+    public override CustomCodeStatementSet? GetCustomTypeDeclaration(ConversionCatalog catalog)
+    {
+        const string content = @"
+typedef struct TypeInfo {
+    uint32_t* implemented_interfaces; // Array of implemented interfaces
+	size_t* interface_offsets; // Array of offsets for each interface
+	size_t interface_count; // Count of implemented interfaces
+} TypeInfo;
+";
+
+        return new CustomCodeStatementSet(content);
+    }
+}

Dntc.Common/Definitions/DefinitionCatalog.cs

@@ -89,6 +89,28 @@ public IEnumerable<DefinedMethod> GetMethodOverrides(DefinedMethod method)
             }
         }
     }
+
+    public IEnumerable<DefinedMethod> GetInterfaceMethods(DefinedMethod method)
+    {
+        if (method is DotNetDefinedMethod { Definition.IsVirtual: true } dntMethod)
+        {
+            var baseType = dntMethod.Definition.DeclaringType;
+
+            foreach (var type in _types.Values.OfType<DotNetDefinedType>().Where(x=>x.Definition.IsInterface))
+            {
+                if (baseType.ImplementsInterface(type.Definition))
+                {
+                    foreach (var derivedMethod in type.Methods.Select(Get).OfType<DotNetDefinedMethod>())
+                    {
+                        if (derivedMethod.Definition.IsOverrideOf(dntMethod.Definition))
+                        {
+                            yield return _methods[derivedMethod.Id];
+                        }
+                    }
+                }
+            }
+        }
+    }
 
     private void Add(TypeDefinition type)
     {

Dntc.Common/Definitions/DotNetDefinedMethod.cs

@@ -191,39 +191,43 @@ private void Analyze()
         }
 
         var referencedHeaders = new HashSet<HeaderName>();
-        foreach (var instruction in Definition.Body.Instructions)
+
+        if (Definition.HasBody)
         {
-            if (!KnownOpCodeHandlers.OpCodeHandlers.TryGetValue(instruction.OpCode.Code, out var handler))
+            foreach (var instruction in Definition.Body.Instructions)
             {
-                var debugInfo = CecilUtils.LoggedSequencePointInfo(
-                    CecilUtils.GetSequencePoint(
-                        Definition,
-                        instruction));
+                if (!KnownOpCodeHandlers.OpCodeHandlers.TryGetValue(instruction.OpCode.Code, out var handler))
+                {
+                    var debugInfo = CecilUtils.LoggedSequencePointInfo(
+                        CecilUtils.GetSequencePoint(
+                            Definition,
+                            instruction));
 
-                var message = $"No handler for op code '{instruction.OpCode.Code}' {debugInfo}";
-                throw new InvalidOperationException(message);
-            }
+                    var message = $"No handler for op code '{instruction.OpCode.Code}' {debugInfo}";
+                    throw new InvalidOperationException(message);
+                }
 
-            var results = handler.Analyze(new AnalyzeContext(instruction, this));
+                var results = handler.Analyze(new AnalyzeContext(instruction, this));
 
-            foreach (var method in results.CalledMethods)
-            {
-                _invokedMethods.Add(method);
-            }
+                foreach (var method in results.CalledMethods)
+                {
+                    _invokedMethods.Add(method);
+                }
 
-            foreach (var referencedType in results.ReferencedTypes)
-            {
-                _referencedTypes.Add(referencedType);
-            }
+                foreach (var referencedType in results.ReferencedTypes)
+                {
+                    _referencedTypes.Add(referencedType);
+                }
 
-            foreach (var header in results.ReferencedHeaders)
-            {
-                referencedHeaders.Add(header);
-            }
+                foreach (var header in results.ReferencedHeaders)
+                {
+                    referencedHeaders.Add(header);
+                }
 
-            if (results.ReferencedGlobal != null)
-            {
-                _referencedGlobals.Add(new IlFieldId(results.ReferencedGlobal.FullName));
+                if (results.ReferencedGlobal != null)
+                {
+                    _referencedGlobals.Add(new IlFieldId(results.ReferencedGlobal.FullName));
+                }
             }
         }
 

Dntc.Common/Definitions/DotNetDefinedType.cs

@@ -1,4 +1,5 @@
 using Dntc.Common.Definitions.ReferenceTypeSupport;
+using Dntc.Common.Definitions.CustomDefinedTypes;
 using Mono.Cecil;
 
 namespace Dntc.Common.Definitions;
@@ -28,6 +29,8 @@ public DotNetDefinedType(TypeDefinition definition)
             .Where(x => !x.IsStatic)
             .Select(ConvertToField)
             .ToArray();
+
+        var referencedTypes = new List<IlTypeName>();
 
         if (!definition.IsValueType)
         {
@@ -38,8 +41,7 @@ public DotNetDefinedType(TypeDefinition definition)
                 definition.BaseType.FullName != typeof(Enum).FullName)
             {
                 var baseTypeName = new IlTypeName(definition.BaseType.FullName);
-
-                OtherReferencedTypes = [baseTypeName];
+                referencedTypes.Add(baseTypeName);
             }
             else
             {
@@ -55,6 +57,10 @@ public DotNetDefinedType(TypeDefinition definition)
             }
         }
 
+        referencedTypes.AddRange(definition.Interfaces.Select(x => new IlTypeName(x.InterfaceType.FullName)));
+
+        OtherReferencedTypes = referencedTypes.ToArray();
+
         Methods = definition.Methods
             .Select(x => new IlMethodId(x.FullName))
             .ToArray();