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)) { }