Span & ArraySegment as MemoryView (#76)

#60 

- [x] Implement Span codegen
- [x] Implement ArraySegment codegen
- [x] Add CS generator tests
- [x] Add CS jsobject extension generator tests
- [x] Add TS Proxy generator tests
- [x] Add TS Initializer generator tests
- [x] Add TS Snapshot generator tests
- [x] Add e2e tests for span return
- [x] Add e2e tests for span param
- [x] Add e2e tests for arraysegment return
- [x] Add e2e tests for arraysegment param
- [x] Add e2e tests with initializer
- [x] Add e2e tests with snapshots
- [x] Implement diagnostics for unsupported type args

Author: ArcadeMode

README.md

@@ -276,7 +276,7 @@ Passing an initializer object in another initializer object.
 
 TypeShim enriches the supported types by JSExport by adding _your_ classes to the [types marshalled by .NET](https://learn.microsoft.com/en-us/aspnet/core/client-side/dotnet-interop/?view=aspnetcore-10.0#type-mappings). Repetitive patterns for type transformation are readily supported and tested in TypeShim.
 
-Of course, TypeShim brings all [types marshalled by .NET](https://learn.microsoft.com/en-us/aspnet/core/client-side/dotnet-interop/?view=aspnetcore-10.0#type-mappings) to TypeScript. This work is largely completed with the exception of Span and ArraySegment.
+Of course, TypeShim brings all [types marshalled by .NET](https://learn.microsoft.com/en-us/aspnet/core/client-side/dotnet-interop/?view=aspnetcore-10.0#type-mappings) to TypeScript. Makes TypeShim officially offer a superset of the .NET types available in JS.
 
 TypeShim aims to continue to broaden its type support. Suggestions and contributions are welcome.
 
@@ -312,12 +312,12 @@ TypeShim aims to continue to broaden its type support. Suggestions and contribut
 | `JSObject`           | `Object`    | ✅     | Requires manual JSObject handling |
 | `String`             | `String`    | ✅     |      |
 | `T[]`                | `T[]`       | ✅     | * [Only supported .NET types](https://learn.microsoft.com/en-us/aspnet/core/client-side/dotnet-interop/?view=aspnetcore-10.0#type-mappings) |
-| `Span<Byte>`         | `MemoryView`| 🚧     |      |
-| `Span<Int32>`        | `MemoryView`| 🚧     |      |
-| `Span<Double>`       | `MemoryView`| 🚧     |      |
-| `ArraySegment<Byte>` | `MemoryView`| 🚧     |      |
-| `ArraySegment<Int32>`| `MemoryView`| 🚧     |      |
-| `ArraySegment<Double>`| `MemoryView`| 🚧    |      |
+| `Span<Byte>`         | `MemoryView`| ✅     |      |
+| `Span<Int32>`        | `MemoryView`| ✅     |      |
+| `Span<Double>`       | `MemoryView`| ✅     |      |
+| `ArraySegment<Byte>` | `MemoryView`| ✅     |      |
+| `ArraySegment<Int32>`| `MemoryView`| ✅     |      |
+| `ArraySegment<Double>`| `MemoryView`| ✅    |      |
 | `Task`               | `Promise`   | ✅     | * [Only supported .NET types](https://learn.microsoft.com/en-us/aspnet/core/client-side/dotnet-interop/?view=aspnetcore-10.0#type-mappings) |
 | `Action`             | `Function`  | ✅     |      |
 | `Action<T1>`         | `Function`  | ✅     |      |

src/TypeShim.E2E/TypeShim.E2E.Wasm/ExportedClass.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.InteropServices.JavaScript;
 
 namespace TypeShim.E2E.Wasm;
 
@@ -12,3 +13,14 @@ public void Dispose()
         // no-op for testing purposes
     }
 }
+
+
+public partial class ManualExport
+{
+    [JSExport]
+    [return: JSMarshalAs<JSType.MemoryView>]
+    public static Span<int> GetSpan()
+    {
+        return new Span<int>(new int[] { 1, 2, 3 });
+    }
+}

src/TypeShim.E2E/TypeShim.E2E.Wasm/MemoryViewClass.cs

@@ -0,0 +1,86 @@
+using System;
+
+namespace TypeShim.E2E.Wasm;
+
+[TSExport]
+public class MemoryViewMethodClass
+{
+    public Span<byte> GetByteSpan() => new Span<byte>([1 << 0, 1 << 1, 1 << 2, 1 << 3, 1 << 4]);
+    public Span<int> GetInt32Span() => new Span<int>([0, 1, 2, 3, 4]);
+    public Span<double> GetDoubleSpan() => new Span<double>([0.1, 1.1, 2.1, 3.1, 4.1]);
+
+    public ArraySegment<byte> GetByteArraySegment() => new ArraySegment<byte>([1 << 0, 1 << 1, 1 << 2, 1 << 3, 1 << 4]);
+    public ArraySegment<int> GetInt32ArraySegment() => new ArraySegment<int>([0, 1, 2, 3, 4]);
+    public ArraySegment<double> GetDoubleArraySegment() => new ArraySegment<double>([0.1, 1.1, 2.1, 3.1, 4.1]);
+
+    public int SumByteSpan(Span<byte> span)
+    {
+        int sum = 0;
+        foreach (byte b in span)
+        {
+            sum += b;
+        }
+        return sum;
+    }
+
+    public int SumInt32Span(Span<int> span)
+    {
+        int sum = 0;
+        foreach (int i in span)
+        {
+            sum += i;
+        }
+        return sum;
+    }
+
+    public double SumDoubleSpan(Span<double> span)
+    {
+        double sum = 0;
+        foreach (double d in span)
+        {
+            sum += d;
+        }
+        return sum;
+    }
+
+    public int SumByteArraySegment(ArraySegment<byte> segment)
+    {
+        int sum = 0;
+        foreach (byte b in segment)
+        {
+            sum += b;
+        }
+        return sum;
+    }
+
+    public int SumInt32ArraySegment(ArraySegment<int> segment)
+    {
+        int sum = 0;
+        foreach (int i in segment)
+        {
+            sum += i;
+        }
+        return sum;
+    }
+
+    public double SumDoubleArraySegment(ArraySegment<double> segment)
+    {
+        double sum = 0;
+        foreach (double d in segment)
+        {
+            sum += d;
+        }
+        return sum;
+    }
+}
+
+[TSExport]
+public class MemoryViewPropertyClass
+{ 
+    public required ArraySegment<byte> ByteArraySegment { get; set; }
+    public required ArraySegment<int> Int32ArraySegment { get; set; }
+    public required ArraySegment<double> DoubleArraySegment { get; set; }
+
+    // span properties are not allowed in classes.
+}
+