[automated] Merge branch 'main' => 'main-vs-deps' (#77776)

I detected changes in the main branch which have not been merged yet to
main-vs-deps. I'm a robot and am configured to help you automatically
keep main-vs-deps up to date, so I've opened this PR.

This PR merges commits made on main by the following committers:

* jaredpar

## Instructions for merging from UI

This PR will not be auto-merged. When pull request checks pass, complete
this PR by creating a merge commit, *not* a squash or rebase commit.

<img alt="merge button instructions"
src="https://i.imgur.com/GepcNJV.png" width="300" />

If this repo does not allow creating merge commits from the GitHub UI,
use command line instructions.

## Instructions for merging via command line

Run these commands to merge this pull request from the command line.

``` sh
git fetch
git checkout main
git pull --ff-only
git checkout main-vs-deps
git pull --ff-only
git merge --no-ff main

# If there are merge conflicts, resolve them and then run git merge --continue to complete the merge
# Pushing the changes to the PR branch will re-trigger PR validation.
git push https://github.com/dotnet/roslyn HEAD:merge/main-to-main-vs-deps
```

<details>
<summary>or if you are using SSH</summary>

```
git push git@github.com:dotnet/roslyn HEAD:merge/main-to-main-vs-deps
```

</details>


After PR checks are complete push the branch
```
git push
```

## Instructions for resolving conflicts

:warning: If there are merge conflicts, you will need to resolve them
manually before merging. You can do this [using GitHub][resolve-github]
or using the [command line][resolve-cli].

[resolve-github]:
https://help.github.com/articles/resolving-a-merge-conflict-on-github/
[resolve-cli]:
https://help.github.com/articles/resolving-a-merge-conflict-using-the-command-line/

## Instructions for updating this pull request

Contributors to this repo have permission update this pull request by
pushing to the branch 'merge/main-to-main-vs-deps'. This can be done to
resolve conflicts or make other changes to this pull request before it
is merged.
The provided examples assume that the remote is named 'origin'. If you
have a different remote name, please replace 'origin' with the name of
your remote.

```
git fetch
git checkout -b merge/main-to-main-vs-deps origin/main-vs-deps
git pull https://github.com/dotnet/roslyn merge/main-to-main-vs-deps
(make changes)
git commit -m "Updated PR with my changes"
git push https://github.com/dotnet/roslyn HEAD:merge/main-to-main-vs-deps
```

<details>
    <summary>or if you are using SSH</summary>

```
git fetch
git checkout -b merge/main-to-main-vs-deps origin/main-vs-deps
git pull git@github.com:dotnet/roslyn merge/main-to-main-vs-deps
(make changes)
git commit -m "Updated PR with my changes"
git push git@github.com:dotnet/roslyn HEAD:merge/main-to-main-vs-deps
```

</details>

Contact .NET Core Engineering (dotnet/dnceng) if you have questions or
issues.
Also, if this PR was generated incorrectly, help us fix it. See
https://github.com/dotnet/arcade/blob/main/.github/workflows/scripts/inter-branch-merge.ps1.

Author: dotnet-policy-service[bot]

src/Compilers/Core/CodeAnalysisTest/AnalyzerAssemblyLoaderTests.cs

@@ -26,7 +26,7 @@ public override object InitializeLifetimeService()
 
         public Exception LoadAnalyzer(string shadowPath, string analyzerPath)
         {
-            var loader = DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(shadowPath);
+            var loader = AnalyzerAssemblyLoader.CreateNonLockingLoader(shadowPath, []);
             Exception analyzerLoadException = null;
             var analyzerRef = new AnalyzerFileReference(analyzerPath, loader);
             analyzerRef.AnalyzerLoadFailed += (s, e) => analyzerLoadException = e.Exception;

src/Compilers/Core/CodeAnalysisTest/Analyzers/AnalyzerFileReferenceAppDomainTests.cs

@@ -29,7 +29,7 @@ private AssemblyLoadTestFixtureCollection() { }
     [Collection(AssemblyLoadTestFixtureCollection.Name)]
     public class AnalyzerFileReferenceTests : TestBase
     {
-        private static readonly AnalyzerAssemblyLoader s_analyzerLoader = new DefaultAnalyzerAssemblyLoader();
+        private static readonly AnalyzerAssemblyLoader s_analyzerLoader = new AnalyzerAssemblyLoader();
         private readonly AssemblyLoadTestFixture _testFixture;
         public AnalyzerFileReferenceTests(AssemblyLoadTestFixture testFixture)
         {
@@ -319,13 +319,13 @@ public void AssemblyLoading_ReferencesLaterFakeCompiler_EndToEnd_CSharp()
                 args: new[] { "/nologo", $@"/analyzer:""{_testFixture.AnalyzerWithLaterFakeCompilerDependency}""", "/nostdlib", $@"/r:""{corlib}""", "/out:something.dll", source.Path },
                 new BuildPaths(clientDir: directory.Path, workingDir: directory.Path, sdkDir: null, tempDir: null),
                 additionalReferenceDirectories: null,
-                new DefaultAnalyzerAssemblyLoader());
+                new AnalyzerAssemblyLoader());
 
             var writer = new StringWriter();
             var result = compiler.Run(writer);
             Assert.Equal(0, result);
             AssertEx.Equal($"""
-                warning CS9057: Analyzer assembly '{_testFixture.AnalyzerWithLaterFakeCompilerDependency}' cannot be used because it references version '100.0.0.0' of the compiler, which is newer than the currently running version '{typeof(DefaultAnalyzerAssemblyLoader).Assembly.GetName().Version}'.
+                warning CS9057: Analyzer assembly '{_testFixture.AnalyzerWithLaterFakeCompilerDependency}' cannot be used because it references version '100.0.0.0' of the compiler, which is newer than the currently running version '42.42.42.42'.
                 in.cs(1,5): warning CS0219: The variable 'x' is assigned but its value is never used
 
                 """, writer.ToString());
@@ -348,7 +348,7 @@ public void DuplicateAnalyzerReference()
                 args: new[] { "/nologo", $@"/analyzer:""{_testFixture.AnalyzerWithFakeCompilerDependency}""", $@"/analyzer:""{_testFixture.AnalyzerWithFakeCompilerDependency}""", "/nostdlib", $@"/r:""{corlib}""", "/out:something.dll", source.Path },
                 new BuildPaths(clientDir: directory.Path, workingDir: directory.Path, sdkDir: null, tempDir: null),
                 additionalReferenceDirectories: null,
-                new DefaultAnalyzerAssemblyLoader());
+                new AnalyzerAssemblyLoader());
 
             var writer = new StringWriter();
             var result = compiler.Run(writer);

src/Compilers/Core/CodeAnalysisTest/Analyzers/AnalyzerFileReferenceTests.cs

@@ -0,0 +1,59 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if NET
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.Loader;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.UnitTests;
+
+public sealed class CompilerResolverTests : IDisposable
+{
+    public TempRoot TempRoot { get; }
+    public int DefaultLoadContextCount { get; }
+    public AssemblyLoadContext CompilerContext { get; }
+    public AssemblyLoadContext ScratchContext { get; }
+    public Assembly AssemblyInCompilerContext { get; }
+    internal AnalyzerAssemblyLoader Loader { get; }
+
+    public CompilerResolverTests()
+    {
+        TempRoot = new TempRoot();
+        DefaultLoadContextCount = AssemblyLoadContext.Default.Assemblies.Count();
+        CompilerContext = new AssemblyLoadContext(nameof(CompilerResolverTests), isCollectible: true);
+        AssemblyInCompilerContext = CompilerContext.LoadFromAssemblyPath(typeof(AnalyzerAssemblyLoader).Assembly.Location);
+        ScratchContext = new AssemblyLoadContext("Scratch", isCollectible: true);
+        Loader = new AnalyzerAssemblyLoader([], [AnalyzerAssemblyLoader.DiskAnalyzerAssemblyResolver], CompilerContext);
+    }
+
+    public void Dispose()
+    {
+        // This test should not pollute the default load context and hence interfere with other tests.
+        Assert.Equal(DefaultLoadContextCount, AssemblyLoadContext.Default.Assemblies.Count());
+        CompilerContext.Unload();
+        ScratchContext.Unload();
+        TempRoot.Dispose();
+    }
+
+    [Fact]
+    public void ResolveReturnsNullForNonHostAssembly()
+    {
+        var name = new AssemblyName("NotARealAssembly");
+        var assembly = Loader.CompilerAnalyzerAssemblyResolver.Resolve(Loader, name, ScratchContext, TempRoot.CreateDirectory().Path);
+        Assert.Null(assembly);
+    }
+
+    [Fact]
+    public void ResolveReturnsForHostAssembly()
+    {
+        var assembly = Loader.CompilerAnalyzerAssemblyResolver.Resolve(Loader, AssemblyInCompilerContext.GetName(), ScratchContext, TempRoot.CreateDirectory().Path);
+        Assert.Same(AssemblyInCompilerContext, assembly);
+    }
+}
+#endif

src/Compilers/Core/CodeAnalysisTest/CompilerAnalyzerAssemblyResolverTests.cs

@@ -35,24 +35,62 @@ namespace Microsoft.CodeAnalysis.UnitTests
 
     public sealed class InvokeUtil
     {
-        internal void Exec(ITestOutputHelper testOutputHelper, AssemblyLoadContext compilerContext, AssemblyLoadTestFixture fixture, AnalyzerTestKind kind, string typeName, string methodName, IAnalyzerAssemblyResolver[] externalResolvers, object? state = null)
+        internal void Exec(
+            ITestOutputHelper testOutputHelper,
+            ImmutableArray<IAnalyzerPathResolver> pathResolvers,
+            ImmutableArray<IAnalyzerAssemblyResolver> assemblyResolvers,
+            AssemblyLoadTestFixture fixture,
+            AnalyzerTestKind kind,
+            string typeName,
+            string methodName,
+            object? state = null)
+        {
+            using var tempRoot = new TempRoot();
+            switch (kind)
+            {
+                case AnalyzerTestKind.LoadDirect:
+                    assemblyResolvers = [.. assemblyResolvers, AnalyzerAssemblyLoader.DiskAnalyzerAssemblyResolver];
+                    break;
+                case AnalyzerTestKind.LoadStream:
+                    assemblyResolvers = [.. assemblyResolvers, AnalyzerAssemblyLoader.StreamAnalyzerAssemblyResolver];
+                    break;
+                case AnalyzerTestKind.ShadowLoad:
+                    pathResolvers = [.. pathResolvers, new ShadowCopyAnalyzerPathResolver(tempRoot.CreateDirectory().Path)];
+                    assemblyResolvers = [.. assemblyResolvers, AnalyzerAssemblyLoader.DiskAnalyzerAssemblyResolver];
+                    break;
+                default:
+                    throw ExceptionUtilities.Unreachable();
+            }
+
+            var loader = new AnalyzerAssemblyLoader(pathResolvers, assemblyResolvers, compilerLoadContext: null);
+            var compilerContextAssemblyCount = loader.CompilerLoadContext.Assemblies.Count();
+            try
+            {
+                Exec(testOutputHelper, fixture, loader, typeName, methodName, state);
+            }
+            finally
+            {
+                // When using the actual compiler load context (the one shared by all of our unit tests) the test
+                // did not load any additional assemblies that could interfere with later tests.
+                Assert.Equal(compilerContextAssemblyCount, loader.CompilerLoadContext.Assemblies.Count());
+            }
+        }
+
+        internal void Exec(
+            ITestOutputHelper testOutputHelper,
+            AssemblyLoadTestFixture fixture,
+            AnalyzerAssemblyLoader loader,
+            string typeName,
+            string methodName,
+            object? state = null)
         {
             // Ensure that the test did not load any of the test fixture assemblies into 
             // the default load context. That should never happen. Assemblies should either 
             // load into the compiler or directory load context.
             //
             // Not only is this bad behavior it also pollutes future test results.
             var defaultContextCount = AssemblyLoadContext.Default.Assemblies.Count();
-            var compilerContextCount = compilerContext.Assemblies.Count();
-
             using var tempRoot = new TempRoot();
-            using AnalyzerAssemblyLoader loader = kind switch
-            {
-                AnalyzerTestKind.LoadDirect => new DefaultAnalyzerAssemblyLoader(compilerContext, AnalyzerLoadOption.LoadFromDisk, externalResolvers.ToImmutableArray()),
-                AnalyzerTestKind.LoadStream => new DefaultAnalyzerAssemblyLoader(compilerContext, AnalyzerLoadOption.LoadFromStream, externalResolvers.ToImmutableArray()),
-                AnalyzerTestKind.ShadowLoad => new ShadowCopyAnalyzerAssemblyLoader(compilerContext, tempRoot.CreateDirectory().Path, externalResolvers.ToImmutableArray()),
-                _ => throw ExceptionUtilities.Unreachable()
-            };
 
             try
             {
@@ -71,19 +109,18 @@ internal void Exec(ITestOutputHelper testOutputHelper, AssemblyLoadContext compi
                     }
                 }
 
-                if (loader is ShadowCopyAnalyzerAssemblyLoader shadowLoader)
+                if (loader.AnalyzerPathResolvers.OfType<ShadowCopyAnalyzerPathResolver>().FirstOrDefault() is { } shadowResolver)
                 {
-                    testOutputHelper.WriteLine($"Shadow loader: {shadowLoader.BaseDirectory}");
+                    testOutputHelper.WriteLine($"{nameof(ShadowCopyAnalyzerPathResolver)}: {shadowResolver.BaseDirectory}");
                 }
 
                 testOutputHelper.WriteLine($"Loader path maps");
                 foreach (var pair in loader.GetPathMapSnapshot())
                 {
-                    testOutputHelper.WriteLine($"\t{pair.OriginalAssemblyPath} -> {pair.RealAssemblyPath}");
+                    testOutputHelper.WriteLine($"\t{pair.OriginalAssemblyPath} -> {pair.ResolvedAssemblyPath}");
                 }
 
                 Assert.Equal(defaultContextCount, AssemblyLoadContext.Default.Assemblies.Count());
-                Assert.Equal(compilerContextCount, compilerContext.Assemblies.Count());
             }
         }
     }
@@ -92,16 +129,25 @@ internal void Exec(ITestOutputHelper testOutputHelper, AssemblyLoadContext compi
 
     public sealed class InvokeUtil : MarshalByRefObject
     {
-        internal void Exec(ITestOutputHelper testOutputHelper, AssemblyLoadTestFixture fixture, AnalyzerTestKind kind, string typeName, string methodName, IAnalyzerAssemblyResolver[] externalResolvers, object? state)
+        internal void Exec(
+            ITestOutputHelper testOutputHelper,
+            AssemblyLoadTestFixture fixture,
+            AnalyzerTestKind kind,
+            string typeName,
+            string methodName,
+            IAnalyzerPathResolver[] pathResolvers,
+            object? state)
         {
             using var tempRoot = new TempRoot();
-            AnalyzerAssemblyLoader loader = kind switch
+            pathResolvers = kind switch
             {
-                AnalyzerTestKind.LoadDirect => new DefaultAnalyzerAssemblyLoader(externalResolvers.ToImmutableArray()),
-                AnalyzerTestKind.ShadowLoad => new ShadowCopyAnalyzerAssemblyLoader(tempRoot.CreateDirectory().Path, externalResolvers.ToImmutableArray()),
-                _ => throw ExceptionUtilities.Unreachable()
+                AnalyzerTestKind.LoadDirect => pathResolvers,
+                AnalyzerTestKind.ShadowLoad => [.. pathResolvers, new ShadowCopyAnalyzerPathResolver(tempRoot.CreateDirectory().Path)],
+                _ => throw ExceptionUtilities.Unreachable(),
             };
 
+            var loader = new AnalyzerAssemblyLoader(pathResolvers.ToImmutableArray());
+
             try
             {
                 AnalyzerAssemblyLoaderTests.InvokeTestCode(loader, fixture, typeName, methodName, state);
@@ -121,15 +167,15 @@ internal void Exec(ITestOutputHelper testOutputHelper, AssemblyLoadTestFixture f
                     testOutputHelper.WriteLine($"\t{assembly.FullName} -> {assembly.Location}");
                 }
 
-                if (loader is ShadowCopyAnalyzerAssemblyLoader shadowLoader)
+                if (loader.AnalyzerPathResolvers.OfType<ShadowCopyAnalyzerPathResolver>().FirstOrDefault() is { } shadowResolver)
                 {
-                    testOutputHelper.WriteLine($"Shadow loader: {shadowLoader.BaseDirectory}");
+                    testOutputHelper.WriteLine($"{nameof(ShadowCopyAnalyzerPathResolver)}: {shadowResolver.BaseDirectory}");
                 }
 
                 testOutputHelper.WriteLine($"Loader path maps");
                 foreach (var pair in loader.GetPathMapSnapshot())
                 {
-                    testOutputHelper.WriteLine($"\t{pair.OriginalAssemblyPath} -> {pair.RealAssemblyPath}");
+                    testOutputHelper.WriteLine($"\t{pair.OriginalAssemblyPath} -> {pair.ResolvedAssemblyPath}");
                 }
             }
         }

src/Compilers/Core/CodeAnalysisTest/CompilerResolverTests.cs

@@ -0,0 +1,108 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Microsoft.CodeAnalysis.UnitTests.Collections;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.UnitTests;
+
+public sealed class ShadowCopyAnalyzerPathResolverTests : IDisposable
+{
+    public TempRoot TempRoot { get; }
+    internal ShadowCopyAnalyzerPathResolver PathResolver { get; }
+
+    public ShadowCopyAnalyzerPathResolverTests()
+    {
+        TempRoot = new TempRoot();
+        PathResolver = new ShadowCopyAnalyzerPathResolver(TempRoot.CreateDirectory().Path);
+    }
+
+    public void Dispose()
+    {
+        TempRoot.Dispose();
+    }
+
+    [Fact]
+    public void IsAnalyzerPathHandled()
+    {
+        var analyzerPath = TempRoot.CreateDirectory().CreateFile("analyzer.dll").Path;
+        Assert.True(PathResolver.IsAnalyzerPathHandled(analyzerPath));
+    }
+
+    /// <summary>
+    /// Don't create the shadow directory until a copy actually happens
+    /// </summary>
+    [Fact]
+    public void ShadowDirectoryIsDelayCreated()
+    {
+        Assert.False(Directory.Exists(PathResolver.ShadowDirectory));
+    }
+
+    /// <summary>
+    /// A shadow copy of a file that doesn't exist should produce a file that doesn't exist, not throw
+    /// </summary>
+    [Fact]
+    public void GetRealPath_FileDoesNotExist()
+    {
+        var analyzerPath = Path.Combine(TempRoot.CreateDirectory().Path, "analyzer.dll");
+        var shadowPath = PathResolver.GetResolvedAnalyzerPath(analyzerPath);
+        Assert.False(File.Exists(shadowPath));
+    }
+
+    [Fact]
+    public void GetRealPath_Copies()
+    {
+        var analyzerPath = Path.Combine(TempRoot.CreateDirectory().Path, "analyzer.dll");
+        File.WriteAllText(analyzerPath, "test");
+        var shadowPath = PathResolver.GetResolvedAnalyzerPath(analyzerPath);
+        Assert.True(File.Exists(shadowPath));
+        Assert.Equal("test", File.ReadAllText(shadowPath));
+    }
+
+    /// <summary>
+    /// When shadow copying two files in the same directory they should end up in the same shadow 
+    /// directory
+    /// </summary>
+    [Fact]
+    public void GetRealPath_FilesInSameDirectory()
+    {
+        var dir = TempRoot.CreateDirectory().Path;
+        var analyzer1Path = Path.Combine(dir, "analyzer1.dll");
+        File.WriteAllText(analyzer1Path, "test");
+        var analyzer2Path = Path.Combine(dir, "analyzer2.dll");
+        File.WriteAllText(analyzer2Path, "test");
+        var shadow1Path = PathResolver.GetResolvedAnalyzerPath(analyzer1Path);
+        var shadow2Path = PathResolver.GetResolvedAnalyzerPath(analyzer2Path);
+        Assert.Equal(Path.GetDirectoryName(shadow1Path), Path.GetDirectoryName(shadow2Path));
+    }
+
+    [Fact]
+    public void GetRealPath_GroupOnDirectory()
+    {
+        var dir = TempRoot.CreateDirectory().Path;
+        var group1AnalyzerPath = createAnalyzer("group1", "analyzer.dll");
+        var group2AnalyzerPath = createAnalyzer("group2", "analyzer.dll");
+        var group1ShadowPath = PathResolver.GetResolvedAnalyzerPath(group1AnalyzerPath);
+        var group2ShadowPath = PathResolver.GetResolvedAnalyzerPath(group2AnalyzerPath);
+        Assert.NotEqual(group1ShadowPath, group2ShadowPath);
+        Assert.Equal("group1-analyzer.dll", File.ReadAllText(group1ShadowPath));
+        Assert.Equal("group2-analyzer.dll", File.ReadAllText(group2ShadowPath));
+
+        string createAnalyzer(string groupName, string name)
+        {
+            var groupDir = Path.Combine(dir, groupName, "analyzers");
+            _ = Directory.CreateDirectory(groupDir);
+            var filePath = Path.Combine(groupDir, name);
+            File.WriteAllText(filePath, $"{Path.GetFileName(groupName)}-{name}");
+            return filePath;
+        }
+    }
+}