private static async Task <DocumentAnalyzerPerformance> TestDocumentPerformanceAsync(ImmutableDictionary <string, ImmutableArray <DiagnosticAnalyzer> > analyzers, Project project, DocumentId documentId, Options analyzerOptionsInternal, CancellationToken cancellationToken)
{
if (!analyzers.TryGetValue(project.Language, out var languageAnalyzers))
{
languageAnalyzers = ImmutableArray <DiagnosticAnalyzer> .Empty;
}
var compilation = await project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
var ideAnalyzerOptions = IdeAnalyzerOptions.GetDefault(project.LanguageServices);
var stopwatch = PerformanceTracker.StartNew();
for (int i = 0; i < analyzerOptionsInternal.TestDocumentIterations; i++)
{
var workspaceAnalyzerOptions = new WorkspaceAnalyzerOptions(project.AnalyzerOptions, project.Solution, ideAnalyzerOptions);
CompilationWithAnalyzers compilationWithAnalyzers = compilation.WithAnalyzers(languageAnalyzers, new CompilationWithAnalyzersOptions(workspaceAnalyzerOptions, null, analyzerOptionsInternal.RunConcurrent, logAnalyzerExecutionTime: true, reportSuppressedDiagnostics: analyzerOptionsInternal.ReportSuppressedDiagnostics));
SyntaxTree tree = await project.GetDocument(documentId).GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
await compilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(tree, cancellationToken).ConfigureAwait(false);
await compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(compilation.GetSemanticModel(tree), null, cancellationToken).ConfigureAwait(false);
}
return(new DocumentAnalyzerPerformance(analyzerOptionsInternal.TestDocumentIterations / stopwatch.Elapsed.TotalSeconds, stopwatch.AllocatedBytes / Math.Max(1, analyzerOptionsInternal.TestDocumentIterations)));
}
public async Task TestCancellation()
{
var code = @"class Test { void Method() { } }";
using var workspace = CreateWorkspace(LanguageNames.CSharp, code);
var ideAnalyzerOptions = IdeAnalyzerOptions.GetDefault(workspace.Services.GetLanguageServices(LanguageNames.CSharp));
var analyzerType = typeof(MyAnalyzer);
for (var i = 0; i < 5; i++)
{
var source = new CancellationTokenSource();
try
{
var task = Task.Run(() => AnalyzeAsync(workspace, workspace.CurrentSolution.ProjectIds.First(), analyzerType, ideAnalyzerOptions, source.Token));
// wait random milli-second
var random = new Random(Environment.TickCount);
var next = random.Next(1000);
await Task.Delay(next);
source.Cancel();
// let it throw
var result = await task;
}
catch (Exception ex)
{
// only cancellation is expected
Assert.True(ex is OperationCanceledException, $"cancellationToken : {source.Token.IsCancellationRequested}/r/n{ex}");
}
}
}
private static async Task <AnalysisResult> GetProjectAnalysisResultAsync(
ImmutableArray <DiagnosticAnalyzer> analyzers,
Project project,
Options analyzerOptionsInternal,
CancellationToken cancellationToken)
{
WriteLine($"Running analyzers for {project.Name}", ConsoleColor.Gray);
if (analyzerOptionsInternal.RunConcurrent)
{
await Task.Yield();
}
try
{
var compilation = await project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
var newCompilation = compilation.RemoveAllSyntaxTrees().AddSyntaxTrees(compilation.SyntaxTrees);
var ideAnalyzerOptions = IdeAnalyzerOptions.GetDefault(project.LanguageServices);
var workspaceAnalyzerOptions = new WorkspaceAnalyzerOptions(project.AnalyzerOptions, project.Solution, ideAnalyzerOptions);
var compilationWithAnalyzers = newCompilation.WithAnalyzers(analyzers, new CompilationWithAnalyzersOptions(workspaceAnalyzerOptions, null, analyzerOptionsInternal.RunConcurrent, logAnalyzerExecutionTime: true, reportSuppressedDiagnostics: analyzerOptionsInternal.ReportSuppressedDiagnostics));
var analystResult = await compilationWithAnalyzers.GetAnalysisResultAsync(cancellationToken).ConfigureAwait(false);
return(analystResult);
}
catch (Exception e)
{
WriteLine($"Failed to analyze {project.Name} with {e.ToString()}", ConsoleColor.Red);
return(null);
}
}
public async Task TestVisualBasicAnalyzerOptions()
{
var code = @"Class Test
Sub Method()
Dim b = Nothing
Dim a = If(b Is Nothing, Nothing, b.ToString())
End Sub
End Class";
using (var workspace = CreateWorkspace(LanguageNames.VisualBasic, code))
{
// set option
workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
.WithChangedOption(CodeStyleOptions2.PreferNullPropagation, LanguageNames.VisualBasic, new CodeStyleOption2 <bool>(false, NotificationOption2.Silent))));
var ideAnalyzerOptions = IdeAnalyzerOptions.GetDefault(workspace.Services.GetLanguageServices(LanguageNames.VisualBasic));
var analyzerType = typeof(VisualBasicUseNullPropagationDiagnosticAnalyzer);
var analyzerResult = await AnalyzeAsync(workspace, workspace.CurrentSolution.ProjectIds.First(), analyzerType, ideAnalyzerOptions);
Assert.True(analyzerResult.IsEmpty);
// set option
workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
.WithChangedOption(CodeStyleOptions2.PreferNullPropagation, LanguageNames.VisualBasic, new CodeStyleOption2 <bool>(true, NotificationOption2.Error))));
analyzerResult = await AnalyzeAsync(workspace, workspace.CurrentSolution.ProjectIds.First(), analyzerType, ideAnalyzerOptions);
var diagnostics = analyzerResult.GetDocumentDiagnostics(analyzerResult.DocumentIds.First(), AnalysisKind.Semantic);
Assert.Equal(IDEDiagnosticIds.UseNullPropagationDiagnosticId, diagnostics[0].Id);
}
}
public async Task TestCSharpAnalyzerOptions()
{
var code = @"class Test
{
void Method()
{
var t = new Test();
}
}";
using var workspace = CreateWorkspace(LanguageNames.CSharp, code);
var analyzerType = typeof(CSharpUseExplicitTypeDiagnosticAnalyzer);
var analyzerResult = await AnalyzeAsync(workspace, workspace.CurrentSolution.ProjectIds.First(), analyzerType,
IdeAnalyzerOptions.GetDefault(workspace.Services.GetLanguageServices(LanguageNames.CSharp)));
var diagnostics = analyzerResult.GetDocumentDiagnostics(analyzerResult.DocumentIds.First(), AnalysisKind.Semantic);
Assert.Equal(IDEDiagnosticIds.UseExplicitTypeDiagnosticId, diagnostics[0].Id);
Assert.Equal(DiagnosticSeverity.Hidden, diagnostics[0].Severity);
var ideOptions = new IdeAnalyzerOptions(
CleanupOptions: new CodeCleanupOptions(
FormattingOptions: CSharpSyntaxFormattingOptions.Default,
SimplifierOptions: new CSharpSimplifierOptions(
varWhenTypeIsApparent: new CodeStyleOption2 <bool>(false, NotificationOption2.Suggestion)),
AddImportOptions: AddImportPlacementOptions.Default));
analyzerResult = await AnalyzeAsync(workspace, workspace.CurrentSolution.ProjectIds.First(), analyzerType, ideOptions);
diagnostics = analyzerResult.GetDocumentDiagnostics(analyzerResult.DocumentIds.First(), AnalysisKind.Semantic);
Assert.Equal(IDEDiagnosticIds.UseExplicitTypeDiagnosticId, diagnostics[0].Id);
Assert.Equal(DiagnosticSeverity.Info, diagnostics[0].Severity);
}
private static void ExecuteAnalyzers(PreviewWorkspace previewWorkspace, ImmutableArray <DiagnosticAnalyzer> analyzers)
{
var analyzerOptions = new AnalyzerOptions(additionalFiles: ImmutableArray <AdditionalText> .Empty);
var project = previewWorkspace.CurrentSolution.Projects.Single();
var ideAnalyzerOptions = IdeAnalyzerOptions.GetDefault(project.LanguageServices);
var workspaceAnalyzerOptions = new WorkspaceAnalyzerOptions(analyzerOptions, project.Solution, ideAnalyzerOptions);
var compilationWithAnalyzersOptions = new CompilationWithAnalyzersOptions(workspaceAnalyzerOptions, onAnalyzerException: null, concurrentAnalysis: false, logAnalyzerExecutionTime: false);
var compilation = project.GetRequiredCompilationAsync(CancellationToken.None).Result;
var compilationWithAnalyzers = new CompilationWithAnalyzers(compilation, analyzers, compilationWithAnalyzersOptions);
var result = compilationWithAnalyzers.GetAnalysisResultAsync(CancellationToken.None).Result;
Assert.Equal(1, result.CompilationDiagnostics.Count);
}
public async Task TestHostAnalyzers_OutOfProc()
{
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());
var ideAnalyzerOptions = IdeAnalyzerOptions.GetDefault(workspace.Services.GetLanguageServices(LanguageNames.CSharp));
var options = workspace.Options
.WithChangedOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, new CodeStyleOption <bool>(false, NotificationOption.Suggestion));
workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(options).WithAnalyzerReferences(new[] { analyzerReference }));
// run analysis
var project = workspace.CurrentSolution.Projects.First();
var runner = CreateAnalyzerRunner();
var compilationWithAnalyzers = (await project.GetCompilationAsync()).WithAnalyzers(
analyzerReference.GetAnalyzers(project.Language).Where(a => a.GetType() == analyzerType).ToImmutableArray(),
new WorkspaceAnalyzerOptions(project.AnalyzerOptions, project.Solution, ideAnalyzerOptions));
// no result for open file only analyzer unless forced
var result = await runner.AnalyzeProjectAsync(project, compilationWithAnalyzers, forceExecuteAllAnalyzers : false, logPerformanceInfo : false, getTelemetryInfo : false, cancellationToken : CancellationToken.None);
Assert.Empty(result.AnalysisResult);
result = await runner.AnalyzeProjectAsync(project, compilationWithAnalyzers, forceExecuteAllAnalyzers : true, logPerformanceInfo : false, getTelemetryInfo : false, cancellationToken : CancellationToken.None);
var analyzerResult = result.AnalysisResult[compilationWithAnalyzers.Analyzers[0]];
// check result
var diagnostics = analyzerResult.GetDocumentDiagnostics(analyzerResult.DocumentIds.First(), AnalysisKind.Semantic);
Assert.Equal(IDEDiagnosticIds.UseExplicitTypeDiagnosticId, diagnostics[0].Id);
}
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 remotableDataService = workspace.Services.GetService <ISolutionAssetStorageProvider>();
var serializer = workspace.Services.GetRequiredService <ISerializerService>();
// run analysis
var project = workspace.CurrentSolution.Projects.First().AddAnalyzerReference(analyzerReference);
var runner = CreateAnalyzerRunner();
var analyzers = analyzerReference.GetAnalyzers(project.Language).Where(a => a.GetType() == analyzerType).ToImmutableArray();
var ideAnalyzerOptions = IdeAnalyzerOptions.GetDefault(project.LanguageServices);
var compilationWithAnalyzers = (await project.GetCompilationAsync())
.WithAnalyzers(analyzers, new WorkspaceAnalyzerOptions(project.AnalyzerOptions, project.Solution, ideAnalyzerOptions));
var result = await runner.AnalyzeProjectAsync(project, compilationWithAnalyzers, forceExecuteAllAnalyzers : false,
logPerformanceInfo : false, getTelemetryInfo : false, cancellationToken : CancellationToken.None);
var analyzerResult = result.AnalysisResult[compilationWithAnalyzers.Analyzers[0]];
// check result
var diagnostics = analyzerResult.GetDocumentDiagnostics(analyzerResult.DocumentIds.First(), AnalysisKind.Syntax);
Assert.Equal("test", diagnostics[0].Id);
}
public static AnalyzerOptions Create(Solution solution, AnalyzerOptions options) => new WorkspaceAnalyzerOptions(options, solution, IdeAnalyzerOptions.GetDefault(solution.Workspace.Services.GetLanguageServices(LanguageNames.CSharp)));