Create a managed implementation of assembly binder

src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj

@@ -248,7 +248,7 @@
     <Compile Include="$(BclSourcesRoot)\System\ValueType.cs" />
     <Compile Include="$(CommonPath)System\Collections\Generic\ArrayBuilder.cs">
       <Link>Common\System\Collections\Generic\ArrayBuilder.cs</Link>
-    </Compile>    
+    </Compile>
   </ItemGroup>
   <ItemGroup Condition="'$(FeatureComWrappers)' == 'true'">
     <Compile Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComWrappers.cs" />
@@ -299,6 +299,17 @@
   <ItemGroup Condition="'$(FeatureObjCMarshal)' == 'true'">
     <Compile Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ObjectiveCMarshal.CoreCLR.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(FeatureManagedBinder)' == 'true'">
+    <Compile Include="$(BclSourcesRoot)\Internal\Runtime\Binder\ApplicationContext.cs" />
+    <Compile Include="$(BclSourcesRoot)\Internal\Runtime\Binder\Assembly.cs" />
+    <Compile Include="$(BclSourcesRoot)\Internal\Runtime\Binder\AssemblyBinder.cs" />
+    <Compile Include="$(BclSourcesRoot)\Internal\Runtime\Binder\AssemblyBinderCommon.cs" />
+    <Compile Include="$(BclSourcesRoot)\Internal\Runtime\Binder\AssemblyIdentity.cs" />
+    <Compile Include="$(BclSourcesRoot)\Internal\Runtime\Binder\AssemblyName.cs" />
+    <Compile Include="$(BclSourcesRoot)\Internal\Runtime\Binder\AssemblyVersion.cs" />
+    <Compile Include="$(BclSourcesRoot)\Internal\Runtime\Binder\BindResult.cs" />
+    <Compile Include="$(BclSourcesRoot)\Internal\Runtime\Binder\TextualIdentityParser.cs" />
+  </ItemGroup>
   <!-- Include additional sources shared files in the compilation -->
   <Import Project="$(LibrariesProjectRoot)\System.Private.CoreLib\src\System.Private.CoreLib.Shared.projitems" Label="Shared" />
 

src/coreclr/System.Private.CoreLib/src/Internal/Runtime/Binder/ApplicationContext.cs

@@ -0,0 +1,283 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
+
+namespace Internal.Runtime.Binder
+{
+    internal struct TPAEntry
+    {
+        public string? ILFileName;
+        public string? NIFileName;
+    }
+
+    internal record struct FailureCacheKey(string SimpleName, AssemblyVersion Version)
+    {
+        public FailureCacheKey(AssemblyName assemblyName) : this(assemblyName.SimpleName, assemblyName.Version) { }
+    }
+
+    internal class ApplicationContext
+    {
+        private volatile int _version;
+
+        public int Version => _version;
+
+        public Dictionary<AssemblyName, Assembly> ExecutionContext { get; } = new Dictionary<AssemblyName, Assembly>();
+
+        public Dictionary<FailureCacheKey, int> FailureCache { get; } = new Dictionary<FailureCacheKey, int>();
+
+        public object ContextCriticalSection { get; } = new object();
+
+        private readonly List<string> _platformResourceRoots = new List<string>();
+
+        public List<string> AppPaths { get; } = new List<string>();
+
+        public Dictionary<string, TPAEntry>? TrustedPlatformAssemblyMap { get; private set; }
+
+        public void IncrementVersion() => Interlocked.Increment(ref _version);
+
+        private const char PATH_SEPARATOR_CHAR = ';';
+
+        private static bool GetNextPath(string paths, ref int startPos, out string outPath)
+        {
+            bool wrappedWithQuotes = false;
+
+            // Skip any leading spaces or path separators
+            while (startPos < paths.Length && paths[startPos] is ' ' or PATH_SEPARATOR_CHAR)
+                startPos++;
+
+            if (startPos == paths.Length)
+            {
+                // No more paths in the string and we just skipped over some white space
+                outPath = string.Empty;
+                return false;
+            }
+
+            // Support paths being wrapped with quotations
+            while (startPos < paths.Length && paths[startPos] == '\"')
+            {
+                startPos++;
+                wrappedWithQuotes = true;
+            }
+
+            int iEnd = startPos; // Where current path ends
+            int iNext;           // Where next path starts
+
+            if (wrappedWithQuotes)
+            {
+                iEnd = paths.AsSpan(iEnd).IndexOf('\"');
+                if (iEnd != -1)
+                {
+                    // Find where the next path starts - there should be a path separator right after the closing quotation mark
+                    iNext = paths.AsSpan(iEnd).IndexOf(PATH_SEPARATOR_CHAR);
+                    if (iNext != -1)
+                    {
+                        iNext++;
+                    }
+                    else
+                    {
+                        iNext = paths.Length;
+                    }
+                }
+                else
+                {
+                    // There was no terminating quotation mark - that's bad
+                    throw new ArgumentException(nameof(paths));
+                }
+            }
+            else if ((iEnd = paths.AsSpan(iEnd).IndexOf(PATH_SEPARATOR_CHAR)) != -1)
+            {
+                iNext = iEnd + 1;
+            }
+            else
+            {
+                iNext = iEnd = paths.Length;
+            }
+
+            // Skip any trailing spaces
+            while (paths[iEnd - 1] == ' ')
+            {
+                iEnd--;
+            }
+
+            Debug.Assert(startPos < iEnd);
+
+            outPath = paths[startPos..iEnd];
+            startPos = iNext;
+            return true;
+        }
+
+        private static bool GetNextTPAPath(string paths, ref int startPos, bool dllOnly, out string outPath, out string simpleName, out bool isNativeImage)
+        {
+            isNativeImage = false;
+
+            while (true)
+            {
+                if (!GetNextPath(paths, ref startPos, out outPath))
+                {
+                    simpleName = string.Empty;
+                    return false;
+                }
+
+                if (!Path.IsPathFullyQualified(outPath))
+                {
+                    throw new ArgumentException(nameof(paths));
+                }
+
+                // Find the beginning of the simple name
+                int iSimpleNameStart = outPath.LastIndexOf(PathInternal.DirectorySeparatorChar);
+                if (iSimpleNameStart == -1)
+                {
+                    iSimpleNameStart = 0;
+                }
+                else
+                {
+                    // Advance past the directory separator to the first character of the file name
+                    iSimpleNameStart++;
+                }
+
+                if (iSimpleNameStart == outPath.Length)
+                {
+                    throw new ArgumentException(nameof(paths));
+                }
+
+                if (dllOnly && (outPath.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)
+                    || outPath.EndsWith(".ni.exe", StringComparison.OrdinalIgnoreCase)))
+                {
+                    // Skip exe files when the caller requested only dlls
+                    continue;
+                }
+
+                if (outPath.EndsWith(".ni.dll", StringComparison.OrdinalIgnoreCase)
+                    || outPath.EndsWith(".ni.exe", StringComparison.OrdinalIgnoreCase))
+                {
+                    simpleName = outPath[iSimpleNameStart..^7];
+                    isNativeImage = true;
+                }
+                else if (outPath.EndsWith(".dll", StringComparison.OrdinalIgnoreCase)
+                    || outPath.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
+                {
+                    simpleName = outPath[iSimpleNameStart..^4];
+                }
+                else
+                {
+                    // Invalid filename
+                    throw new ArgumentException(nameof(paths));
+                }
+
+                return true; ;
+            }
+        }
+
+        public void SetupBindingPaths(string trustedPlatformAssemblies, string platformResourceRoots, string appPaths, bool acquireLock)
+        {
+            if (acquireLock)
+            {
+                lock (ContextCriticalSection)
+                {
+                    Core(trustedPlatformAssemblies, platformResourceRoots, appPaths);
+                }
+            }
+            else
+            {
+                Core(trustedPlatformAssemblies, platformResourceRoots, appPaths);
+            }
+
+            void Core(string trustedPlatformAssemblies, string platformResourceRoots, string appPaths)
+            {
+                if (TrustedPlatformAssemblyMap != null)
+                {
+                    return;
+                }
+
+                //
+                // Parse TrustedPlatformAssemblies
+                //
+
+                TrustedPlatformAssemblyMap = new Dictionary<string, TPAEntry>(StringComparer.InvariantCultureIgnoreCase);
+                for (int i = 0; i < trustedPlatformAssemblies.Length;)
+                {
+                    if (!GetNextTPAPath(trustedPlatformAssemblies, ref i, dllOnly: false, out string fileName, out string simpleName, out bool isNativeImage))
+                    {
+                        break;
+                    }
+
+                    if (TrustedPlatformAssemblyMap.TryGetValue(simpleName, out TPAEntry existingEntry))
+                    {
+                        //
+                        // We want to store only the first entry matching a simple name we encounter.
+                        // The exception is if we first store an IL reference and later in the string
+                        // we encounter a native image.  Since we don't touch IL in the presence of
+                        // native images, we replace the IL entry with the NI.
+                        //
+                        if ((existingEntry.ILFileName != null && !isNativeImage) ||
+                            (existingEntry.NIFileName != null && isNativeImage))
+                        {
+                            continue;
+                        }
+                    }
+
+                    if (isNativeImage)
+                    {
+                        existingEntry.NIFileName = fileName;
+                    }
+                    else
+                    {
+                        existingEntry.ILFileName = fileName;
+                    }
+
+                    TrustedPlatformAssemblyMap[simpleName] = existingEntry;
+                }
+
+                //
+                // Parse PlatformResourceRoots
+                //
+
+                for (int i = 0; i < platformResourceRoots.Length;)
+                {
+                    if (!GetNextPath(platformResourceRoots, ref i, out string pathName))
+                    {
+                        break;
+                    }
+
+                    if (!Path.IsPathFullyQualified(pathName))
+                    {
+                        throw new ArgumentException(nameof(pathName));
+                    }
+
+                    _platformResourceRoots.Add(pathName);
+                }
+
+                //
+                // Parse AppPaths
+                //
+
+                for (int i = 0; i < appPaths.Length;)
+                {
+                    if (!GetNextPath(appPaths, ref i, out string pathName))
+                    {
+                        break;
+                    }
+
+
+                    if (!Path.IsPathFullyQualified(pathName))
+                    {
+                        throw new ArgumentException(nameof(pathName));
+                    }
+
+                    AppPaths.Add(pathName);
+                }
+            }
+        }
+
+        public void AddToFailureCache(AssemblyName assemblyName, int hresult)
+        {
+            FailureCache.Add(new FailureCacheKey(assemblyName), hresult);
+            IncrementVersion();
+        }
+    }
+}

src/coreclr/System.Private.CoreLib/src/Internal/Runtime/Binder/Assembly.cs

@@ -0,0 +1,42 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+namespace Internal.Runtime.Binder
+{
+    // BINDER_SPACE::Assembly represents a result of binding to an actual assembly (PEImage)
+    // It is basically a tuple of 1) physical assembly and 2) binder which created/owns this binding
+    // We also store whether it was bound using TPA list
+    internal class Assembly
+    {
+        public IntPtr PEImage;
+
+        public AssemblyName AssemblyName { get; }
+
+        // private IntPtr _pBinder; // PTR_AssemblyBinder
+
+        public bool IsInTPA { get; }
+
+        // private IntPtr _domainAssembly; // DomainAssembly*
+
+        public Assembly(nint pPEImage, bool isInTPA)
+        {
+            // Get assembly name def from meta data import and store it for later refs access
+            AssemblyName = new AssemblyName(pPEImage)
+            {
+                IsDefinition = true
+            };
+
+            // validate architecture
+            if (!AssemblyBinderCommon.IsValidArchitecture(AssemblyName.Architecture))
+            {
+                // Assembly image can't be executed on this platform
+                throw new BadImageFormatException();
+            }
+
+            IsInTPA = isInTPA;
+            PEImage = pPEImage;
+        }
+    }
+}

src/coreclr/System.Private.CoreLib/src/Internal/Runtime/Binder/AssemblyBinder.cs

@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Internal.Runtime.Binder
+{
+    internal abstract class AssemblyBinder
+    {
+        public abstract ApplicationContext AppContext { get; }
+    }
+}