[Swift language feature] Implement Swift.String wrapper in C#

src/Swift.Bindings/tests/IntegrationTests/FunctionalTests/Structs/StructsTests.cs

@@ -392,6 +392,19 @@ private static unsafe int SumSet(SwiftSet<SwiftIntMock> set)
         [DllImport("Structs/libStructsTests.dylib", EntryPoint = "$s12StructsTests8sumArray5arrays5Int32VSayAEG_tF")]
         private static extern int PInvoke_SumSet(Variant array);
 
+        [Fact]
+        public void TestString()
+        {
+            SwiftString swiftString = StructsTests.getString();
+            int result = StructsTests.verifyString(swiftString);
+            Assert.Equal(42, result);
 
+            string str = swiftString.ToString();
+            Assert.Equal("Hello world!", str);
+
+            swiftString = new SwiftString(str);
+            result = StructsTests.verifyString(swiftString);
+            Assert.Equal(42, result);
+        }
     }
 }

src/Swift.Bindings/tests/IntegrationTests/FunctionalTests/Structs/StructsTests.swift

@@ -257,3 +257,18 @@ public func sumArray(array: Array<Int32>) -> Int32
 {
     return array.reduce(0, +)
 }
+
+public func getString() -> String
+{
+    return "Hello world!"
+}
+
+public func verifyString(str: String) -> Int32
+{
+    if str == "Hello world!" {
+        return 42
+    }
+
+    return -1
+}
+

src/Swift.Runtime/src/Swift/FoundationDatabase.xml

@@ -70,5 +70,8 @@
         <entity managedNameSpace="Swift" managedTypeName="UnsafeMutableBufferPointer&lt;System.Byte&gt;">
             <typedeclaration kind="struct" name="UnsafeMutableBufferPointer&lt;Swift.UInt8&gt;" module="Swift" mangledName="sSr" frozen="true" blittable="true"/>
         </entity>
+        <entity managedNameSpace="Swift" managedTypeName="SwiftString">
+            <typedeclaration kind="struct" name="String" module="Swift" mangledName="sSS" frozen="true" blittable="true"/>
+        </entity>
     </entities>
 </swifttypedatabase>

src/Swift.Runtime/src/Swift/SwiftArray.cs

@@ -272,9 +272,11 @@ public unsafe Element this[int index]
 
 internal static class SwiftArrayPInvokes
 {
+    [UnmanagedCallConv(CallConvs = [typeof(CallConvSwift)])]
     [DllImport(KnownLibraries.SwiftCore, EntryPoint = "$sSaMa")]
     public static extern TypeMetadata PInvoke_getMetadata(TypeMetadataRequest request, TypeMetadata typeMetadata);
 
+    [UnmanagedCallConv(CallConvs = [typeof(CallConvSwift)])]
     [DllImport(KnownLibraries.SwiftCore, EntryPoint = "$sS2ayxGycfC")]
     public static extern ArrayBuffer Init(TypeMetadata typeMetadata);
 
@@ -286,6 +288,7 @@ internal static class SwiftArrayPInvokes
     [DllImport(KnownLibraries.SwiftCore, EntryPoint = "$sSayxSicis")]
     public static unsafe extern void Set(SwiftHandle value, nint index, TypeMetadata elementMetadata, SwiftSelf self);
 
+    [UnmanagedCallConv(CallConvs = [typeof(CallConvSwift)])]
     [DllImport(KnownLibraries.SwiftCore, EntryPoint = "$sSa5countSivg")]
     public static extern nint Count(ArrayBuffer handle, TypeMetadata elementMetadata);
 

src/Swift.Runtime/src/Swift/SwiftString.cs

@@ -0,0 +1,164 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.Swift;
+using System.Text;
+using Swift.Runtime;
+using Swift.Runtime.InteropServices;
+
+namespace Swift;
+
+/// <summary>
+/// Represents Foundation.Data type.
+/// </summary>
+public struct Data
+{
+    private long _flags;
+    private IntPtr _object;
+}
+
+/// <summary>
+/// Represents a Swift string with Foundation.Data payload.
+/// </summary>
+public struct SwiftString : ISwiftObject
+{
+    static nuint _payloadSize = SwiftObjectHelper<SwiftString>.GetTypeMetadata().Size;
+
+    private Data _payload;
+
+    private static Dictionary<Type, string> _protocolConformanceSymbols;
+
+    static SwiftString()
+    {
+        _protocolConformanceSymbols = new Dictionary<Type, string> { };
+    }
+
+    public static nuint PayloadSize => _payloadSize;
+
+    public Data Payload => _payload;
+
+    static TypeMetadata ISwiftObject.GetTypeMetadata()
+    {
+        return TypeMetadata.Cache.GetOrAdd(typeof(SwiftString), _ => PInvoke_getMetadata());
+    }
+
+    static ISwiftObject ISwiftObject.NewFromPayload(SwiftHandle handle)
+    {
+        return new SwiftString(handle);
+    }
+
+    IntPtr ISwiftObject.MarshalToSwift(IntPtr swiftDest)
+    {
+        var metadata = SwiftObjectHelper<SwiftString>.GetTypeMetadata();
+        unsafe
+        {
+            fixed (void* _payloadPtr = &_payload)
+            {
+                metadata.ValueWitnessTable->InitializeWithCopy((void*)swiftDest, (void*)_payloadPtr, metadata);
+            }
+        }
+        return swiftDest;
+    }
+
+    /// <summary>
+    /// Gets the protocol conformance descriptor for the given type.
+    /// </summary>
+    /// <typeparam name="TProtocol"></typeparam>
+    /// <returns></returns>
+    static ProtocolConformanceDescriptor ISwiftObject.GetProtocolConformanceDescriptor<TProtocol>()
+        where TProtocol : class
+    {
+        if (!_protocolConformanceSymbols.TryGetValue(typeof(TProtocol), out var symbolName))
+        {
+            throw new SwiftRuntimeException($"Attempted to retrieve protocol conformance descriptor for type SwiftString and protocol {typeof(TProtocol).Name}, but no conformance was found.");
+        }
+        return ProtocolConformanceDescriptor.LoadFromSymbol("/usr/lib/swift/libswiftCore.dylib", symbolName);
+    }
+
+    /// <summary>
+    /// Constructs a new SwiftString from the given handle.
+    /// </summary>
+    unsafe SwiftString(SwiftHandle handle)
+    {
+        _payload = *(Data*)handle;
+    }
+
+    /// <summary>
+    /// Constructs a new SwiftString from the C# string.
+    /// </summary>
+    public SwiftString(string str)
+    {
+        byte[] utf8Bytes = Encoding.UTF8.GetBytes(str);
+        unsafe
+        {
+            fixed (byte* utf8BytesPtr = utf8Bytes)
+            {
+                _payload = PInvoke_Create(utf8BytesPtr, utf8Bytes.Length, 1);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Gets the length of string.
+    /// </summary>
+    public int Length => (int)PInvoke_GetLength(_payload);
+
+    /// <summary>
+    /// Converts the SwiftString to a C# string.
+    /// </summary>
+    public override string ToString()
+    {
+        unsafe
+        {
+            var elementType = TypeMetadata.GetTypeMetadataOrThrow<byte>();
+            var resultType = TypeMetadata.GetTypeMetadataOrThrow<long>();
+
+            var len = Length;
+            if (len <= 0)
+                return string.Empty;
+
+            string? str = null;
+
+            var arr = PInvoke_GetUtf8ContiguousArray(_payload);
+            PInvoke_WithUnsafeBytes(bytes =>
+                {
+                    unsafe
+                    {
+                        str = Encoding.UTF8.GetString((byte*)bytes, len);
+                        return IntPtr.Zero;
+                    }
+                }, IntPtr.Zero, arr, elementType, resultType);
+
+            return str!;
+        }
+    }
+
+    public unsafe delegate IntPtr CallbackDelegate(IntPtr param);
+
+    [UnmanagedCallConv(CallConvs = new Type[] { typeof(CallConvSwift) })]
+    [DllImport(KnownLibraries.SwiftCore, EntryPoint = "$sSSMa")]
+    public static extern TypeMetadata PInvoke_getMetadata();
+
+    [UnmanagedCallConv(CallConvs = new Type[] { typeof(CallConvSwift) })]
+    [DllImport(KnownLibraries.SwiftCore, CharSet = CharSet.Unicode, EntryPoint = "$sSS21_builtinStringLiteral17utf8CodeUnitCount7isASCIISSBp_BwBi1_tcfC")]
+    public static unsafe extern Data PInvoke_Create(byte* str, long len, byte flag);
+
+    [UnmanagedCallConv(CallConvs = new Type[] { typeof(CallConvSwift) })]
+    [DllImport(KnownLibraries.SwiftCore, EntryPoint = "$sSS5countSivg")]
+    public static extern long PInvoke_GetLength(Data str);
+
+    // https://developer.apple.com/documentation/swift/string/utf8cstring
+    [UnmanagedCallConv(CallConvs = new Type[] { typeof(CallConvSwift) })]
+    [DllImport(KnownLibraries.SwiftCore, EntryPoint = "$sSS11utf8CStrings15ContiguousArrayVys4Int8VGvg")]
+    public static unsafe extern IntPtr PInvoke_GetUtf8ContiguousArray(Data str);
+
+    // https://developer.apple.com/documentation/swift/contiguousarray/withunsafebytes(_:)
+    [UnmanagedCallConv(CallConvs = new Type[] { typeof(CallConvSwift) })]
+    [DllImport(KnownLibraries.SwiftCore, EntryPoint = "$ss15ContiguousArrayV15withUnsafeBytesyqd__qd__SWKXEKlF")]
+    public static extern unsafe IntPtr PInvoke_WithUnsafeBytes(CallbackDelegate callback, IntPtr context, IntPtr contiguousArray, TypeMetadata elementType, TypeMetadata resultType);
+}

src/Swift.Runtime/tests/LibraryTests/SwiftArrayTests.cs

@@ -138,7 +138,7 @@ public unsafe void ArrayDispose()
         Arc.Release(payload);
     }
 
-    private static void PrimitiveArrayTest<T>(T value1, T value2, T overwriteValue) where T : unmanaged
+    private static void PrimitiveArrayTest<T>(T value1, T value2, T overwriteValue)
     {
         var metadata = TypeMetadata.GetTypeMetadataOrThrow<SwiftArray<T>>();
         Assert.True(metadata.Size > 0);
@@ -181,4 +181,5 @@ private static void PrimitiveArrayTest<T>(T value1, T value2, T overwriteValue)
     [Fact] public void ArrayTestFloat() => PrimitiveArrayTest<float>(4.2f, 1.7f, 10.0f);
     [Fact] public void ArrayTestDouble() => PrimitiveArrayTest<double>(4.2, 1.7, 10.0);
     [Fact] public void ArrayTestBool() => PrimitiveArrayTest<bool>(true, false, true);
+    [Fact] public void ArrayTestString() => PrimitiveArrayTest<SwiftString>(new SwiftString("Hello"), new SwiftString("World"), new SwiftString("String"));
 }

src/Swift.Runtime/tests/LibraryTests/SwiftStringTests.cs

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+using Swift;
+using Swift.Runtime;
+using Xunit;
+
+namespace BindingsGeneration.Tests;
+
+public class SwiftStringTests : IClassFixture<SwiftStringTests.TestFixture>
+{
+    private readonly TestFixture _fixture;
+
+    public SwiftStringTests(TestFixture fixture)
+    {
+        _fixture = fixture;
+    }
+
+    public class TestFixture
+    {
+        static TestFixture()
+        {
+        }
+
+        private static void InitializeResources()
+        {
+        }
+    }
+
+    [Fact]
+    static void SmokeTest()
+    {
+        var metadata = TypeMetadata.GetTypeMetadataOrThrow<SwiftString>();
+        // sizeof(Data)
+        Assert.Equal((nuint)16, metadata.Size);
+
+        var str = new SwiftString();
+        Assert.Equal(0, str.Length);
+
+        string text = "Hello world!";
+        str = new SwiftString(text);
+
+        Assert.Equal(text.Length, str.Length);
+        Assert.Equal(text, str.ToString());
+    }
+}