@nativescript/windows 0.1.0-alpha.17 → 0.1.0-alpha.19

package/framework/dotnet-bridge/Bridge.JsDelegate.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Buffers;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace NativeScriptBridge;
+
+public static partial class Bridge
+{
+    // ── JS delegate creation ──────────────────────────────────────────────────
+    //
+    // opcode 0x09: given a delegate type name (or "" for System.Action) and a
+    // JS callback id, compile a .NET delegate that serialises its parameters as
+    // binary and calls back into V8 via the s_jsInvoker function pointer.
+
+    private static DispatchResult CreateJsDelegate(string typeName, int callbackId)
+    {
+        var delegateType = string.IsNullOrEmpty(typeName)
+            ? typeof(Action)
+            : ResolveType(null, typeName)
+              ?? throw new TypeLoadException($"Delegate type not found: {typeName}");
+
+        var invokeMethod = delegateType.GetMethod("Invoke")
+            ?? throw new MissingMethodException($"No Invoke method on {delegateType}");
+
+        var parameters  = invokeMethod.GetParameters();
+        var returnType  = invokeMethod.ReturnType;
+
+        var paramExprs = parameters
+            .Select((p, i) => Expression.Parameter(p.ParameterType, p.Name ?? $"p{i}"))
+            .ToArray();
+
+        // object?[] args = new object?[] { (object?)p0, (object?)p1, … }
+        var objArgs   = paramExprs.Select(p => (Expression)Expression.Convert(p, typeof(object)));
+        var argsArray = Expression.NewArrayInit(typeof(object), objArgs);
+
+        var callMethod = typeof(Bridge).GetMethod(
+            nameof(CallJsCallback),
+            BindingFlags.Static | BindingFlags.NonPublic)!;
+
+        var callExpr = Expression.Call(callMethod, Expression.Constant(callbackId), argsArray);
+
+        Expression body = returnType == typeof(void)
+            ? callExpr
+            : (Expression)Expression.Block(returnType, callExpr, Expression.Default(returnType));
+
+        var del = Expression.Lambda(delegateType, body, paramExprs).Compile();
+        return Box(del);
+    }
+
+    // ── Callback invocation helper ────────────────────────────────────────────
+
+    internal static unsafe void CallJsCallback(int id, object?[] args)
+    {
+        if (s_jsInvoker == null) return;
+
+        var buf = new ArrayBufferWriter<byte>(64);
+        var w   = new BinWriter(buf);
+        w.WriteByte((byte)Math.Min(args.Length, 255));
+        foreach (var arg in args)
+            WriteCallbackArg(ref w, arg);
+
+        var bytes   = buf.WrittenSpan;
+        byte* respPtr = null;
+        int   respLen = 0;
+        fixed (byte* p = bytes)
+            s_jsInvoker(id, p, bytes.Length, &respPtr, &respLen);
+
+        // Response is only set for non-void delegates; free it when present.
+        if (respPtr != null && respLen > 0)
+            Marshal.FreeHGlobal((IntPtr)respPtr);
+    }
+
+    // Serialises a single delegate argument in response-binary tag format so
+    // the Rust side can reuse its existing bin_read_value parser.
+    private static void WriteCallbackArg(ref BinWriter w, object? arg)
+    {
+        if (arg is null)    { w.WriteByte(0x00); return; }
+        if (arg is bool b)  { w.WriteByte(b ? (byte)0x02 : (byte)0x01); return; }
+        if (arg is int  i)  { w.WriteByte(0x03); w.WriteI32(i); return; }
+        if (arg is uint u)  { w.WriteByte(0x03); w.WriteI32((int)u); return; }
+        if (arg is long l)  { w.WriteByte(0x04); w.WriteF64((double)l); return; }
+        if (arg is float f) { w.WriteByte(0x04); w.WriteF64((double)f); return; }
+        if (arg is double d){ w.WriteByte(0x04); w.WriteF64(d); return; }
+        if (arg is string s){ w.WriteByte(0x05); w.WriteString32(s); return; }
+
+        // Object: box in the handle map and send as a handle reference.
+        // The JS side receives {__handle, __type} which can be turned into a
+        // proxy via NSWinRT.dotnet.fromHandle(...).
+        var handleId = Interlocked.Increment(ref s_nextHandle);
+        s_handles[handleId] = arg;
+        var typeName = arg.GetType().FullName ?? arg.GetType().Name;
+        w.WriteByte(0x06);
+        w.WriteI32(handleId);
+        w.WriteString16(typeName); // u16 length prefix (matches bin_read_value tag 0x06)
+    }
+}

package/framework/dotnet-bridge/Bridge.cs

@@ -1,353 +1,77 @@
 using System;
-using System.Collections;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Text.Json;
-using System.Text.Json.Nodes;
-using System.Threading;
-using System.Threading.Tasks;
+
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("DotNetBridgeTests")]
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("DotNetBridgeBenchmarks")]
 
 namespace NativeScriptBridge;
 
-/// <summary>
-/// Reflection-based .NET dispatch bridge — UTF-8 ABI edition.
-///
-/// Invoke() receives a UTF-8 byte slice (no string allocation on the Rust side),
-/// dispatches via reflection, and serialises the response directly to a UTF-8
-/// byte array via JsonSerializer.SerializeToUtf8Bytes().  This removes the
-/// UTF-16 encode/decode round-trip of the original char* ABI.
-///
-/// Request JSON schema
-/// -------------------
-///   Static call:    { "assembly": "System", "typeName": "System.Diagnostics.Stopwatch", "method": "StartNew", "args": [] }
-///   Constructor:    { "assembly": "System", "typeName": "System.Text.StringBuilder",    "method": ".ctor",    "args": [128] }
-///   Instance call:  { "handle": 3, "method": "Stop",          "args": [] }
-///   Property get:   { "assembly": "...", "typeName": "...",   "method": "get_Now",      "args": [] }
-///   Property set:   { "handle": 3, "method": "set_IsEnabled", "args": [true] }
-///   Release:        { "handle": 3, "method": "__release",     "args": [] }
-///
-/// Response JSON schema
-/// --------------------
-///   Primitive / string:   { "result": 42.5 }
-///   Managed object:       { "result": { "__handle": 7, "__type": "System.Diagnostics.Stopwatch" } }
-///   Array / enumerable:   { "result": [1, 2, 3] }
-///   Error:                { "error": "Method not found" }
-/// </summary>
-public static class Bridge
+public static partial class Bridge
 {
-    private static readonly ConcurrentDictionary<int, object?> s_handles = new();
-    private static int s_nextHandle;
+    internal static readonly ConcurrentDictionary<int, object?> s_handles = new();
+    internal static int s_nextHandle;
+
+    // Function pointer registered by the Rust runtime so managed delegates can
+    // call back into V8 without a JSON round-trip.
+    internal static unsafe delegate* unmanaged[Cdecl]<int, byte*, int, byte**, int*, void>
+        s_jsInvoker;
+
+    private static readonly ConcurrentDictionary<string, Type?> s_typeCache
+        = new(StringComparer.Ordinal);
+    private static readonly ConcurrentDictionary<MethodKey, DispatchEntry> s_methodCache = new();
+    private static readonly ConcurrentDictionary<PropKey, PropertyInfo?> s_propCache = new();
+    private static readonly ConcurrentDictionary<CtorKey, CtorEntry> s_ctorCache = new();
+
+    private static readonly JsonSerializerOptions s_coerceOpts = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+    };
 
-    private static readonly ConcurrentDictionary<string, Type?> s_typeCache = new();
-    private static readonly ConcurrentDictionary<string, MethodInfo?> s_methodCache = new();
-    private static readonly ConcurrentDictionary<string, PropertyInfo?> s_propertyCache = new();
+    internal static void ClearCaches()
+    {
+        s_typeCache.Clear();
+        s_methodCache.Clear();
+        s_propCache.Clear();
+        s_ctorCache.Clear();
+        s_handles.Clear();
+        s_nextHandle = 0;
+    }
 
-    // ── exported entry points ────────────────────────────────────────────────
+    [UnmanagedCallersOnly(EntryPoint = "RegisterJsCallback",
+        CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
+    public static unsafe int RegisterJsCallback(
+        delegate* unmanaged[Cdecl]<int, byte*, int, byte**, int*, void> callback)
+    {
+        s_jsInvoker = callback;
+        return 0;
+    }
 
-    /// Called by the Rust runtime.  Request arrives as a raw UTF-8 byte slice;
-    /// response is written as a UTF-8 byte buffer allocated with Marshal.AllocHGlobal.
     [UnmanagedCallersOnly(EntryPoint = "Invoke",
         CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
     public static unsafe int Invoke(
         byte* requestPtr, int requestLen,
         byte** responsePtr, int* responseLenPtr)
     {
-        byte[] responseBytes;
         try
         {
-            var requestSpan = new ReadOnlySpan<byte>(requestPtr, requestLen);
-            var req = JsonSerializer.Deserialize<InvokeRequest>(requestSpan, JsonOptions.Default)!;
-            var result = Dispatch(req);
-            responseBytes = JsonSerializer.SerializeToUtf8Bytes(result, JsonOptions.Default);
+            var span = new ReadOnlySpan<byte>(requestPtr, requestLen);
+            var req  = JsonSerializer.Deserialize(span, BridgeJsonContext.Default.InvokeRequest)!;
+            WriteResult(Dispatch(req), responsePtr, responseLenPtr);
         }
         catch (Exception ex)
         {
-            var errResult = new InvokeResult(null, Unwrap(ex).Message);
-            responseBytes = JsonSerializer.SerializeToUtf8Bytes(errResult, JsonOptions.Default);
+            WriteError(Unwrap(ex).Message, responsePtr, responseLenPtr);
         }
-
-        WriteResponse(responseBytes, responsePtr, responseLenPtr);
         return 0;
     }
 
-    /// Frees the response buffer allocated by Invoke.
     [UnmanagedCallersOnly(EntryPoint = "Free",
         CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
     public static unsafe void Free(byte* ptr)
     {
-        if (ptr != null)
-            Marshal.FreeHGlobal((IntPtr)ptr);
-    }
-
-    // ── dispatch ─────────────────────────────────────────────────────────────
-
-    private static InvokeResult Dispatch(InvokeRequest req)
-    {
-        if (req.Method == "__release" && req.Handle.HasValue)
-        {
-            s_handles.TryRemove(req.Handle.Value, out _);
-            return new InvokeResult(null, null);
-        }
-
-        // Return reflection metadata so JS can distinguish methods from properties.
-        if (req.Method == "__members__")
-        {
-            var t = req.Handle.HasValue
-                ? (s_handles.TryGetValue(req.Handle.Value, out var h) ? h?.GetType() : null)
-                : ResolveType(req.Assembly, req.TypeName);
-            if (t is null) return new InvokeResult(null, $"Type not found: {req.TypeName}");
-            var inst   = BindingFlags.Public | BindingFlags.Instance;
-            var stat   = BindingFlags.Public | BindingFlags.Static;
-            var members = new
-            {
-                methods          = t.GetMethods(inst).Where(m => !m.IsSpecialName).Select(m => m.Name).Distinct().ToArray(),
-                properties       = t.GetProperties(inst).Select(p => p.Name).Distinct().ToArray(),
-                staticMethods    = t.GetMethods(stat).Where(m => !m.IsSpecialName).Select(m => m.Name).Distinct().ToArray(),
-                staticProperties = t.GetProperties(stat).Select(p => p.Name).Distinct().ToArray(),
-            };
-            return new InvokeResult(JsonSerializer.SerializeToElement(members, JsonOptions.Default), null);
-        }
-
-        object? target = null;
-        Type? type = null;
-
-        if (req.Handle.HasValue)
-        {
-            if (!s_handles.TryGetValue(req.Handle.Value, out target))
-                return new InvokeResult(null, $"Invalid handle {req.Handle.Value}");
-            type = target?.GetType();
-        }
-        else
-        {
-            type = ResolveType(req.Assembly, req.TypeName);
-            if (type is null)
-                return new InvokeResult(null, $"Type not found: {req.TypeName}");
-        }
-
-        if (type is null)
-            return new InvokeResult(null, "Cannot determine target type");
-
-        var method = req.Method ?? throw new ArgumentException("Method is required");
-
-        // ── Constructor ──────────────────────────────────────────────────────
-        if (method == ".ctor")
-        {
-            var argElements = req.Args ?? [];
-            var ctors = type.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
-            var ctor = ctors.FirstOrDefault(c => c.GetParameters().Length == argElements.Count)
-                    ?? ctors.FirstOrDefault();
-            if (ctor is null)
-                return new InvokeResult(null, $"No public constructor found on {type.FullName}");
-            var pars = ctor.GetParameters();
-            var ctorArgs = new object?[pars.Length];
-            for (int i = 0; i < pars.Length && i < argElements.Count; i++)
-                ctorArgs[i] = Coerce(argElements[i], pars[i].ParameterType);
-            return Box(ctor.Invoke(ctorArgs));
-        }
-
-        var isStatic = target is null;
-        var flags = (isStatic ? BindingFlags.Static : BindingFlags.Instance)
-                  | BindingFlags.Public;
-
-        // ── Property getter / setter ─────────────────────────────────────────
-        if (method.StartsWith("get_", StringComparison.Ordinal))
-        {
-            var prop = GetCachedProperty(type, method[4..], flags);
-            if (prop is not null)
-                return Box(prop.GetValue(target));
-        }
-        if (method.StartsWith("set_", StringComparison.Ordinal) && req.Args?.Count == 1)
-        {
-            var prop = GetCachedProperty(type, method[4..], flags);
-            if (prop is not null)
-            {
-                prop.SetValue(target, Coerce(req.Args[0], prop.PropertyType));
-                return new InvokeResult(null, null);
-            }
-        }
-
-        // ── Regular method ───────────────────────────────────────────────────
-        var argElems = req.Args ?? [];
-        var mi = FindMethod(type, method, argElems.Count, flags);
-        if (mi is null)
-            return new InvokeResult(null,
-                $"Method '{method}' ({argElems.Count} args) not found on {type.FullName}");
-
-        var parameters = mi.GetParameters();
-        var callArgs = new object?[parameters.Length];
-        for (int i = 0; i < parameters.Length && i < argElems.Count; i++)
-            callArgs[i] = Coerce(argElems[i], parameters[i].ParameterType);
-
-        return Box(AwaitIfTask(mi.Invoke(target, callArgs)));
-    }
-
-    // ── helpers ───────────────────────────────────────────────────────────────
-
-    private static object? AwaitIfTask(object? value)
-    {
-        if (value is null) return null;
-        var t = value.GetType();
-
-        if (value is Task task)
-        {
-            task.Wait();
-            if (task.IsFaulted)
-                throw task.Exception!.InnerException ?? task.Exception;
-            return t.GetProperty("Result")?.GetValue(value);
-        }
-
-        if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(ValueTask<>))
-        {
-            var innerTask = (Task)t.GetMethod("AsTask")!.Invoke(value, null)!;
-            innerTask.Wait();
-            if (innerTask.IsFaulted)
-                throw innerTask.Exception!.InnerException ?? innerTask.Exception;
-            return innerTask.GetType().GetProperty("Result")?.GetValue(innerTask);
-        }
-
-        if (value is System.Threading.Tasks.ValueTask vt)
-        {
-            vt.AsTask().Wait();
-            return null;
-        }
-
-        return value;
-    }
-
-    private static Type? ResolveType(string? assemblyName, string? typeName)
-    {
-        if (string.IsNullOrEmpty(typeName)) return null;
-        var key = string.IsNullOrEmpty(assemblyName) ? typeName : $"{assemblyName}|{typeName}";
-        return s_typeCache.GetOrAdd(key, _ => ResolveTypeCore(assemblyName, typeName));
-    }
-
-    private static Type? ResolveTypeCore(string? assemblyName, string? typeName)
-    {
-        var fqn = string.IsNullOrEmpty(assemblyName) ? typeName! : $"{typeName}, {assemblyName}";
-        var t = Type.GetType(fqn);
-        if (t is not null) return t;
-
-        foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
-        {
-            t = asm.GetType(typeName!);
-            if (t is not null) return t;
-        }
-
-        if (!string.IsNullOrEmpty(assemblyName))
-        {
-            try
-            {
-                var asm = Assembly.Load(assemblyName);
-                t = asm.GetType(typeName!);
-                if (t is not null) return t;
-            }
-            catch { }
-        }
-
-        return null;
-    }
-
-    private static MethodInfo? FindMethod(Type type, string name, int argCount, BindingFlags flags)
-    {
-        var key = $"{type.FullName}|{name}|{argCount}|{(int)flags}";
-        return s_methodCache.GetOrAdd(key, _ => FindMethodCore(type, name, argCount, flags));
-    }
-
-    private static MethodInfo? FindMethodCore(Type type, string name, int argCount, BindingFlags flags)
-    {
-        var match = Array.Find(
-            type.GetMethods(flags),
-            m => m.Name == name && !m.IsGenericMethod && m.GetParameters().Length == argCount);
-        if (match is not null) return match;
-        return type.GetMethod(name, flags);
-    }
-
-    private static PropertyInfo? GetCachedProperty(Type type, string name, BindingFlags flags)
-    {
-        var key = $"{type.FullName}|{name}|{(int)flags}";
-        return s_propertyCache.GetOrAdd(key, _ => type.GetProperty(name, flags));
-    }
-
-    private static object? Coerce(JsonElement el, Type targetType)
-    {
-        if (el.ValueKind == JsonValueKind.Null) return null;
-        if (el.ValueKind == JsonValueKind.Object && el.TryGetProperty("__handle", out var h))
-        {
-            s_handles.TryGetValue(h.GetInt32(), out var obj);
-            return obj;
-        }
-        return JsonSerializer.Deserialize(el.GetRawText(), targetType, JsonOptions.Default);
-    }
-
-    private static InvokeResult Box(object? value)
-    {
-        if (value is null) return new InvokeResult(null, null);
-
-        var t = value.GetType();
-
-        if (t.IsPrimitive || t == typeof(string) || t == typeof(decimal)
-            || t == typeof(DateTime) || t == typeof(DateTimeOffset)
-            || t == typeof(TimeSpan) || t == typeof(Guid))
-        {
-            return new InvokeResult(
-                JsonSerializer.SerializeToElement(value, t, JsonOptions.Default), null);
-        }
-
-        // Arrays and IEnumerable — serialise as JSON arrays.
-        if (t.IsArray || (t != typeof(string) && value is IEnumerable enumerable))
-        {
-            try
-            {
-                var list = new List<object?>();
-                foreach (var item in (IEnumerable)value) list.Add(item);
-                return new InvokeResult(
-                    JsonSerializer.SerializeToElement(list, typeof(List<object?>), JsonOptions.Default),
-                    null);
-            }
-            catch { }
-        }
-
-        var id = Interlocked.Increment(ref s_nextHandle);
-        s_handles[id] = value;
-        return new InvokeResult(
-            JsonSerializer.SerializeToElement(
-                new { __handle = id, __type = t.FullName }, JsonOptions.Default),
-            null);
+        if (ptr != null) Marshal.FreeHGlobal((IntPtr)ptr);
     }
-
-    private static Exception Unwrap(Exception ex) =>
-        ex is TargetInvocationException { InnerException: { } inner } ? Unwrap(inner) : ex;
-
-    private static unsafe void WriteResponse(byte[] json, byte** responsePtr, int* responseLenPtr)
-    {
-        var ptr = (byte*)Marshal.AllocHGlobal(json.Length + 1);
-        Marshal.Copy(json, 0, (IntPtr)ptr, json.Length);
-        ptr[json.Length] = 0;
-        *responsePtr = ptr;
-        *responseLenPtr = json.Length;
-    }
-}
-
-// ── JSON types ────────────────────────────────────────────────────────────────
-
-internal sealed record InvokeRequest(
-    string? Assembly,
-    string? TypeName,
-    string? Method,
-    int? Handle,
-    List<JsonElement>? Args
-);
-
-internal sealed record InvokeResult(JsonElement? Result, string? Error);
-
-internal static class JsonOptions
-{
-    internal static readonly JsonSerializerOptions Default = new()
-    {
-        PropertyNameCaseInsensitive = true,
-        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
-    };
 }