@nativescript/windows 0.1.0-alpha.5 → 0.1.0-alpha.51

package/framework/dotnet-bridge/Bridge.cs

@@ -1,353 +1,211 @@
 using System;
-using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Runtime.Loader;
 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;
-
-    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();
-
-    // ── exported entry points ────────────────────────────────────────────────
-
-    /// 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)
+    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();
+    // Cache of attempted assembly loads (simple name -> Assembly or null if not found).
+    private static readonly ConcurrentDictionary<string, Assembly?> s_assemblyLoadCache
+        = new(StringComparer.OrdinalIgnoreCase);
+    // Directories to search for assemblies (initialized once in static ctor).
+    private static readonly string[] s_assemblySearchDirs;
+
+    private static readonly JsonSerializerOptions s_coerceOpts = new()
     {
-        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);
-        }
-        catch (Exception ex)
-        {
-            var errResult = new InvokeResult(null, Unwrap(ex).Message);
-            responseBytes = JsonSerializer.SerializeToUtf8Bytes(errResult, JsonOptions.Default);
-        }
-
-        WriteResponse(responseBytes, responsePtr, responseLenPtr);
-        return 0;
-    }
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+    };
 
-    /// Frees the response buffer allocated by Invoke.
-    [UnmanagedCallersOnly(EntryPoint = "Free",
-        CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
-    public static unsafe void Free(byte* ptr)
+    internal static void ClearCaches()
     {
-        if (ptr != null)
-            Marshal.FreeHGlobal((IntPtr)ptr);
+        s_typeCache.Clear();
+        s_methodCache.Clear();
+        s_propCache.Clear();
+        s_ctorCache.Clear();
+        s_handles.Clear();
+        s_nextHandle = 0;
     }
 
-    // ── dispatch ─────────────────────────────────────────────────────────────
-
-    private static InvokeResult Dispatch(InvokeRequest req)
+    // Returns a JSON object mapping top-level namespace roots (e.g. "NativeScript")
+    // to the assembly simple-name that most likely contains that namespace's types.
+    // This probes the application base directory and libs/ for assemblies and
+    // inspects exported types. The result is safe-to-call and tolerant of
+    // non-.NET DLLs.
+    public static string GetNamespaceAssemblyMapJson()
     {
-        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 map = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        try
         {
-            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
+            var baseDir = AppContext.BaseDirectory ?? AppDomain.CurrentDomain.BaseDirectory;
+            var dirs = new List<string> { baseDir };
+            var libs = Path.Combine(baseDir, "libs");
+            if (Directory.Exists(libs))
             {
-                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;
+                dirs.Add(libs);
+                try { dirs.AddRange(Directory.GetDirectories(libs, "*", SearchOption.AllDirectories)); } catch { }
+            }
 
-        // ── 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)
+            foreach (var dir in dirs.Where(d => !string.IsNullOrEmpty(d) && Directory.Exists(d)))
             {
-                prop.SetValue(target, Coerce(req.Args[0], prop.PropertyType));
-                return new InvokeResult(null, null);
+                try
+                {
+                    foreach (var file in Directory.EnumerateFiles(dir, "*.dll", SearchOption.TopDirectoryOnly))
+                    {
+                        try
+                        {
+                            var simple = Path.GetFileNameWithoutExtension(file);
+                            if (string.IsNullOrEmpty(simple)) continue;
+
+                            Assembly asm = AppDomain.CurrentDomain.GetAssemblies()
+                                .FirstOrDefault(a => string.Equals(a.GetName().Name, simple, StringComparison.OrdinalIgnoreCase));
+                            if (asm is null)
+                            {
+                                try { asm = AssemblyLoadContext.Default.LoadFromAssemblyPath(file); }
+                                catch { continue; }
+                            }
+
+                            Type[] types;
+                            try { types = asm.GetExportedTypes(); }
+                            catch { types = Array.Empty<Type>(); }
+
+                            foreach (var t in types)
+                            {
+                                if (string.IsNullOrEmpty(t.Namespace)) continue;
+                                var root = t.Namespace.Split('.')[0];
+                                if (!map.ContainsKey(root)) map[root] = asm.GetName().Name;
+                            }
+                        }
+                        catch { }
+                    }
+                }
+                catch { }
             }
         }
-
-        // ── 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)));
+        catch { }
+        try { return JsonSerializer.Serialize(map); } catch { return "{}"; }
     }
 
-    // ── helpers ───────────────────────────────────────────────────────────────
-
-    private static object? AwaitIfTask(object? value)
+    // Static ctor: initialize assembly search directories and register resolver.
+    static Bridge()
     {
-        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<>))
+        try
         {
-            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);
+            var baseDir = AppContext.BaseDirectory ?? AppDomain.CurrentDomain.BaseDirectory;
+            var dirs = new List<string> { baseDir };
+            var libs = Path.Combine(baseDir, "libs");
+            if (Directory.Exists(libs))
+            {
+                dirs.Add(libs);
+                try { dirs.AddRange(Directory.GetDirectories(libs, "*", SearchOption.AllDirectories)); } catch { }
+            }
+            s_assemblySearchDirs = dirs.Where(d => !string.IsNullOrEmpty(d)).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
+            AppDomain.CurrentDomain.AssemblyResolve += OnAssemblyResolve;
         }
-
-        if (value is System.Threading.Tasks.ValueTask vt)
+        catch
         {
-            vt.AsTask().Wait();
-            return null;
+            s_assemblySearchDirs = Array.Empty<string>();
         }
-
-        return value;
     }
 
-    private static Type? ResolveType(string? assemblyName, string? typeName)
+    private static Assembly? OnAssemblyResolve(object? sender, ResolveEventArgs args)
     {
-        if (string.IsNullOrEmpty(typeName)) return null;
-        var key = string.IsNullOrEmpty(assemblyName) ? typeName : $"{assemblyName}|{typeName}";
-        return s_typeCache.GetOrAdd(key, _ => ResolveTypeCore(assemblyName, typeName));
-    }
+        try
+        {
+            var requested = new AssemblyName(args.Name).Name;
+            if (string.IsNullOrEmpty(requested)) return null;
 
-    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;
+            if (s_assemblyLoadCache.TryGetValue(requested, out var cached)) return cached;
 
-        foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
-        {
-            t = asm.GetType(typeName!);
-            if (t is not null) return t;
-        }
+            // Check already-loaded assemblies first (avoid recursive Assembly.Load).
+            var loadedAsm = AppDomain.CurrentDomain.GetAssemblies()
+                .FirstOrDefault(a => string.Equals(a.GetName().Name, requested, StringComparison.OrdinalIgnoreCase));
+            if (loadedAsm is not null)
+            {
+                s_assemblyLoadCache[requested] = loadedAsm;
+                return loadedAsm;
+            }
 
-        if (!string.IsNullOrEmpty(assemblyName))
-        {
-            try
+            // Try to locate a matching dll in known search directories.
+            foreach (var dir in s_assemblySearchDirs)
             {
-                var asm = Assembly.Load(assemblyName);
-                t = asm.GetType(typeName!);
-                if (t is not null) return t;
+                try
+                {
+                    var candidate = Path.Combine(dir, requested + ".dll");
+                    if (File.Exists(candidate))
+                    {
+                        try
+                        {
+                            var asm = AssemblyLoadContext.Default.LoadFromAssemblyPath(candidate);
+                            s_assemblyLoadCache[requested] = asm;
+                            return asm;
+                        }
+                        catch { }
+                    }
+                }
+                catch { }
             }
-            catch { }
-        }
 
+            s_assemblyLoadCache[requested] = null;
+        }
+        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)
+    [UnmanagedCallersOnly(EntryPoint = "RegisterJsCallback",
+        CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
+    public static unsafe int RegisterJsCallback(
+        delegate* unmanaged[Cdecl]<int, byte*, int, byte**, int*, void> callback)
     {
-        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);
+        s_jsInvoker = callback;
+        return 0;
     }
 
-    private static InvokeResult Box(object? value)
+    [UnmanagedCallersOnly(EntryPoint = "Invoke",
+        CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
+    public static unsafe int Invoke(
+        byte* requestPtr, int requestLen,
+        byte** responsePtr, int* responseLenPtr)
     {
-        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))
+        try
         {
-            return new InvokeResult(
-                JsonSerializer.SerializeToElement(value, t, JsonOptions.Default), null);
+            var span = new ReadOnlySpan<byte>(requestPtr, requestLen);
+            var req  = JsonSerializer.Deserialize(span, BridgeJsonContext.Default.InvokeRequest)!;
+            WriteResult(Dispatch(req), responsePtr, responseLenPtr);
         }
-
-        // Arrays and IEnumerable — serialise as JSON arrays.
-        if (t.IsArray || (t != typeof(string) && value is IEnumerable enumerable))
+        catch (Exception ex)
         {
-            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 { }
+            WriteError(Unwrap(ex).Message, responsePtr, responseLenPtr);
         }
-
-        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);
+        return 0;
     }
 
-    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)
+    [UnmanagedCallersOnly(EntryPoint = "Free",
+        CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
+    public static unsafe void Free(byte* ptr)
     {
-        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;
+        if (ptr != null) Marshal.FreeHGlobal((IntPtr)ptr);
     }
 }
-
-// ── 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,
-    };
-}