CodeGen: implement the wide architecture set

Cesium.CodeGen.Tests/ArchitectureDependentCodeTests.cs

@@ -1,11 +1,12 @@
+using System.Diagnostics.CodeAnalysis;
 using JetBrains.Annotations;
 
 namespace Cesium.CodeGen.Tests;
 
 public class ArchitectureDependentCodeTests : CodeGenTestBase
 {
     [MustUseReturnValue]
-    private static Task DoTest(TargetArchitectureSet arch, string source)
+    private static Task DoTest(TargetArchitectureSet arch, [StringSyntax("cpp")] string source)
     {
         var assembly = GenerateAssembly(runtime: default, arch: arch, sources: source);
         return VerifyTypes(assembly, arch);
@@ -15,6 +16,7 @@ private static Task DoTest(TargetArchitectureSet arch, string source)
     [InlineData(TargetArchitectureSet.Bit64)]
     [InlineData(TargetArchitectureSet.Bit32)]
     [InlineData(TargetArchitectureSet.Dynamic)]
+    [InlineData(TargetArchitectureSet.Wide)]
     public Task StaticArray(TargetArchitectureSet arch) => DoTest(arch, """
 int main(void)
 {
@@ -28,6 +30,7 @@ int main(void)
     [InlineData(TargetArchitectureSet.Bit64)]
     [InlineData(TargetArchitectureSet.Bit32)]
     [InlineData(TargetArchitectureSet.Dynamic)]
+    [InlineData(TargetArchitectureSet.Wide)]
     public Task StructArray(TargetArchitectureSet arch) => DoTest(arch, """
 typedef struct { char *ptr; } foo;
 
@@ -42,6 +45,7 @@ int main(void)
     // TODO[#355]: [InlineData(TargetArchitectureSet.Bit64)]
     // TODO[#355]: [InlineData(TargetArchitectureSet.Bit32)]
     [InlineData(TargetArchitectureSet.Dynamic)]
+    // TODO[#355] [InlineData(TargetArchitectureSet.Wide)]
     public Task TwoMemberStructArray(TargetArchitectureSet arch) => DoTest(arch, """
 typedef struct { char *ptr; int len; } foo;
 
@@ -56,6 +60,7 @@ int main(void)
     [InlineData(TargetArchitectureSet.Dynamic)]
     [InlineData(TargetArchitectureSet.Bit64)]
     [InlineData(TargetArchitectureSet.Bit32)]
+    [InlineData(TargetArchitectureSet.Wide)]
     public Task PointerArrayMemberAssign(TargetArchitectureSet arch) => DoTest(arch, """
 int main(void)
 {
@@ -69,6 +74,7 @@ int main(void)
     [InlineData(TargetArchitectureSet.Dynamic)]
     [InlineData(TargetArchitectureSet.Bit64)]
     [InlineData(TargetArchitectureSet.Bit32)]
+    [InlineData(TargetArchitectureSet.Wide)]
     public Task PointerFunctionSignature(TargetArchitectureSet arch) => DoTest(arch, """
 int foo(void *x)
 {
@@ -80,11 +86,41 @@ int foo(void *x)
     [InlineData(TargetArchitectureSet.Dynamic)]
     [InlineData(TargetArchitectureSet.Bit64)]
     [InlineData(TargetArchitectureSet.Bit32)]
+    [InlineData(TargetArchitectureSet.Wide)]
+    public Task FunctionPointerParameter(TargetArchitectureSet arch) => DoTest(arch, """
+typedef void (*func)(int, int);
+typedef void (*v_func)(void);
+
+int foo(func x) { return 0; }
+int v_foo(v_func x) { return 0; }
+""");
+
+    [Theory]
+    [InlineData(TargetArchitectureSet.Dynamic)]
+    [InlineData(TargetArchitectureSet.Bit64)]
+    [InlineData(TargetArchitectureSet.Bit32)]
+    [InlineData(TargetArchitectureSet.Wide)]
     public Task FunctionPointerStructMember(TargetArchitectureSet arch) => DoTest(arch, """
 typedef void (*func)(int);
 struct Foo
 {
     func x;
 };
+""");
+    // TODO[#487]: empty-paren-func ptr
+    // TODO[#487]: vararg-func ptr
+
+    [Theory]
+    [InlineData(TargetArchitectureSet.Dynamic)]
+    [InlineData(TargetArchitectureSet.Bit64)]
+    [InlineData(TargetArchitectureSet.Bit32)]
+    [InlineData(TargetArchitectureSet.Wide)]
+    public Task StructWithNestedFuncPtr(TargetArchitectureSet arch) => DoTest(arch, """
+typedef int (*func)(void);
+typedef int (*hostFunc)(func);
+typedef struct
+{
+    hostFunc foo;
+} foo;
 """);
 }

Cesium.CodeGen.Tests/ArchitectureDependentTypeTests.cs

@@ -1,33 +1,59 @@
+using System.Diagnostics.CodeAnalysis;
 using JetBrains.Annotations;
 
 namespace Cesium.CodeGen.Tests;
 
 public class ArchitectureDependentTypeTests : CodeGenTestBase
 {
     [MustUseReturnValue]
-    private static Task DoTest(TargetArchitectureSet arch, string source, string @namespace = "", string globalTypeFqn = "")
+    private static Task DoTest(
+        TargetArchitectureSet arch,
+        [StringSyntax("cpp")] string source)
     {
         var assembly = GenerateAssembly(
             default,
             arch,
-            @namespace: @namespace,
-            globalTypeFqn: globalTypeFqn,
+            @namespace: "",
+            globalTypeFqn: "",
             sources: source);
         return VerifyTypes(assembly, arch);
     }
 
     [Theory]
     [InlineData(TargetArchitectureSet.Bit64)]
     [InlineData(TargetArchitectureSet.Bit32)]
-    public Task StructWithPointer(TargetArchitectureSet arch) => DoTest(arch, """
+    [InlineData(TargetArchitectureSet.Wide)]
+    public Task StructWithPointerArray(TargetArchitectureSet arch) => DoTest(arch, """
 typedef struct
 {
     char *x[1];
 } foo;
 """);
 
+    [Theory]
+    [InlineData(TargetArchitectureSet.Dynamic)]
+    [InlineData(TargetArchitectureSet.Bit64)]
+    [InlineData(TargetArchitectureSet.Bit32)]
+    [InlineData(TargetArchitectureSet.Wide)]
+    public Task StructWithPointer(TargetArchitectureSet arch) => DoTest(arch, """
+        typedef struct
+        {
+            char *x;
+        } foo;
+        """);
+
+    [Theory]
+    [InlineData(TargetArchitectureSet.Dynamic)]
+    [InlineData(TargetArchitectureSet.Wide)]
+    public Task StructWithDoublePointer(TargetArchitectureSet arch) => DoTest(arch, """
+        typedef struct
+        {
+            int **x;
+        } foo;
+        """);
+
     [Fact(DisplayName = "Struct with a fixed array of a pointer type isn't supported for dynamic architecture")]
-    public void StructWithPointerDynamic() => DoesNotCompile("""
+    public void StructWithPointerArrayDynamic() => DoesNotCompile("""
 typedef struct
 {
     char *x[1];

Cesium.CodeGen.Tests/Cesium.CodeGen.Tests.csproj

@@ -8,7 +8,7 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="JetBrains.Annotations" Version="2022.1.0" />
+        <PackageReference Include="JetBrains.Annotations" Version="2023.3.0" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
         <PackageReference Include="Verify.Xunit" Version="16.3.5" />
         <PackageReference Include="xunit" Version="2.4.1" />
@@ -24,6 +24,7 @@
 
     <ItemGroup>
       <ProjectReference Include="..\Cesium.CodeGen\Cesium.CodeGen.csproj" />
+      <ProjectReference Include="..\Cesium.Compiler\Cesium.Compiler.csproj" />
       <ProjectReference Include="..\Cesium.Core\Cesium.Core.csproj" />
       <ProjectReference Include="..\Cesium.Parser\Cesium.Parser.csproj" />
       <ProjectReference Include="..\Cesium.Runtime\Cesium.Runtime.csproj" />

Cesium.CodeGen.Tests/CodeGenNetInteropTests.cs

@@ -0,0 +1,173 @@
+using System.Diagnostics.CodeAnalysis;
+using Cesium.Compiler;
+using Cesium.Test.Framework;
+using Xunit.Abstractions;
+
+namespace Cesium.CodeGen.Tests;
+
+// TODO[#488]: Make them run in parallel, as all the integration tests
+public class CodeGenNetInteropTests : CodeGenTestBase
+{
+    private readonly ITestOutputHelper _output;
+    public CodeGenNetInteropTests(ITestOutputHelper output)
+    {
+        _output = output;
+    }
+
+    private async Task DoTest(
+        TargetArchitectureSet architecture,
+        [StringSyntax("csharp")] string cSharpCode,
+        [StringSyntax("cpp")] string cCode)
+    {
+        var cSharpAssemblyPath = await CSharpCompilationUtil.CompileCSharpAssembly(
+            _output,
+            CSharpCompilationUtil.DefaultRuntime,
+            cSharpCode);
+        var (cesiumAssembly, assemblyContents) = GenerateAssembly(runtime: null, arch: architecture, sources: new[]{cCode}, referencePaths: new[] { cSharpAssemblyPath });
+        await VerifyTypes(cesiumAssembly, architecture);
+        await VerifyAssemblyRuns(assemblyContents.ToArray(), cSharpAssemblyPath);
+    }
+
+    private async Task VerifyAssemblyRuns(byte[] assemblyContentToRun, string referencePath)
+    {
+        var testDirectoryPath = Path.GetTempFileName();
+        File.Delete(testDirectoryPath);
+        Directory.CreateDirectory(testDirectoryPath);
+
+        try
+        {
+            var assemblyPath = Path.Combine(testDirectoryPath, "EntryPoint.dll");
+            var runtimeConfigPath = Path.ChangeExtension(assemblyPath, ".runtimeconfig.json");
+
+            await File.WriteAllBytesAsync(assemblyPath, assemblyContentToRun);
+            await File.WriteAllTextAsync(runtimeConfigPath, RuntimeConfig.EmitNet7());
+
+            DeployReferenceAssembly(CSharpCompilationUtil.CesiumRuntimeLibraryPath);
+            DeployReferenceAssembly(referencePath);
+
+            await ExecUtil.RunToSuccess(_output, "dotnet", testDirectoryPath, new[] { assemblyPath });
+        }
+        finally
+        {
+            Directory.Delete(testDirectoryPath, recursive: true);
+        }
+
+        void DeployReferenceAssembly(string assemblyPath)
+        {
+            var targetFilePath = Path.Combine(testDirectoryPath, Path.GetFileName(assemblyPath));
+            File.Copy(assemblyPath, targetFilePath);
+        }
+    }
+
+    [Theory]
+    [InlineData(TargetArchitectureSet.Dynamic)]
+    [InlineData(TargetArchitectureSet.Wide)]
+    public Task PointerInterop(TargetArchitectureSet architecture) => DoTest(
+        architecture,
+        @"public static unsafe class Test
+{
+    public static int Func(int* ptr) => 1;
+}
+", """
+__cli_import("Test::Func")
+int Func(int *ptr);
+
+int main(void)
+{
+    int x = 0;
+    return Func(&x) - 1;
+}
+""");
+
+    [Theory]
+    [InlineData(TargetArchitectureSet.Dynamic)]
+    [InlineData(TargetArchitectureSet.Wide)]
+    public Task CPtrInterop(TargetArchitectureSet architecture) => DoTest(
+        architecture,
+        @"using Cesium.Runtime;
+public static class Test
+{
+    public static int Func(CPtr<int> ptr) => 1;
+}
+", """
+   __cli_import("Test::Func")
+   int Func(int *ptr);
+
+   int main(void)
+   {
+       int x = 0;
+       return Func(&x) - 1;
+   }
+   """);
+
+    [Theory]
+    [InlineData(TargetArchitectureSet.Dynamic)]
+    [InlineData(TargetArchitectureSet.Wide)]
+    public Task VoidPtrInterop(TargetArchitectureSet architecture) => DoTest(
+        architecture,
+        @"using Cesium.Runtime;
+public static class Test
+{
+    public static int Func(VoidPtr ptr) => 1;
+}
+", """
+   __cli_import("Test::Func")
+   int Func(void *ptr);
+
+   int main(void)
+   {
+       int x = 0;
+       return Func(&x) - 1;
+   }
+   """);
+
+    [Theory]
+    [InlineData(TargetArchitectureSet.Dynamic)]
+    [InlineData(TargetArchitectureSet.Wide)]
+    public Task FuncPtrInterop(TargetArchitectureSet architecture) => DoTest(
+        architecture,
+        @"using Cesium.Runtime;
+public static class Test
+{
+    public static int Func(FuncPtr<Func<int>> ptr) => 1;
+}
+", """
+__cli_import("Test::Func")
+int Func(int (*ptr)());
+
+int myFunc()
+{
+   return 0;
+}
+
+int main(void)
+{
+   return Func(&myFunc) - 1;
+}
+""");
+
+    [Theory]
+    [InlineData(TargetArchitectureSet.Dynamic)]
+    [InlineData(TargetArchitectureSet.Wide)]
+    public Task FunctionPointerInterop(TargetArchitectureSet architecture) => DoTest(
+        architecture,
+        """
+public static unsafe class Test
+{
+    public static int Func(delegate*<int> ptr) => 1;
+}
+""", """
+__cli_import("Test::Func")
+int Func(int (*ptr)());
+
+int myFunc()
+{
+   return 0;
+}
+
+int main(void)
+{
+   return Func(&myFunc) - 1;
+}
+""");
+}