public override async Task <CommandResult> ExecuteAsync(ProjectOrSolution projectOrSolution, CancellationToken cancellationToken = default)
{
AssemblyResolver.Register();
var codeFixerOptions = new CodeFixerOptions(
severityLevel: SeverityLevel,
ignoreCompilerErrors: Options.IgnoreCompilerErrors,
ignoreAnalyzerReferences: Options.IgnoreAnalyzerReferences,
supportedDiagnosticIds: Options.SupportedDiagnostics,
ignoredDiagnosticIds: Options.IgnoredDiagnostics,
ignoredCompilerDiagnosticIds: Options.IgnoredCompilerDiagnostics,
projectNames: Options.Projects,
ignoredProjectNames: Options.IgnoredProjects,
diagnosticIdsFixableOneByOne: Options.DiagnosticsFixableOneByOne,
diagnosticFixMap: DiagnosticFixMap,
diagnosticFixerMap: DiagnosticFixerMap,
fileBanner: Options.FileBanner,
language: Language,
maxIterations: Options.MaxIterations,
batchSize: Options.BatchSize,
format: Options.Format);
IEnumerable <AnalyzerAssembly> analyzerAssemblies = Options.AnalyzerAssemblies
.SelectMany(path => AnalyzerAssemblyLoader.LoadFrom(path).Select(info => info.AnalyzerAssembly));
CultureInfo culture = (Options.Culture != null) ? CultureInfo.GetCultureInfo(Options.Culture) : null;
return(await FixAsync(projectOrSolution, analyzerAssemblies, codeFixerOptions, culture, cancellationToken));
}
public override async Task <CommandResult> ExecuteAsync(ProjectOrSolution projectOrSolution, CancellationToken cancellationToken = default)
{
AssemblyResolver.Register();
ImmutableArray <UnusedSymbolInfo> allUnusedSymbols;
if (projectOrSolution.IsProject)
{
Project project = projectOrSolution.AsProject();
allUnusedSymbols = await AnalyzeProject(project, cancellationToken);
}
else
{
Solution solution = projectOrSolution.AsSolution();
ImmutableArray <UnusedSymbolInfo> .Builder unusedSymbols = null;
foreach (Project project in FilterProjects(solution, Options, s => s
.GetProjectDependencyGraph()
.GetTopologicallySortedProjects(cancellationToken)
.ToImmutableArray()))
{
cancellationToken.ThrowIfCancellationRequested();
ImmutableArray <UnusedSymbolInfo> unusedSymbols2 = await AnalyzeProject(project, cancellationToken);
if (unusedSymbols2.Any())
{
(unusedSymbols ?? (unusedSymbols = ImmutableArray.CreateBuilder <UnusedSymbolInfo>())).AddRange(unusedSymbols2);
}
}
allUnusedSymbols = unusedSymbols?.ToImmutableArray() ?? ImmutableArray <UnusedSymbolInfo> .Empty;
}
if (allUnusedSymbols.Any())
{
WriteLine(Verbosity.Normal);
Dictionary <UnusedSymbolKind, int> countByKind = allUnusedSymbols
.GroupBy(f => UnusedSymbolFinder.GetUnusedSymbolKind(f.Symbol))
.OrderByDescending(f => f.Count())
.ThenBy(f => f.Key)
.ToDictionary(f => f.Key, f => f.Count());
int maxCountLength = countByKind.Sum(f => f.Value.ToString().Length);
foreach (KeyValuePair <UnusedSymbolKind, int> kvp in countByKind)
{
WriteLine($"{kvp.Value.ToString().PadLeft(maxCountLength)} {kvp.Key.ToString().ToLowerInvariant()} symbols", Verbosity.Normal);
}
}
WriteLine(Verbosity.Minimal);
WriteLine($"{allUnusedSymbols.Length} unused {((allUnusedSymbols.Length == 1) ? "symbol" : "symbols")} found", ConsoleColor.Green, Verbosity.Minimal);
WriteLine(Verbosity.Minimal);
return(CommandResult.Success);
}
public override async Task <CommandResult> ExecuteAsync(ProjectOrSolution projectOrSolution, CancellationToken cancellationToken = default)
{
AssemblyResolver.Register();
var codeAnalyzerOptions = new CodeAnalyzerOptions(
ignoreAnalyzerReferences: Options.IgnoreAnalyzerReferences,
ignoreCompilerDiagnostics: Options.IgnoreCompilerDiagnostics,
reportNotConfigurable: Options.ReportNotConfigurable,
reportSuppressedDiagnostics: Options.ReportSuppressedDiagnostics,
logAnalyzerExecutionTime: Options.ExecutionTime,
severityLevel: SeverityLevel,
supportedDiagnosticIds: Options.SupportedDiagnostics,
ignoredDiagnosticIds: Options.IgnoredDiagnostics,
projectNames: Options.Projects,
ignoredProjectNames: Options.IgnoredProjects,
language: Language);
IEnumerable <string> analyzerAssemblies = Options.AnalyzerAssemblies;
if (Options.UseRoslynatorAnalyzers)
{
analyzerAssemblies = analyzerAssemblies.Concat(RoslynatorAnalyzersAssemblies);
}
CultureInfo culture = (Options.Culture != null) ? CultureInfo.GetCultureInfo(Options.Culture) : null;
var codeAnalyzer = new CodeAnalyzer(
analyzerAssemblies: AnalyzerAssemblyLoader.LoadFiles(analyzerAssemblies, loadFixers: false),
formatProvider: culture,
options: codeAnalyzerOptions);
if (projectOrSolution.IsProject)
{
Project project = projectOrSolution.AsProject();
WriteLine($"Analyze '{project.Name}'", ConsoleColor.Cyan, Verbosity.Minimal);
ProjectAnalysisResult result = await codeAnalyzer.AnalyzeProjectAsync(project, cancellationToken);
if (Options.Output != null &&
result.Diagnostics.Any())
{
DiagnosticXmlSerializer.Serialize(result, project, Options.Output, culture);
}
}
else
{
Solution solution = projectOrSolution.AsSolution();
ImmutableArray <ProjectAnalysisResult> results = await codeAnalyzer.AnalyzeSolutionAsync(solution, cancellationToken);
if (Options.Output != null &&
results.Any(f => f.Diagnostics.Any()))
{
DiagnosticXmlSerializer.Serialize(results, solution, Options.Output, culture);
}
}
return(CommandResult.Success);
}
public override async Task <CommandResult> ExecuteAsync(ProjectOrSolution projectOrSolution, CancellationToken cancellationToken = default)
{
AssemblyResolver.Register();
var codeAnalyzerOptions = new CodeAnalyzerOptions(
ignoreAnalyzerReferences: Options.IgnoreAnalyzerReferences,
ignoreCompilerDiagnostics: Options.IgnoreCompilerDiagnostics,
reportNotConfigurable: Options.ReportNotConfigurable,
reportSuppressedDiagnostics: Options.ReportSuppressedDiagnostics,
logAnalyzerExecutionTime: Options.ExecutionTime,
severityLevel: SeverityLevel,
supportedDiagnosticIds: Options.SupportedDiagnostics,
ignoredDiagnosticIds: Options.IgnoredDiagnostics,
projectNames: Options.Projects,
ignoredProjectNames: Options.IgnoredProjects,
language: Language);
IEnumerable <AnalyzerAssembly> analyzerAssemblies = Options.AnalyzerAssemblies
.SelectMany(path => AnalyzerAssemblyLoader.LoadFrom(path, loadFixers: false).Select(info => info.AnalyzerAssembly));
CultureInfo culture = (Options.Culture != null) ? CultureInfo.GetCultureInfo(Options.Culture) : null;
var codeAnalyzer = new CodeAnalyzer(
analyzerAssemblies: analyzerAssemblies,
formatProvider: culture,
options: codeAnalyzerOptions);
if (projectOrSolution.IsProject)
{
Project project = projectOrSolution.AsProject();
WriteLine($"Analyze '{project.Name}'", ConsoleColor.Cyan, Verbosity.Minimal);
Stopwatch stopwatch = Stopwatch.StartNew();
ProjectAnalysisResult result = await codeAnalyzer.AnalyzeProjectAsync(project, cancellationToken);
stopwatch.Stop();
WriteLine($"Done analyzing project '{project.FilePath}' in {stopwatch.Elapsed:mm\\:ss\\.ff}", Verbosity.Minimal);
if (Options.Output != null &&
result.Diagnostics.Any())
{
DiagnosticXmlSerializer.Serialize(result, project, Options.Output, culture);
}
}
else
{
Solution solution = projectOrSolution.AsSolution();
ImmutableArray <ProjectAnalysisResult> results = await codeAnalyzer.AnalyzeSolutionAsync(solution, cancellationToken);
if (Options.Output != null &&
results.Any(f => f.Diagnostics.Any()))
{
DiagnosticXmlSerializer.Serialize(results, solution, Options.Output, culture);
}
}
return(CommandResult.Success);
}