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}");
}
}
}
internal TestParameters(
ParseOptions parseOptions = null,
CompilationOptions compilationOptions = null,
OptionsCollection options = null,
CodeActionOptions?codeActionOptions = null,
IdeAnalyzerOptions?ideAnalyzerOptions = null,
object fixProviderData = null,
int index = 0,
CodeActionPriority?priority = null,
bool retainNonFixableDiagnostics = false,
bool includeDiagnosticsOutsideSelection = false,
string title = null,
TestHost testHost = TestHost.InProcess,
string workspaceKind = null)
{
this.parseOptions = parseOptions;
this.compilationOptions = compilationOptions;
this.options = options;
this.codeActionOptions = codeActionOptions ?? CodeActionOptions.Default;
#if CODE_STYLE
this.ideAnalyzerOptions = ideAnalyzerOptions ?? IdeAnalyzerOptions.CodeStyleDefault;
#else
this.ideAnalyzerOptions = ideAnalyzerOptions ?? IdeAnalyzerOptions.Default;
#endif
this.fixProviderData = fixProviderData;
this.index = index;
this.priority = priority;
this.retainNonFixableDiagnostics = retainNonFixableDiagnostics;
this.includeDiagnosticsOutsideSelection = includeDiagnosticsOutsideSelection;
this.title = title;
this.testHost = testHost;
this.workspaceKind = workspaceKind;
}
private static async Task <CompilationWithAnalyzers?> GetOrCreateCompilationWithAnalyzersAsync(
Project project,
IdeAnalyzerOptions ideOptions,
IEnumerable <StateSet> stateSets,
bool includeSuppressedDiagnostics,
CancellationToken cancellationToken)
{
if (_lastProjectAndCompilationWithAnalyzers.TryGetTarget(out var projectAndCompilationWithAnalyzers) &&
projectAndCompilationWithAnalyzers?.Project == project)
{
if (projectAndCompilationWithAnalyzers.CompilationWithAnalyzers == null)
{
return(null);
}
if (((WorkspaceAnalyzerOptions)projectAndCompilationWithAnalyzers.CompilationWithAnalyzers.AnalysisOptions.Options !).IdeOptions == ideOptions)
{
return(projectAndCompilationWithAnalyzers.CompilationWithAnalyzers);
}
}
var compilationWithAnalyzers = await CreateCompilationWithAnalyzersAsync(project, ideOptions, stateSets, includeSuppressedDiagnostics, cancellationToken).ConfigureAwait(false);
_lastProjectAndCompilationWithAnalyzers.SetTarget(new ProjectAndCompilationWithAnalyzers(project, compilationWithAnalyzers));
return(compilationWithAnalyzers);
}
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)));
}
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 DiagnosticArguments(
bool reportSuppressedDiagnostics,
bool logPerformanceInfo,
bool getTelemetryInfo,
DocumentId?documentId,
TextSpan?documentSpan,
AnalysisKind?documentAnalysisKind,
ProjectId projectId,
string[] analyzerIds,
IdeAnalyzerOptions ideOptions)
{
Debug.Assert(documentId != null || documentSpan == null);
Debug.Assert(documentId != null || documentAnalysisKind == null);
Debug.Assert(documentAnalysisKind is null or
(AnalysisKind?) AnalysisKind.Syntax or(AnalysisKind?) AnalysisKind.Semantic);
Debug.Assert(analyzerIds.Length > 0);
ReportSuppressedDiagnostics = reportSuppressedDiagnostics;
LogPerformanceInfo = logPerformanceInfo;
GetTelemetryInfo = getTelemetryInfo;
DocumentId = documentId;
DocumentSpan = documentSpan;
DocumentAnalysisKind = documentAnalysisKind;
ProjectId = projectId;
AnalyzerIds = analyzerIds;
IdeOptions = ideOptions;
}
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 WorkspaceAnalyzerOptions(AnalyzerOptions options, Solution solution, IdeAnalyzerOptions ideOptions)
: base(options.AdditionalFiles, options.AnalyzerConfigOptionsProvider)
{
_solution = solution;
IdeOptions = ideOptions;
}
public static AnalyzerOptions Create(Solution solution, AnalyzerOptions options) => new WorkspaceAnalyzerOptions(options, solution, IdeAnalyzerOptions.GetDefault(solution.Workspace.Services.GetLanguageServices(LanguageNames.CSharp)));
public AnalyzerOptionsProvider(AnalyzerConfigOptions options, IdeAnalyzerOptions fallbackOptions)
{
_options = options;
_fallbackOptions = fallbackOptions;
}
private static Task <CompilationWithAnalyzers?> CreateCompilationWithAnalyzersAsync(Project project, IdeAnalyzerOptions ideOptions, IEnumerable <StateSet> stateSets, bool includeSuppressedDiagnostics, CancellationToken cancellationToken) => DocumentAnalysisExecutor.CreateCompilationWithAnalyzersAsync(project, ideOptions, stateSets.Select(s => s.Analyzer), includeSuppressedDiagnostics, cancellationToken);
public WorkspaceAnalyzerOptions(AnalyzerOptions options, Project project)
: this(options, project.Solution, IdeAnalyzerOptions.FromProject(project))
{
}
