Fix assembly resolution so host apps no longer need manual pre-loading

classForName's DependencyContext heuristic had three gaps that prevented
type resolution for NuGet/framework assemblies not yet loaded by the CLR:

1. Namespace-to-assembly guessing did a single dictionary lookup and gave
   up. Now walks up the namespace hierarchy (e.g. Microsoft.AspNetCore.Builder
   -> Microsoft.AspNetCore -> Microsoft) until a match is found.

2. DependencyContext entries stored empty paths, making Assembly.LoadFrom
   impossible. Now resolves DLL filenames against AppContext.BaseDirectory.

3. The AssemblyResolve handler only checked embedded resources. Now also
   consults the runtime assembly dictionary and probes the base directory,
   with a ThreadStatic recursion guard to prevent infinite loops.

Includes 4 new tests: namespace walk-up resolution, runtime assembly path
verification, counter validation, and graceful failure on unknown types.

Author: Dangercoder

Clojure/Clojure/Lib/RT.cs

@@ -348,19 +348,50 @@ public override object invoke(object arg1)
 
         #region Initialization
 
+        [ThreadStatic]
+        static bool _isResolving;
+
         static Assembly ResolveAssembly(object sender, ResolveEventArgs args)
         {
-            AssemblyName asmName = new(args.Name);
-            var name = asmName.Name;
-            var stream = GetEmbeddedResourceStream(name, out _);
-            if (stream == null)
+            if (_isResolving)
+                return null;
+
+            _isResolving = true;
+            try
             {
-                name += ".dll";
-                stream = GetEmbeddedResourceStream(name, out _);
+                AssemblyName asmName = new(args.Name);
+                var name = asmName.Name;
+
+                // 1. Embedded resources (existing behavior)
+                var stream = GetEmbeddedResourceStream(name, out _);
                 if (stream == null)
-                    return null;
+                    stream = GetEmbeddedResourceStream(name + ".dll", out _);
+                if (stream != null)
+                    return Assembly.Load(ReadStreamBytes(stream));
+
+                // 2. Check _runtimeAssemblyNames (DependencyContext + TRUSTED_PLATFORM_ASSEMBLIES)
+                var runtimeNames = _runtimeAssemblyNames.Value;
+                if (runtimeNames.TryGetValue(asmName, out var runtimePath)
+                    && !string.IsNullOrWhiteSpace(runtimePath))
+                {
+                    try { return Assembly.LoadFrom(runtimePath); }
+                    catch { /* Assembly may be corrupt or version-mismatched; fall through */ }
+                }
+
+                // 3. Probe the app's base directory
+                var probePath = Path.Combine(AppContext.BaseDirectory, name + ".dll");
+                if (File.Exists(probePath))
+                {
+                    try { return Assembly.LoadFrom(probePath); }
+                    catch { /* File exists but isn't loadable; give up */ }
+                }
+
+                return null;
+            }
+            finally
+            {
+                _isResolving = false;
             }
-            return Assembly.Load(ReadStreamBytes(stream));
         }
 
 #if MONO
@@ -2797,8 +2828,15 @@ public int GetHashCode(AssemblyName obj)
                         {
                             try
                             {
-                                var name = new AssemblyName(Path.GetFileNameWithoutExtension(assembly));
-                                names[name] = string.Empty;
+                                var asmName = new AssemblyName(Path.GetFileNameWithoutExtension(assembly));
+
+                                // Resolve to actual file path so Assembly.LoadFrom works later.
+                                // Published apps copy all dependency DLLs to the base directory.
+                                var fullPath = Path.Combine(AppContext.BaseDirectory, Path.GetFileName(assembly));
+                                if (File.Exists(fullPath))
+                                    names[asmName] = fullPath;
+                                else if (!names.ContainsKey(asmName))
+                                    names[asmName] = string.Empty;  // fallback: Assembly.Load will be tried
                             }
                             catch { }
                         }
@@ -2877,6 +2915,9 @@ internal static Type classForName(string p, Namespace ns, bool canCallClrTypeSpe
             // Search through currently loaded assemblies.
             AppDomain domain = AppDomain.CurrentDomain;
             Assembly[] loadedAssemblies = domain.GetAssemblies();
+            var loadedAssemblyNames = new HashSet<string>(
+                loadedAssemblies.Select(a => a.GetName().Name),
+                StringComparer.OrdinalIgnoreCase);
 
             // Search by namespace-qualified name in loaded assemblies.
             foreach (Assembly assy in loadedAssemblies)
@@ -2920,34 +2961,44 @@ internal static Type classForName(string p, Namespace ns, bool canCallClrTypeSpe
                 {
                     var runtimeAssemblyNames = _runtimeAssemblyNames.Value;
 
-                    try
+                    // Try the full namespace as assembly name, then walk up the hierarchy.
+                    // e.g., "Microsoft.AspNetCore.Builder" -> "Microsoft.AspNetCore" -> "Microsoft"
+                    string probe = assemblyNameString;
+                    while (probe != null)
                     {
-                        var targetAssemblyName = new AssemblyName(assemblyNameString);
-
-                        // try if the namespace directly matches the assembly name.
-                        if (runtimeAssemblyNames.TryGetValue(targetAssemblyName, out var path))
+                        try
                         {
+                            var targetAssemblyName = new AssemblyName(probe);
 
-                            if (loadedAssemblies.Any(a => a.GetName().Name.Equals(assemblyNameString, StringComparison.OrdinalIgnoreCase)))
-                            {
-                                // Skip if this assembly is already loaded.
-                            }
-                            else
+                            if (runtimeAssemblyNames.TryGetValue(targetAssemblyName, out var path))
                             {
-                                NumRuntimeAssemblyLoads++;
-                                var assy = string.IsNullOrWhiteSpace(path) ? Assembly.Load(targetAssemblyName) : Assembly.LoadFrom(path);
-                                var type = assy.GetType(p, false);
-                                if (type != null)
+                                if (loadedAssemblyNames.Contains(probe))
                                 {
-                                    NumRuntimeAssemblyFinds++;
-                                    return type;
+                                    // Already loaded; earlier scan didn't find type. Keep walking.
+                                }
+                                else
+                                {
+                                    NumRuntimeAssemblyLoads++;
+                                    var assy = string.IsNullOrWhiteSpace(path)
+                                        ? Assembly.Load(targetAssemblyName)
+                                        : Assembly.LoadFrom(path);
+                                    var type = assy.GetType(p, false);
+                                    if (type != null)
+                                    {
+                                        NumRuntimeAssemblyFinds++;
+                                        return type;
+                                    }
+                                    // Assembly loaded but type not found. Continue walking up.
                                 }
                             }
                         }
-                    }
-                    catch
-                    {
-                        // Ignore failures to load assembly.
+                        catch
+                        {
+                            // Ignore failures to load this particular assembly. Keep trying.
+                        }
+
+                        int lastDot = probe.LastIndexOf('.');
+                        probe = lastDot > 0 ? probe.Substring(0, lastDot) : null;
                     }
                 }
             }

Clojure/Csharp.Tests/SharedAssemblyLoadingTests.cs

@@ -1,6 +1,8 @@
 using clojure.lang;
 using NUnit.Framework;
 using System;
+using System.Collections.Generic;
+using System.Reflection;
 
 namespace Csharp.Tests;
 
@@ -102,4 +104,69 @@ public void TestCanLoadNuGetPackageTypes()
             "Should be able to load types from NuGet packages");
 
     }
+
+    [Test]
+    public void TestNamespaceWalkUpResolvesType()
+    {
+        // System.Text.Json.Serialization.JsonConverter lives in assembly System.Text.Json,
+        // not System.Text.Json.Serialization. The namespace walk-up should find it by
+        // stripping "Serialization" and trying "System.Text.Json".
+        var type = RT.classForName("System.Text.Json.Serialization.JsonConverter");
+
+        Assert.That(type, Is.Not.Null,
+            "Should resolve type via namespace hierarchy walk-up when assembly name != namespace");
+        Assert.That(type.Assembly.GetName().Name, Is.EqualTo("System.Text.Json"));
+    }
+
+    [Test]
+    public void TestRuntimeAssemblyNamesHavePaths()
+    {
+        // Access _runtimeAssemblyNames via reflection to verify DependencyContext
+        // entries have been resolved to actual file paths where possible.
+        var field = typeof(RT).GetField("_runtimeAssemblyNames",
+            BindingFlags.NonPublic | BindingFlags.Static);
+        Assert.That(field, Is.Not.Null, "_runtimeAssemblyNames field should exist");
+
+        var lazy = field.GetValue(null);
+        var dict = (Dictionary<AssemblyName, string>)lazy.GetType().GetProperty("Value").GetValue(lazy);
+
+        // TPA entries should always have non-empty paths
+        int withPaths = 0;
+        foreach (var kvp in dict)
+        {
+            if (!string.IsNullOrWhiteSpace(kvp.Value))
+                withPaths++;
+        }
+
+        Assert.That(withPaths, Is.GreaterThan(0),
+            "At least some runtime assembly entries should have resolved file paths");
+    }
+
+    [Test]
+    public void TestClassForNameCountersIncrement()
+    {
+        // Reset counters
+        int failsBefore = RT.NumFails;
+
+        // Load a type that requires runtime assembly resolution
+        var type = RT.classForName("System.Text.Json.JsonSerializer");
+        Assert.That(type, Is.Not.Null);
+
+        // The type should have been found (via loaded assemblies or runtime resolution)
+        // We just verify no new failures were recorded for this lookup
+        Assert.That(RT.NumFails, Is.EqualTo(failsBefore),
+            "Loading a valid type should not increment NumFails");
+    }
+
+    [Test]
+    public void TestClassForNameReturnsNullForBogusType()
+    {
+        int failsBefore = RT.NumFails;
+
+        var type = RT.classForName("This.Type.Does.Not.Exist.Anywhere");
+
+        Assert.That(type, Is.Null, "Bogus type name should return null");
+        Assert.That(RT.NumFails, Is.GreaterThan(failsBefore),
+            "Failed lookup should increment NumFails");
+    }
 }