Implement projection tooling for simple P/Invoke cases

Directory.Build.targets

@@ -8,7 +8,7 @@
                         TargetingPackVersion="$(MicrosoftNETCoreAppVersion)" />
   </ItemGroup>
 
-  <Import Condition="'$(IsTestProject)' == 'true'" Project="$(RepositoryEngineeringDir)testing\runsettings.targets" />
+  <!-- <Import Condition="'$(IsTestProject)' == 'true'" Project="$(RepositoryEngineeringDir)testing\runsettings.targets" /> -->
 
   <Import Project="Sdk.targets" Sdk="Microsoft.DotNet.Arcade.Sdk" />
 </Project>

README.md

@@ -2,9 +2,18 @@
 
 This is a collection of tools designed to consume a compiled Apple Swift library and generate bindings and wrappers that enable it to be used as a .NET library.
 
-## Current Status
-
-The components are currently undergoing iterative reviews and will be moved from https://github.com/xamarin/binding-tools-for-swift.
+## Installation and usage
+
+The tool will be available as a NuGet CLI package in the [`dotnet-experimental`](https://dev.azure.com/dnceng/public/_packaging?_a=feed&feed=dotnet-experimental) feed.
+
+Options:
+```
+  -d, --dylibs             Required. Paths to the dynamic libraries (dylibs), separated by commas.
+  -s, --swiftinterfaces    Required. Paths to the Swift interface files, separated by commas.
+  -o, --output             Required. Output directory for generated bindings.
+  -h, --help               Display this help message.
+  --version                Display version information.
+```
 
 ## .NET Foundation
 

eng/Versions.props

@@ -13,7 +13,7 @@
     <UsingToolXliff>false</UsingToolXliff>
     <!-- Libs -->
     <MicrosoftNETTestSdkVersion>16.7.1</MicrosoftNETTestSdkVersion>
-    <XUnitVersion>2.4.1</XUnitVersion>
+    <XUnitVersion>2.4.2</XUnitVersion>
     <XUnitRunnerVisualStudioVersion>2.4.3</XUnitRunnerVisualStudioVersion>
     <!-- Set the custom NETCoreApp version -->
     <MicrosoftNETCoreAppVersion>7.0.0-preview.7.22375.6</MicrosoftNETCoreAppVersion>

global.json

@@ -1,11 +1,11 @@
 {
   "sdk": {
-    "version": "8.0.100",
+    "version": "7.0.100",
     "allowPrerelease": true,
     "rollForward": "major"
   },
   "tools": {
-    "dotnet": "8.0.100"
+    "dotnet": "7.0.100"
   },
   "msbuild-sdks": {
     "Microsoft.DotNet.Arcade.Sdk": "9.0.0-beta.24102.4"

src/SwiftBindings/src/Program.cs

@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using CommandLine;
+using SwiftReflector;
+
+namespace SwiftBindings
+{
+    public class Options
+    {
+        [Option('d', "dylibs", Required = true, Separator = ',', HelpText = "Paths to the dynamic libraries (dylibs), separated by commas.")]
+        public IEnumerable<string> DylibPaths { get; set; }
+
+        [Option('s', "swiftinterfaces", Required = true, Separator = ',', HelpText = "Paths to the Swift interface files, separated by commas.")]
+        public IEnumerable<string> SwiftInterfacePaths { get; set; }
+
+        [Option('o', "output", Required = true, HelpText = "Output directory for generated bindings.")]
+        public string OutputDirectory { get; set; }
+
+        [Option('h', "help", HelpText = "Display this help message.")]
+        public bool Help { get; set; }
+    }
+
+    public class BindingsTool
+    {
+        public static void Main(string[] args)
+        {
+            Parser.Default.ParseArguments<Options>(args).WithParsed(options =>
+            {
+                if (options.Help)
+                {
+                    Console.WriteLine("Usage:");
+                    Console.WriteLine("  -d, --dylibs            Paths to the dynamic libraries (dylibs), separated by commas.");
+                    Console.WriteLine("  -s, --swiftinterfaces   Paths to the Swift interface files, separated by commas.");
+                    Console.WriteLine("  -o, --output            Output directory for generated bindings.");
+                    return;
+                }
+
+                if (options.DylibPaths == null || options.SwiftInterfacePaths == null || options.OutputDirectory == null)
+                {
+                    Console.WriteLine("Error: Missing required argument(s).");
+                    return;
+                }
+
+                if (options.DylibPaths.Count() != options.SwiftInterfacePaths.Count())
+                {
+                    Console.WriteLine("Error: Number of dylibs, interface files, and modules must match.");
+                    return;
+                }
+
+                if (!Directory.Exists(options.OutputDirectory))
+                {
+                    Console.WriteLine($"Error: Directory '{options.OutputDirectory}' doesn't exist.");
+                    return;
+                }
+
+                for (int i = 0; i < options.DylibPaths.Count(); i++)
+                {
+                    string dylibPath = options.DylibPaths.ElementAt(i);
+                    string swiftInterfacePath = options.SwiftInterfacePaths.ElementAt(i);
+
+                    if (!File.Exists(dylibPath))
+                    {
+                        Console.WriteLine($"Error: Dynamic library not found at path '{dylibPath}'.");
+                        return;
+                    }
+
+                    if (!File.Exists(swiftInterfacePath))
+                    {
+                        Console.WriteLine($"Error: Swift interface file not found at path '{swiftInterfacePath}'.");
+                        return;
+                    }
+
+                    GenerateBindings(dylibPath, swiftInterfacePath, options.OutputDirectory);
+                }
+            });
+        }
+
+        public static void GenerateBindings(string dylibPath, string swiftInterfacePath, string outputDirectory)
+        {
+            BindingsCompiler bindingsCompiler = new BindingsCompiler();
+            var errors = new ErrorHandling ();
+			var moduleInventory = bindingsCompiler.GetModuleInventory(dylibPath, errors);
+			var moduleDeclarations = bindingsCompiler.GetModuleDeclarations(swiftInterfacePath);
+			bindingsCompiler.CompileModules(moduleDeclarations, moduleInventory, dylibPath, outputDirectory, errors);
+        }
+    }
+}

src/SwiftBindings/src/SwiftBindings.csproj

@@ -2,9 +2,15 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
+    <Nullable>disable</Nullable>
   </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="../../SwiftReflector/SwiftReflector.csproj" />
+    <ProjectReference Include="../../SyntaxDynamo/SyntaxDynamo.csproj" />
+    <ProjectReference Include="../../SwiftRuntimeLibrary/SwiftRuntimeLibrary.csproj" />
 
+    <PackageReference Include="CommandLineParser" Version="2.9.1" />
+  </ItemGroup>
 </Project>

src/SwiftBindings/tests/CMakeLists.txt

@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.24)
+
+project(SmokeTests)
+
+set(SOURCE SmokeTests)
+
+if (NOT SWIFT_COMPILER_TARGET)
+    set(SWIFT_PLATFORM "macosx")
+    if (NOT DEFINED CMAKE_OSX_ARCHITECTURES OR CMAKE_OSX_ARCHITECTURES STREQUAL "")
+        set(CMAKE_OSX_ARCHITECTURES "arm64")
+    endif()
+    set(SWIFT_PLATFORM_SUFFIX "11")
+    set(SWIFT_DEPLOYMENT_TARGET ${CMAKE_OSX_DEPLOYMENT_TARGET})
+    set(SWIFT_COMPILER_TARGET "${CMAKE_OSX_ARCHITECTURES}-apple-${SWIFT_PLATFORM}${SWIFT_DEPLOYMENT_TARGET}${SWIFT_PLATFORM_SUFFIX}")
+endif()
+
+add_custom_target(${SOURCE} ALL
+    COMMAND xcrun swiftc -target ${SWIFT_COMPILER_TARGET} -emit-module -emit-library -enable-library-evolution -emit-module-interface ${CMAKE_CURRENT_SOURCE_DIR}/${SOURCE}.swift  -o ${CMAKE_CURRENT_BINARY_DIR}/lib${SOURCE}.dylib
+    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${SOURCE}.swift
+    COMMENT "Generating ${SOURCE} library"
+)
+
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${SOURCE}.dylib
+    DESTINATION bin
+)

src/SwiftBindings/tests/SmokeTests.cs

@@ -1,14 +1,37 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
 using System;
 using Xunit;
 
 namespace SwiftBindings.Tests
 {
-    public class MyClassTests
+    public class SmokeTests
     {
         [Fact]
-        public void Test1()
+        public void DirectPInvokeVoidVoid()
         {
-            Assert.True(MyClass.ReturnTrue);
+            BindingsTool.GenerateBindings("libSmokeTests.dylib", "SmokeTests.swiftinterface", "");
+            var sourceCode = """
+                // Copyright (c) Microsoft Corporation.
+                // Licensed under the MIT License.
+
+                using System;
+                using SmokeTests;
+
+                namespace Hello {
+                    class MainClass {
+                        public static int Main(string[] args)
+                        {
+                            TopLevelEntities.SimplePinvokeVoidVoid();
+                            return 42;
+                        }
+                    }
+                }
+                """;
+
+            int result = TestsHelper.CompileAndExecuteFromFileAndString("TopLevelEntitiesSmokeTests.cs", sourceCode);
+            Assert.Equal(42, result);
         }
     }
 }

src/SwiftBindings/tests/SmokeTests.swift

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+public func SimplePinvokeVoidVoid()
+{
+	print("Hello world");
+}

src/SwiftBindings/tests/SwiftBindings.Tests.csproj

@@ -1,9 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
+    <NativeLibsCommand>cd $(OutputPath)$(TargetFramework) &amp;&amp; cmake $(MSBuildThisFileDirectory) &amp;&amp; make</NativeLibsCommand>
   </PropertyGroup>
-  
+
   <ItemGroup>
-    <ProjectReference Include="..\src\SwiftBindings.csproj" />
+    <ProjectReference Include="../src/SwiftBindings.csproj" />
+
+    <PackageReference Include="Microsoft.CodeAnalysis" Version="4.8.0" />
   </ItemGroup>
+
+  <Target Name="CompileNativeLibs" AfterTargets="Build">
+    <Exec Command="$(NativeLibsCommand)" />
+  </Target>
 </Project>
+

src/SwiftBindings/tests/TestsHelper.cs

@@ -0,0 +1,65 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Emit;
+
+namespace SwiftBindings.Tests
+{
+    public static class TestsHelper
+    {
+        public static int CompileAndExecuteFromFileAndString(string filePath, string sourceCode)
+        {
+            string fileSourceCode = File.ReadAllText(filePath);
+            var sourceCodes = new[] { fileSourceCode, sourceCode };
+            return CompileAndExecute(sourceCodes);
+        }
+
+        private static int CompileAndExecute(string[] sourceCodes)
+        {
+            var options = new CSharpCompilationOptions(OutputKind.ConsoleApplication);
+            var syntaxTrees = sourceCodes.Select(code => CSharpSyntaxTree.ParseText(code)).ToArray();
+
+            var references = new[]
+            {
+                MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
+                MetadataReference.CreateFromFile(typeof(Console).Assembly.Location),
+            };
+
+
+            var compilation = CSharpCompilation.Create("CompiledAssembly",
+                                                        syntaxTrees: syntaxTrees,
+                                                        references: references,
+                                                        options: options);
+
+            string assemblyPath = Path.Combine(Path.GetTempPath(), "CompiledAssembly.dll");
+            using (var stream = new FileStream(assemblyPath, FileMode.Create))
+            {
+                EmitResult emitResult = compilation.Emit(stream);
+
+                if (!emitResult.Success)
+                {
+                    string errorMessage = "Compilation failed:";
+                    foreach (var diagnostic in emitResult.Diagnostics)
+                    {
+                        errorMessage += $"\n{diagnostic}";
+                    }
+                    throw new InvalidOperationException(errorMessage);
+                }
+            }
+
+            Assembly compiledAssembly = Assembly.LoadFile(assemblyPath);
+
+            MethodInfo entryPoint = compiledAssembly.EntryPoint;
+            object[] args = entryPoint.GetParameters().Length == 0 ? null : new object[] { new string[0] };
+            int result = (int)entryPoint.Invoke(null, args);
+
+            return result;
+        }
+    }
+}