/// <summary> /// Verifies that <paramref name="code"/> produces no diagnostics when analyzed with <paramref name="analyzer"/>. /// </summary> /// <param name="analyzer">The analyzer.</param> /// <param name="code"> /// The code to create the solution from. /// Can be a .cs, .csproj or .sln file. /// </param> public static void NoAnalyzerDiagnostics(DiagnosticAnalyzer analyzer, FileInfo code) { var sln = CodeFactory.CreateSolution(code, CodeFactory.DefaultCompilationOptions(analyzer, SuppressedDiagnostics), MetadataReferences); var diagnostics = Analyze.GetDiagnostics(analyzer, sln); NoDiagnostics(diagnostics); }
/// <summary> /// Check the solution for compiler errors and warnings, uses: /// DiagnosticSettings.AllowedErrorIds() /// DiagnosticSettings.AllowedDiagnostics(). /// </summary> /// <param name="metadataReferences">A collection of <see cref="MetadataReference"/> to use when compiling. Default is <see langword="null" /> meaning <see cref="MetadataReferences"/> are used.</param> /// <param name="code">The code to analyze.</param> public static void NoCompilerErrors(IEnumerable <MetadataReference> metadataReferences, params string[] code) { #pragma warning disable CS0618 // Suppress until removed. Will be replaced with Metadatareferences.FromAttributes() var solution = CodeFactory.CreateSolution(code, metadataReferences); NoCompilerErrors(solution, SuppressedDiagnostics, DiagnosticSettings.AllowedDiagnostics()); #pragma warning restore CS0618 // Suppress until removed. Will be replaced with Metadatareferences.FromAttributes() }
/// <summary> /// Verifies that <paramref name="code"/> produces no diagnostics when analyzed with <paramref name="analyzer"/>. /// </summary> /// <param name="analyzer">The analyzer.</param> /// <param name="code">The code to analyze.</param> /// <param name="compilationOptions">The <see cref="CSharpCompilationOptions"/> to use.</param> /// <param name="metadataReferences">The metadata references to use when compiling.</param> public static void NoAnalyzerDiagnostics(DiagnosticAnalyzer analyzer, string code, CSharpCompilationOptions compilationOptions, IEnumerable <MetadataReference> metadataReferences) { var sln = CodeFactory.CreateSolution(code, compilationOptions, metadataReferences); var diagnostics = Analyze.GetDiagnostics(analyzer, sln); NoDiagnostics(diagnostics); }
/// <summary> /// Verifies that <paramref name="diagnosticsAndSources"/> produces the expected diagnostics. /// </summary> /// <param name="analyzer">The <see cref="DiagnosticAnalyzer"/> to check <paramref name="diagnosticsAndSources"/> with.</param> /// <param name="diagnosticsAndSources">The code to analyze with <paramref name="analyzer"/>. Indicate error position with ↓ (alt + 25).</param> /// <param name="allowCompilationErrors">Specify if compilation errors are accepted in the fixed code. This can be for example syntax errors. Default value is <see cref="AllowCompilationErrors.No"/>.</param> /// <param name="suppressWarnings">A collection of <see cref="DiagnosticDescriptor.Id"/> to suppress when analyzing the code. Default is <see langword="null" /> meaning <see cref="SuppressedDiagnostics"/> are used.</param> /// <param name="metadataReferences">A collection of <see cref="MetadataReference"/> to use when compiling. Default is <see langword="null" /> meaning <see cref="MetadataReferences"/> are used.</param> /// <param name="compilationOptions">The <see cref="CSharpCompilationOptions"/>.</param> public static void Diagnostics( DiagnosticAnalyzer analyzer, DiagnosticsAndSources diagnosticsAndSources, AllowCompilationErrors allowCompilationErrors = AllowCompilationErrors.No, IEnumerable <string>?suppressWarnings = null, IEnumerable <MetadataReference>?metadataReferences = null, CSharpCompilationOptions?compilationOptions = null) { VerifyAnalyzerSupportsDiagnostics(analyzer, diagnosticsAndSources.ExpectedDiagnostics); var sln = CodeFactory.CreateSolution( diagnosticsAndSources, analyzer, compilationOptions, #pragma warning disable CS0618 // Suppress until removed. Will be replaced with Metadatareferences.FromAttributes() suppressWarnings ?? SuppressedDiagnostics, metadataReferences ?? MetadataReferences); #pragma warning restore CS0618 // Suppress until removed. Will be replaced with Metadatareferences.FromAttributes() var diagnostics = Analyze.GetDiagnostics(analyzer, sln); VerifyDiagnostics(diagnosticsAndSources, diagnostics, sln); if (allowCompilationErrors == AllowCompilationErrors.No) { NoCompilerErrors(sln); } }
/// <summary> /// Creates a solution and adds the <paramref name="analyzer"/> as analyzer. /// Then compiles it and returns the diagnostics. /// </summary> /// <param name="analyzer">The analyzer to find diagnostics for.</param> /// <param name="sources">The sources as strings.</param> /// <param name="references">The <see cref="MetadataReference"/> to use when compiling.</param> /// <returns>A list with diagnostics per document.</returns> public static async Task <DiagnosticsWithMetadata> GetDiagnosticsWithMetadataAsync(DiagnosticAnalyzer analyzer, IReadOnlyList <string> sources, IReadOnlyList <MetadataReference> references) { var sln = CodeFactory.CreateSolution(sources, new[] { analyzer }, references); var results = await GetDiagnosticsAsync(sln, analyzer).ConfigureAwait(false); return(new DiagnosticsWithMetadata(sln, results)); }
/// <summary> /// Verifies that /// 1. <paramref name="fix"/> supports fixing diagnostics reported by <paramref name="analyzer"/>. /// 2. <paramref name="diagnosticsAndSources"/> produces diagnostics fixable by <paramref name="fix"/>. /// 3. Applying <paramref name="fix"/> results in <paramref name="after"/>. /// </summary> /// <param name="analyzer">The <see cref="DiagnosticAnalyzer"/> to check <paramref name="diagnosticsAndSources"/> with.</param> /// <param name="fix">The <see cref="CodeFixProvider"/> to apply on the <see cref="Diagnostic"/> reported.</param> /// <param name="diagnosticsAndSources">The code to analyze with <paramref name="analyzer"/>. Indicate error position with ↓ (alt + 25).</param> /// <param name="after">The expected code produced by applying <paramref name="fix"/>.</param> /// <param name="fixTitle">The expected title of the fix. Must be provided if more than one code action is registered.</param> /// <param name="allowCompilationErrors">Specify if compilation errors are accepted in the fixed code. This can be for example syntax errors. Default value is <see cref="AllowCompilationErrors.No"/>.</param> /// <param name="suppressWarnings">A collection of <see cref="DiagnosticDescriptor.Id"/> to suppress when analyzing the code. Default is <see langword="null" /> meaning <see cref="SuppressedDiagnostics"/> are used.</param> /// <param name="metadataReferences">A collection of <see cref="MetadataReference"/> to use when compiling. Default is <see langword="null" /> meaning <see cref="MetadataReferences"/> are used.</param> /// <param name="compilationOptions">The <see cref="CSharpCompilationOptions"/>.</param> public static void CodeFix( DiagnosticAnalyzer analyzer, CodeFixProvider fix, DiagnosticsAndSources diagnosticsAndSources, IReadOnlyList <string> after, string?fixTitle = null, AllowCompilationErrors allowCompilationErrors = AllowCompilationErrors.No, IEnumerable <string>?suppressWarnings = null, IEnumerable <MetadataReference>?metadataReferences = null, CSharpCompilationOptions?compilationOptions = null) { VerifyCodeFixSupportsAnalyzer(analyzer, fix); VerifyAnalyzerSupportsDiagnostics(analyzer, diagnosticsAndSources.ExpectedDiagnostics); var sln = CodeFactory.CreateSolution( diagnosticsAndSources: diagnosticsAndSources, analyzer: analyzer, compilationOptions: compilationOptions, #pragma warning disable CS0618 // Suppress until removed. Will be replaced with Metadatareferences.FromAttributes() suppressWarnings ?? SuppressedDiagnostics, metadataReferences ?? MetadataReferences); #pragma warning restore CS0618 // Suppress until removed. Will be replaced with Metadatareferences.FromAttributes() var diagnostics = Analyze.GetDiagnostics(analyzer, sln); VerifyDiagnostics(diagnosticsAndSources, diagnostics, sln); VerifyFix(sln, diagnostics, analyzer, fix, after, fixTitle, allowCompilationErrors); }
/// <summary> /// Verifies that <paramref name="code"/> produces no diagnostics when analyzed with <paramref name="analyzer"/>. /// </summary> /// <param name="analyzer">The analyzer.</param> /// <param name="code">The code to analyze.</param> public static void Valid(DiagnosticAnalyzer analyzer, IReadOnlyList <string> code) { var sln = CodeFactory.CreateSolution(code, CodeFactory.DefaultCompilationOptions(analyzer, SuppressedDiagnostics), MetadataReferences); var diagnosticsAndErrors = Analyze.GetDiagnosticsAndErrors(analyzer, sln); NoDiagnosticsOrErrors(diagnosticsAndErrors); }
/// <summary> /// Verifies that <paramref name="code"/> produces no diagnostics when analyzed with <paramref name="analyzer"/>. /// </summary> /// <param name="analyzer">The analyzer.</param> /// <param name="code">The code to analyze.</param> /// <param name="compilationOptions">The <see cref="CSharpCompilationOptions"/> to use.</param> /// <param name="metadataReferences">The metadata references to use when compiling.</param> public static void Valid(DiagnosticAnalyzer analyzer, IReadOnlyList <string> code, CSharpCompilationOptions compilationOptions, IEnumerable <MetadataReference> metadataReferences) { var sln = CodeFactory.CreateSolution(code, compilationOptions, metadataReferences); var diagnosticsAndErrors = Analyze.GetDiagnosticsAndErrors(analyzer, sln); NoDiagnosticsOrErrors(diagnosticsAndErrors); }
/// <summary> /// Verifies that <paramref name="code"/> produces no diagnostics when analyzed with <paramref name="analyzer"/>. /// </summary> /// <param name="analyzer">The analyzer.</param> /// <param name="descriptor">The expected diagnostic.</param> /// <param name="code">The code to analyze.</param> public static void NoAnalyzerDiagnostics(DiagnosticAnalyzer analyzer, DiagnosticDescriptor descriptor, IReadOnlyList <string> code) { VerifyAnalyzerSupportsDiagnostic(analyzer, descriptor); var sln = CodeFactory.CreateSolution(code, CodeFactory.DefaultCompilationOptions(analyzer, descriptor, SuppressedDiagnostics), MetadataReferences); var diagnostics = Analyze.GetDiagnostics(analyzer, sln); NoDiagnostics(diagnostics); }
/// <summary> /// Verifies that <paramref name="diagnosticsAndSources"/> produces the expected diagnostics. /// </summary> /// <param name="analyzer">The analyzer to apply.</param> /// <param name="diagnosticsAndSources">The code to analyze.</param> public static void Diagnostics(DiagnosticAnalyzer analyzer, DiagnosticsAndSources diagnosticsAndSources) { VerifyAnalyzerSupportsDiagnostics(analyzer, diagnosticsAndSources.ExpectedDiagnostics); var sln = CodeFactory.CreateSolution(diagnosticsAndSources, analyzer, SuppressedDiagnostics, MetadataReferences); var diagnostics = Analyze.GetDiagnostics(analyzer, sln); VerifyDiagnostics(diagnosticsAndSources, diagnostics); }
/// <summary> /// Verifies that <paramref name="code"/> produces no diagnostics when analyzed with <paramref name="analyzer"/>. /// </summary> /// <param name="analyzer">The <see cref="DiagnosticAnalyzer"/> to check <paramref name="code"/> with.</param> /// <param name="code"> /// The code to create the solution from. /// Can be a .cs, .csproj or .sln file. /// </param> public static void NoAnalyzerDiagnostics(DiagnosticAnalyzer analyzer, FileInfo code) { #pragma warning disable CS0618 // Suppress until removed. Will be replaced with Metadatareferences.FromAttributes() var sln = CodeFactory.CreateSolution(code, CodeFactory.DefaultCompilationOptions(analyzer, SuppressedDiagnostics), MetadataReferences); #pragma warning restore CS0618 // Suppress until removed. Will be replaced with Metadatareferences.FromAttributes() var diagnostics = Analyze.GetDiagnostics(analyzer, sln); NoDiagnostics(diagnostics); }
/// <summary> /// Verifies that <paramref name="code"/> produces no diagnostics when analyzed with <paramref name="analyzer"/>. /// </summary> /// <param name="analyzer">The analyzer.</param> /// <param name="descriptor">The expected diagnostic.</param> /// <param name="code"> /// The code to create the solution from. /// Can be a .cs, .csproj or .sln file. /// </param> public static void Valid(DiagnosticAnalyzer analyzer, DiagnosticDescriptor descriptor, FileInfo code) { VerifyAnalyzerSupportsDiagnostic(analyzer, descriptor); var sln = CodeFactory.CreateSolution(code, CodeFactory.DefaultCompilationOptions(analyzer, descriptor, SuppressedDiagnostics), MetadataReferences); var diagnosticsAndErrors = Analyze.GetDiagnosticsAndErrors(analyzer, sln); NoDiagnosticsOrErrors(diagnosticsAndErrors); }
/// <summary> /// Verifies that <paramref name="code"/> produces no diagnostics when analyzed with <paramref name="analyzer"/>. /// </summary> /// <param name="analyzer">The analyzer.</param> /// <param name="descriptors">The expected diagnostic.</param> /// <param name="code">The code to analyze.</param> public static void Valid(DiagnosticAnalyzer analyzer, IReadOnlyList <DiagnosticDescriptor> descriptors, params string[] code) { VerifyAnalyzerSupportsDiagnostics(analyzer, descriptors); var sln = CodeFactory.CreateSolution(code, CodeFactory.DefaultCompilationOptions(analyzer, descriptors, SuppressedDiagnostics), MetadataReferences); var diagnosticsAndErrors = Analyze.GetDiagnosticsAndErrors(analyzer, sln); NoDiagnosticsOrErrors(diagnosticsAndErrors); }
/// <summary> /// Verifies that <paramref name="code"/> produces no diagnostics when analyzed with <paramref name="analyzer"/>. /// </summary> /// <param name="analyzer">The <see cref="DiagnosticAnalyzer"/> to check <paramref name="code"/> with.</param> /// <param name="code">The code to analyze using <paramref name="analyzer"/>. Analyzing the code is expected to produce no errors or warnings.</param> public static void Valid(DiagnosticAnalyzer analyzer, params string[] code) { Valid( analyzer, #pragma warning disable CS0618 // Suppress until removed. Will be replaced with Metadatareferences.FromAttributes() CodeFactory.CreateSolution(code, CodeFactory.DefaultCompilationOptions(analyzer, SuppressedDiagnostics), MetadataReferences)); #pragma warning restore CS0618 // Suppress until removed. Will be replaced with Metadatareferences.FromAttributes() }
/// <summary> /// Verifies that <paramref name="code"/> produces no diagnostics when analyzed with <paramref name="analyzer"/>. /// </summary> /// <param name="analyzer">The <see cref="DiagnosticAnalyzer"/> to check <paramref name="code"/> with.</param> /// <param name="descriptor">The <see cref="ExpectedDiagnostic"/> with information about the expected <see cref="Diagnostic"/>. If <paramref name="analyzer"/> supports more than one <see cref="DiagnosticDescriptor.Id"/> this must be provided.</param> /// <param name="code">The code to analyze using <paramref name="analyzer"/>. Analyzing the code is expected to produce no errors or warnings.</param> public static void NoAnalyzerDiagnostics(DiagnosticAnalyzer analyzer, DiagnosticDescriptor descriptor, IReadOnlyList <string> code) { VerifyAnalyzerSupportsDiagnostic(analyzer, descriptor); #pragma warning disable CS0618 // Suppress until removed. Will be replaced with Metadatareferences.FromAttributes() var sln = CodeFactory.CreateSolution(code, CodeFactory.DefaultCompilationOptions(analyzer, descriptor, SuppressedDiagnostics), MetadataReferences); #pragma warning restore CS0618 // Suppress until removed. Will be replaced with Metadatareferences.FromAttributes() var diagnostics = Analyze.GetDiagnostics(analyzer, sln); NoDiagnostics(diagnostics); }
/// <summary> /// Verifies that /// 1. <paramref name="diagnosticsAndSources"/> produces the expected diagnostics /// 2. The code fix fixes the code. /// </summary> /// <param name="analyzer">The analyzer to run on the code..</param> /// <param name="fix">The <see cref="CodeFixProvider"/> to apply.</param> /// <param name="diagnosticsAndSources">The code to analyze.</param> /// <param name="fixedCode">The expected code produced by the code fix.</param> /// <param name="suppressedDiagnostics">Ids of diagnostics to suppress.</param> /// <param name="metadataReferences">Collection of <see cref="MetadataReference"/> to use when compiling.</param> /// <param name="fixTitle">The title of the fix to apply if more than one.</param> /// <param name="allowCompilationErrors">If compilation errors are accepted in the fixed code.</param> public static void CodeFix(DiagnosticAnalyzer analyzer, CodeFixProvider fix, DiagnosticsAndSources diagnosticsAndSources, string fixedCode, IEnumerable <string> suppressedDiagnostics, IEnumerable <MetadataReference> metadataReferences, string fixTitle = null, AllowCompilationErrors allowCompilationErrors = AllowCompilationErrors.No) { VerifyCodeFixSupportsAnalyzer(analyzer, fix); VerifyAnalyzerSupportsDiagnostics(analyzer, diagnosticsAndSources.ExpectedDiagnostics); var sln = CodeFactory.CreateSolution(diagnosticsAndSources, analyzer, suppressedDiagnostics, metadataReferences); var diagnostics = Analyze.GetDiagnostics(analyzer, sln); VerifyDiagnostics(diagnosticsAndSources, diagnostics); VerifyFix(sln, diagnostics, analyzer, fix, fixedCode, fixTitle, allowCompilationErrors); }
/// <summary> /// Verifies that /// 1. <paramref name="diagnosticsAndSources"/> produces the expected diagnostics /// 2. The code fix does not change the code. /// </summary> /// <param name="analyzer">The type of the analyzer.</param> /// <param name="codeFix">The type of the code fix.</param> /// <param name="diagnosticsAndSources">The code to analyze.</param> /// <param name="suppressedDiagnostics">Ids of diagnostics to suppress.</param> /// <param name="metadataReferences">Collection of <see cref="MetadataReference"/> to use when compiling.</param> public static void NoFix(DiagnosticAnalyzer analyzer, CodeFixProvider codeFix, DiagnosticsAndSources diagnosticsAndSources, IEnumerable <string> suppressedDiagnostics, IEnumerable <MetadataReference> metadataReferences) { VerifyAnalyzerSupportsDiagnostics(analyzer, diagnosticsAndSources.ExpectedDiagnostics); VerifyCodeFixSupportsAnalyzer(analyzer, codeFix); var sln = CodeFactory.CreateSolution(diagnosticsAndSources, analyzer, suppressedDiagnostics, metadataReferences); var diagnostics = Analyze.GetDiagnostics(analyzer, sln); VerifyDiagnostics(diagnosticsAndSources, diagnostics); VerifyNoFix(sln, diagnostics, codeFix); }
/// <summary> /// Verifies that <paramref name="code"/> produces no diagnostics when analyzed with <paramref name="analyzer"/>. /// </summary> /// <param name="analyzer">The analyzer.</param> /// <param name="code">The code to analyze.</param> /// <param name="compilationOptions">The <see cref="CSharpCompilationOptions"/> to use.</param> /// <param name="metadataReferences">The metadata references to use when compiling.</param> public static void Valid(DiagnosticAnalyzer analyzer, string code, CSharpCompilationOptions compilationOptions = null, IEnumerable <MetadataReference> metadataReferences = null) { var sln = CodeFactory.CreateSolution( code, compilationOptions ?? CodeFactory.DefaultCompilationOptions(analyzer, SuppressedDiagnostics), metadataReferences ?? MetadataReferences); var diagnosticsAndErrors = Analyze.GetDiagnosticsAndErrors(analyzer, sln); NoDiagnosticsOrErrors(diagnosticsAndErrors); }
/// <summary> /// Creates a solution and adds the <paramref name="analyzer"/> as analyzer. /// Then compiles it and returns the diagnostics. /// </summary> /// <param name="analyzer">The analyzer to find diagnostics for.</param> /// <param name="sources">The sources as strings.</param> /// <param name="compilationOptions">The <see cref="CSharpCompilationOptions"/> to use.</param> /// <param name="metadataReferences">The <see cref="MetadataReference"/> to use when compiling.</param> /// <returns>A list with diagnostics per document.</returns> public static Task <IReadOnlyList <ImmutableArray <Diagnostic> > > GetDiagnosticsAsync(DiagnosticAnalyzer analyzer, IReadOnlyList <string> sources, CSharpCompilationOptions compilationOptions, IEnumerable <MetadataReference> metadataReferences) { if (analyzer == null) { throw new ArgumentNullException(nameof(analyzer)); } var sln = CodeFactory.CreateSolution(sources, compilationOptions, metadataReferences); return(GetDiagnosticsAsync(sln, analyzer)); }
public static async Task <DiagnosticsWithMetadata> GetDiagnosticsWithMetadataAsync(DiagnosticAnalyzer analyzer, IReadOnlyList <string> sources, CSharpCompilationOptions compilationOptions, IEnumerable <MetadataReference> references) { if (analyzer == null) { throw new ArgumentNullException(nameof(analyzer)); } var sln = CodeFactory.CreateSolution(sources, compilationOptions, references); var diagnostics = await GetDiagnosticsAsync(sln, analyzer).ConfigureAwait(false); return(new DiagnosticsWithMetadata(sln, diagnostics)); }
/// <summary> /// Verifies that /// 1. <paramref name="codeWithErrorsIndicated"/> produces the expected diagnostics /// 2. The code fix fixes the code. /// </summary> /// <param name="analyzer">The analyzer to run on the code..</param> /// <param name="codeFix">The code fix to apply.</param> /// <param name="codeWithErrorsIndicated">The code with error positions indicated.</param> /// <param name="fixedCode">The expected code produced by the code fix.</param> /// <param name="fixTitle">The title of the fix to apply if more than one.</param> /// <param name="suppressedDiagnostics">The diagnostics to suppress when compiling.</param> /// <param name="metadataReferences">The meta data metadataReferences to add to the compilation.</param> /// <param name="allowCompilationErrors">If compilation errors are accepted in the fixed code.</param> /// <param name="scope">The scope to apply fixes for.</param> public static void FixAllByScope(DiagnosticAnalyzer analyzer, CodeFixProvider codeFix, IReadOnlyList <string> codeWithErrorsIndicated, IReadOnlyList <string> fixedCode, string fixTitle, IEnumerable <string> suppressedDiagnostics, IEnumerable <MetadataReference> metadataReferences, AllowCompilationErrors allowCompilationErrors, FixAllScope scope) { var diagnosticsAndSources = DiagnosticsAndSources.CreateFromCodeWithErrorsIndicated(analyzer, codeWithErrorsIndicated); VerifyAnalyzerSupportsDiagnostics(analyzer, diagnosticsAndSources.ExpectedDiagnostics); VerifyCodeFixSupportsAnalyzer(analyzer, codeFix); var sln = CodeFactory.CreateSolution(diagnosticsAndSources, analyzer, suppressedDiagnostics, metadataReferences); var diagnostics = Analyze.GetDiagnostics(sln, analyzer); VerifyDiagnostics(diagnosticsAndSources, diagnostics); FixAllByScope(analyzer, codeFix, sln, fixedCode, fixTitle, allowCompilationErrors, scope); }
/// <summary> /// Verifies that <paramref name="codeWithErrorsIndicated"/> produces the expected diagnostics. /// </summary> /// <param name="analyzer">The analyzer to apply.</param> /// <param name="codeWithErrorsIndicated">The code with error positions indicated.</param> /// <param name="compilationOptions">The <see cref="CSharpCompilationOptions"/> to use.</param> /// <param name="metadataReferences">The meta data metadataReferences to use when compiling.</param> public static void Diagnostics(DiagnosticAnalyzer analyzer, IReadOnlyList <string> codeWithErrorsIndicated, CSharpCompilationOptions compilationOptions = null, IEnumerable <MetadataReference> metadataReferences = null) { var diagnosticsAndSources = DiagnosticsAndSources.CreateFromCodeWithErrorsIndicated(analyzer, codeWithErrorsIndicated); VerifyAnalyzerSupportsDiagnostics(analyzer, diagnosticsAndSources.ExpectedDiagnostics); var sln = CodeFactory.CreateSolution( diagnosticsAndSources.Code, compilationOptions ?? CodeFactory.DefaultCompilationOptions(analyzer, SuppressedDiagnostics), metadataReferences ?? MetadataReferences); var diagnostics = Analyze.GetDiagnostics(analyzer, sln); VerifyDiagnostics(diagnosticsAndSources, diagnostics); }
/// <summary> /// Verifies that /// 1. <paramref name="codeWithErrorsIndicated"/> produces the expected diagnostics /// 2. The code fix does not change the code. /// </summary> /// <param name="codeFix">The type of the code fix.</param> /// <param name="codeWithErrorsIndicated">The code to analyze.</param> /// <param name="compilationOptions">The <see cref="CSharpCompilationOptions"/> to use.</param> /// <param name="metadataReferences">The meta data references to use when compiling.</param> public static void NoFix(CodeFixProvider codeFix, IReadOnlyList <string> codeWithErrorsIndicated, CSharpCompilationOptions compilationOptions, IEnumerable <MetadataReference> metadataReferences) { var diagnosticsAndSources = DiagnosticsAndSources.CreateFromCodeWithErrorsIndicated(new PlaceholderAnalyzer("None"), codeWithErrorsIndicated); var sln = CodeFactory.CreateSolution(diagnosticsAndSources.Code, compilationOptions, metadataReferences); var diagnostics = Analyze.GetDiagnostics(sln); if (diagnostics.SelectMany(x => x).All(d => !codeFix.FixableDiagnosticIds.Contains(d.Id))) { throw new InvalidOperationException("Analyzing the code did not produce any diagnostics fixable by the code fix."); } VerifyNoFix(sln, diagnostics, codeFix); }
/// <summary> /// Verifies that /// 1. <paramref name="codeWithErrorsIndicated"/> produces the expected diagnostics /// 2. The code fix fixes the code. /// </summary> /// <param name="analyzer">The analyzer to run on the code..</param> /// <param name="fix">The <see cref="CodeFixProvider"/> to apply.</param> /// <param name="codeWithErrorsIndicated">The code to analyze.</param> /// <param name="fixedCode">The expected code produced by the code fix.</param> /// <param name="compilationOptions">The compilation options.</param> /// <param name="metadataReferences">Collection of <see cref="MetadataReference"/> to use when compiling.</param> /// <param name="fixTitle">The title of the fix to apply if more than one.</param> /// <param name="allowCompilationErrors">If compilation errors are accepted in the fixed code.</param> public static void CodeFix(DiagnosticAnalyzer analyzer, CodeFixProvider fix, IReadOnlyList <string> codeWithErrorsIndicated, string fixedCode, CSharpCompilationOptions compilationOptions = null, IEnumerable <MetadataReference> metadataReferences = null, string fixTitle = null, AllowCompilationErrors allowCompilationErrors = AllowCompilationErrors.No) { VerifyCodeFixSupportsAnalyzer(analyzer, fix); var diagnosticsAndSources = DiagnosticsAndSources.CreateFromCodeWithErrorsIndicated(analyzer, codeWithErrorsIndicated); VerifyAnalyzerSupportsDiagnostics(analyzer, diagnosticsAndSources.ExpectedDiagnostics); var sln = CodeFactory.CreateSolution( diagnosticsAndSources.Code, compilationOptions ?? CodeFactory.DefaultCompilationOptions(analyzer, SuppressedDiagnostics), metadataReferences ?? MetadataReferences); var diagnostics = Analyze.GetDiagnostics(analyzer, sln); VerifyDiagnostics(diagnosticsAndSources, diagnostics); VerifyFix(sln, diagnostics, analyzer, fix, fixedCode, fixTitle, allowCompilationErrors); }
/// <summary> /// Verifies that <paramref name="code"/> produces no diagnostics when analyzed with <paramref name="analyzer"/>. /// </summary> /// <param name="analyzer">The <see cref="DiagnosticAnalyzer"/> to check <paramref name="code"/> with.</param> /// <param name="code">The code to analyze using <paramref name="analyzer"/>. Analyzing the code is expected to produce no errors or warnings.</param> /// <param name="suppressWarnings">A collection of <see cref="DiagnosticDescriptor.Id"/> to suppress when analyzing the code. Default is <see langword="null" /> meaning <see cref="SuppressedDiagnostics"/> are used.</param> /// <param name="metadataReferences">A collection of <see cref="MetadataReference"/> to use when compiling. Default is <see langword="null" /> meaning <see cref="MetadataReferences"/> are used.</param> /// <param name="compilationOptions">The <see cref="CSharpCompilationOptions"/>.</param> public static void Valid( DiagnosticAnalyzer analyzer, IReadOnlyList <string> code, IEnumerable <string>?suppressWarnings = null, IEnumerable <MetadataReference>?metadataReferences = null, CSharpCompilationOptions?compilationOptions = null) { Valid( analyzer, CodeFactory.CreateSolution( code, #pragma warning disable CS0618 // Suppress until removed. Will be replaced with Metadatareferences.FromAttributes() compilationOptions ?? CodeFactory.DefaultCompilationOptions(analyzer, suppressWarnings ?? SuppressedDiagnostics), metadataReferences ?? MetadataReferences)); #pragma warning restore CS0618 // Suppress until removed. Will be replaced with Metadatareferences.FromAttributes() }
/// <summary> /// Verifies that /// 1. <paramref name="codeWithErrorsIndicated"/> produces the expected diagnostics /// 2. The code fix fixes the code. /// </summary> /// <typeparam name="TAnalyzer">The type of the analyzer.</typeparam> /// <typeparam name="TCodeFix">The type of the code fix.</typeparam> /// <param name="codeWithErrorsIndicated">The code with error positions indicated.</param> /// <param name="fixedCode">The expected code produced by the code fix.</param> /// <param name="fixTitle">The title of the fix to apply if more than one.</param> /// <param name="allowCompilationErrors">If compilation errors are accepted in the fixed code.</param> public static void FixAllOneByOne <TAnalyzer, TCodeFix>(string codeWithErrorsIndicated, string fixedCode, string fixTitle = null, AllowCompilationErrors allowCompilationErrors = AllowCompilationErrors.No) where TAnalyzer : DiagnosticAnalyzer, new() where TCodeFix : CodeFixProvider, new() { var analyzer = new TAnalyzer(); var diagnosticsAndSources = DiagnosticsAndSources.CreateFromCodeWithErrorsIndicated(analyzer, codeWithErrorsIndicated); VerifyAnalyzerSupportsDiagnostics(analyzer, diagnosticsAndSources.ExpectedDiagnostics); var codeFix = new TCodeFix(); VerifyCodeFixSupportsAnalyzer(analyzer, codeFix); var sln = CodeFactory.CreateSolution(diagnosticsAndSources, analyzer, SuppressedDiagnostics, MetadataReferences); var diagnostics = Analyze.GetDiagnostics(analyzer, sln); VerifyDiagnostics(diagnosticsAndSources, diagnostics); FixAllOneByOne(analyzer, codeFix, sln, new[] { fixedCode }, fixTitle, allowCompilationErrors); }
/// <summary> /// Verifies that /// 1. <paramref name="diagnosticsAndSources"/> produces the expected diagnostics /// 2. The code fix fixes the code. /// </summary> /// <param name="analyzer">The analyzer to run on the code..</param> /// <param name="codeFix">The code fix to apply.</param> /// <param name="diagnosticsAndSources">The code and expected diagnostics.</param> /// <param name="fixedCode">The expected code produced by the code fix.</param> /// <param name="suppressedDiagnostics">The diagnostics to suppress when compiling.</param> /// <param name="metadataReferences">The meta data metadataReferences to add to the compilation.</param> /// <param name="fixTitle">The title of the fix to apply if more than one.</param> /// <param name="allowCompilationErrors">If compilation errors are accepted in the fixed code.</param> public static void FixAll(DiagnosticAnalyzer analyzer, CodeFixProvider codeFix, DiagnosticsAndSources diagnosticsAndSources, IReadOnlyList <string> fixedCode, IEnumerable <string> suppressedDiagnostics, IEnumerable <MetadataReference> metadataReferences, string fixTitle, AllowCompilationErrors allowCompilationErrors) { VerifyAnalyzerSupportsDiagnostics(analyzer, diagnosticsAndSources.ExpectedDiagnostics); VerifyCodeFixSupportsAnalyzer(analyzer, codeFix); var sln = CodeFactory.CreateSolution(diagnosticsAndSources, analyzer, suppressedDiagnostics, metadataReferences); var diagnostics = Analyze.GetDiagnostics(analyzer, sln); VerifyDiagnostics(diagnosticsAndSources, diagnostics); FixAllOneByOne(analyzer, codeFix, sln, fixedCode, fixTitle, allowCompilationErrors); var fixAllProvider = codeFix.GetFixAllProvider(); if (fixAllProvider != null) { foreach (var scope in fixAllProvider.GetSupportedFixAllScopes()) { FixAllByScope(analyzer, codeFix, sln, fixedCode, fixTitle, allowCompilationErrors, scope); } } }
/// <summary> /// Creates a solution and adds the <paramref name="analyzer"/> as analyzer. /// Then compiles it and returns the diagnostics. /// </summary> /// <param name="analyzer">The analyzer to find diagnostics for.</param> /// <param name="sources">The sources as strings.</param> /// <param name="compilationOptions">The <see cref="CSharpCompilationOptions"/> to use.</param> /// <param name="metadataReferences">The <see cref="MetadataReference"/> to use when compiling.</param> /// <returns>A list with diagnostics per document.</returns> public static Task <IReadOnlyList <ImmutableArray <Diagnostic> > > GetDiagnosticsAsync(DiagnosticAnalyzer analyzer, IReadOnlyList <string> sources, CSharpCompilationOptions compilationOptions, IReadOnlyList <MetadataReference> metadataReferences) { var sln = CodeFactory.CreateSolution(sources, compilationOptions, metadataReferences); return(GetDiagnosticsAsync(sln, analyzer)); }
/// <summary> /// Creates a solution and adds the <paramref name="analyzer"/> as analyzer. /// Then compiles it and returns the diagnostics. /// </summary> /// <param name="analyzer">The analyzer to find diagnostics for.</param> /// <param name="code"> /// The code to create the solution from. /// Can be a .cs, .csproj or .solution file /// </param> /// <param name="metadataReferences">The <see cref="MetadataReference"/> to use when compiling.</param> /// <returns>A list with diagnostics per document.</returns> public static Task <IReadOnlyList <ImmutableArray <Diagnostic> > > GetDiagnosticsAsync(DiagnosticAnalyzer analyzer, FileInfo code, IReadOnlyList <MetadataReference> metadataReferences) { var sln = CodeFactory.CreateSolution(code, new[] { analyzer }, metadataReferences); return(GetDiagnosticsAsync(sln, analyzer)); }
/// <summary> /// Check the solution for compiler errors and warnings, uses: /// DiagnosticSettings.AllowedErrorIds() /// DiagnosticSettings.AllowedDiagnostics(). /// </summary> public static void NoCompilerErrors(IEnumerable <MetadataReference> metadataReferences, params string[] code) { var solution = CodeFactory.CreateSolution(code, metadataReferences); NoCompilerErrors(solution, DiagnosticSettings.AllowedErrorIds(), DiagnosticSettings.AllowedDiagnostics()); }