public async Task TestHostAnalyzers()
{
var code = @"class Test
{
void Method()
{
var t = new Test();
}
}";
using (var workspace = CreateWorkspace(LanguageNames.CSharp, code))
{
var analyzerType = typeof(CSharpUseExplicitTypeDiagnosticAnalyzer);
var analyzerReference = new AnalyzerFileReference(analyzerType.Assembly.Location, new TestAnalyzerAssemblyLoader());
// add host analyzer as global assets
var snapshotService = workspace.Services.GetService <IRemotableDataService>();
var assetBuilder = new CustomAssetBuilder(workspace);
var asset = assetBuilder.Build(analyzerReference, CancellationToken.None);
snapshotService.AddGlobalAsset(analyzerReference, asset, CancellationToken.None);
var client = await RemoteHostClient.TryGetClientAsync(workspace, CancellationToken.None).ConfigureAwait(false);
Assert.True(await client.TryRunRemoteAsync(
WellKnownRemoteHostServices.RemoteHostService,
nameof(IRemoteHostService.SynchronizeGlobalAssetsAsync),
new[] { new Checksum[] { asset.Checksum } },
workspace.CurrentSolution,
callbackTarget: null,
CancellationToken.None));
// set option
workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
.WithChangedOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, new CodeStyleOption <bool>(false, NotificationOption.Suggestion))));
// run analysis
var project = workspace.CurrentSolution.Projects.First();
var executor = new DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner(owner: null, hostDiagnosticUpdateSource: new MyUpdateSource(workspace));
var analyzerDriver = (await project.GetCompilationAsync()).WithAnalyzers(
analyzerReference.GetAnalyzers(project.Language).Where(a => a.GetType() == analyzerType).ToImmutableArray(),
new WorkspaceAnalyzerOptions(project.AnalyzerOptions, project.Solution));
// no result for open file only analyzer unless forced
var result = await executor.AnalyzeAsync(analyzerDriver, project, forcedAnalysis : false, cancellationToken : CancellationToken.None);
Assert.Empty(result.AnalysisResult);
result = await executor.AnalyzeAsync(analyzerDriver, project, forcedAnalysis : true, cancellationToken : CancellationToken.None);
var analyzerResult = result.AnalysisResult[analyzerDriver.Analyzers[0]];
// check result
var diagnostics = analyzerResult.GetDocumentDiagnostics(analyzerResult.DocumentIds.First(), AnalysisKind.Semantic);
Assert.Equal(IDEDiagnosticIds.UseExplicitTypeDiagnosticId, diagnostics[0].Id);
}
}
private static async Task <DiagnosticAnalysisResult> AnalyzeAsync(TestWorkspace workspace, ProjectId projectId, Type analyzerType, CancellationToken cancellationToken = default(CancellationToken))
{
var executor = new DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner(owner: null, hostDiagnosticUpdateSource: new MyUpdateSource(workspace));
var analyzerReference = new AnalyzerFileReference(analyzerType.Assembly.Location, new TestAnalyzerAssemblyLoader());
var project = workspace.CurrentSolution.GetProject(projectId).AddAnalyzerReference(analyzerReference);
var analyzerDriver = (await project.GetCompilationAsync()).WithAnalyzers(
analyzerReference.GetAnalyzers(project.Language).Where(a => a.GetType() == analyzerType).ToImmutableArray(),
new WorkspaceAnalyzerOptions(project.AnalyzerOptions, project.Solution.Options, project.Solution));
var result = await executor.AnalyzeAsync(analyzerDriver, project, forcedAnalysis : true, cancellationToken : cancellationToken);
return(result.AnalysisResult[analyzerDriver.Analyzers[0]]);
}
public async Task TestDuplicatedAnalyzers()
{
var code = @"class Test
{
void Method()
{
var t = new Test();
}
}";
using (var workspace = CreateWorkspace(LanguageNames.CSharp, code))
{
var analyzerType = typeof(DuplicateAnalyzer);
var analyzerReference = new AnalyzerFileReference(analyzerType.Assembly.Location, new TestAnalyzerAssemblyLoader());
// add host analyzer as global assets
var snapshotService = workspace.Services.GetService <IRemotableDataService>();
var assetBuilder = new CustomAssetBuilder(workspace);
var asset = assetBuilder.Build(analyzerReference, CancellationToken.None);
snapshotService.AddGlobalAsset(analyzerReference, asset, CancellationToken.None);
var client = await workspace.Services.GetService <IRemoteHostClientService>().TryGetRemoteHostClientAsync(CancellationToken.None);
await client.TryRunRemoteAsync(
WellKnownRemoteHostServices.RemoteHostService, workspace.CurrentSolution,
nameof(IRemoteHostService.SynchronizeGlobalAssetsAsync), (object)(new Checksum[] { asset.Checksum }), CancellationToken.None);
// run analysis
var project = workspace.CurrentSolution.Projects.First().AddAnalyzerReference(analyzerReference);
var executor = new DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner(owner: null, hostDiagnosticUpdateSource: new MyUpdateSource(workspace));
var analyzerDriver = (await project.GetCompilationAsync()).WithAnalyzers(
analyzerReference.GetAnalyzers(project.Language).Where(a => a.GetType() == analyzerType).ToImmutableArray(),
new WorkspaceAnalyzerOptions(project.AnalyzerOptions, project.Solution.Options, project.Solution));
var result = await executor.AnalyzeAsync(analyzerDriver, project, forcedAnalysis : false, cancellationToken : CancellationToken.None);
var analyzerResult = result.AnalysisResult[analyzerDriver.Analyzers[0]];
// check result
var diagnostics = analyzerResult.SyntaxLocals[analyzerResult.DocumentIds.First()];
Assert.Equal("test", diagnostics[0].Id);
}
}
