public async Task ShadowCopyAnalyzerAssemblyLoaderMissingDirectory()
{
var baseDirectory = Path.Combine(Path.GetTempPath(), TestBase.GetUniqueName());
var loader = new ShadowCopyAnalyzerAssemblyLoader(baseDirectory);
var task = loader.DeleteLeftoverDirectoriesTask;
await task;
Assert.False(task.IsFaulted);
}
public RemoteAnalyzerAssemblyLoaderService()
{
var baseDirectory = Path.GetDirectoryName(Path.GetFullPath(typeof(RemoteAnalyzerAssemblyLoader).GetTypeInfo().Assembly.Location));
Debug.Assert(baseDirectory != null);
_loader = new(baseDirectory);
_shadowCopyLoader = new(Path.Combine(Path.GetTempPath(), "VS", "AnalyzerAssemblyLoader"));
}
public void LoadWithDependency()
{
var directory = Temp.CreateDirectory();
var immutable = directory.CopyFile(typeof(ImmutableArray).Assembly.Location);
var microsoftCodeAnalysis = directory.CopyFile(typeof(DiagnosticAnalyzer).Assembly.Location);
var analyzerDependencyFile = CreateAnalyzerDependency();
var analyzerMainFile = CreateMainAnalyzerWithDependency(analyzerDependencyFile);
var loader = new ShadowCopyAnalyzerAssemblyLoader(Path.Combine(directory.Path, "AnalyzerAssemblyLoader"));
var analyzerMainReference = new AnalyzerFileReference(analyzerMainFile.Path, loader);
analyzerMainReference.AnalyzerLoadFailed += (_, e) => AssertEx.Fail(e.Exception.Message);
var analyzerDependencyReference = new AnalyzerFileReference(analyzerDependencyFile.Path, loader);
analyzerDependencyReference.AnalyzerLoadFailed += (_, e) => AssertEx.Fail(e.Exception.Message);
var analyzers = analyzerMainReference.GetAnalyzersForAllLanguages();
Assert.Equal(1, analyzers.Length);
Assert.Equal("TestAnalyzer", analyzers[0].ToString());
Assert.Equal(0, analyzerDependencyReference.GetAnalyzersForAllLanguages().Length);
Assert.NotNull(analyzerDependencyReference.GetAssembly());
TempFile CreateAnalyzerDependency()
{
var analyzerDependencySource = @"
using System;
using System.Collections.Immutable;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Diagnostics;
public abstract class AbstractTestAnalyzer : DiagnosticAnalyzer
{
protected static string SomeString = nameof(SomeString);
public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get { throw new NotImplementedException(); } }
public override void Initialize(AnalysisContext context) { throw new NotImplementedException(); }
}";
var analyzerDependencyCompilation = CSharp.CSharpCompilation.Create(
"AnalyzerDependency",
new SyntaxTree[] { CSharp.SyntaxFactory.ParseSyntaxTree(analyzerDependencySource) },
new MetadataReference[]
{
TestMetadata.NetStandard20.netstandard,
TestMetadata.NetStandard20.SystemRuntime,
MetadataReference.CreateFromFile(immutable.Path),
MetadataReference.CreateFromFile(microsoftCodeAnalysis.Path)
},
new CSharp.CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
return(directory.CreateDirectory("AnalyzerDependency").CreateFile("AnalyzerDependency.dll").WriteAllBytes(analyzerDependencyCompilation.EmitToArray()));
}
TempFile CreateMainAnalyzerWithDependency(TempFile analyzerDependency)
{
var analyzerMainSource = @"
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Diagnostics;
[DiagnosticAnalyzer(LanguageNames.CSharp)]
public sealed class TestAnalyzer : AbstractTestAnalyzer
{
private static string SomeString2 = AbstractTestAnalyzer.SomeString;
}";
var analyzerMainCompilation = CSharp.CSharpCompilation.Create(
"AnalyzerMain",
new SyntaxTree[] { CSharp.SyntaxFactory.ParseSyntaxTree(analyzerMainSource) },
new MetadataReference[]
{
TestMetadata.NetStandard20.netstandard,
TestMetadata.NetStandard20.SystemRuntime,
MetadataReference.CreateFromFile(immutable.Path),
MetadataReference.CreateFromFile(microsoftCodeAnalysis.Path),
MetadataReference.CreateFromFile(analyzerDependency.Path)
},
new CSharp.CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
return(directory.CreateDirectory("AnalyzerMain").CreateFile("AnalyzerMain.dll").WriteAllBytes(analyzerMainCompilation.EmitToArray()));
}
}
