private void RaiseAnalyzerChangedWarning(ProjectId projectId, string analyzerPath)
{
var messageArguments = new string[] { analyzerPath };
if (DiagnosticData.TryCreate(_analyzerChangedRule, messageArguments, projectId, _workspace, out var diagnostic))
{
_updateSource.UpdateDiagnosticsForProject(projectId, Tuple.Create(s_analyzerChangedErrorId, analyzerPath), SpecializedCollections.SingletonEnumerable(diagnostic));
}
}
// Method is static to prevent accidental use of mutable state in this class
private static void AnalyzeAndReportConflictsInSolution(
Solution solution,
ImmutableHashSet <string> currentAnalyzerPaths,
HostDiagnosticUpdateSource hostDiagnosticUpdateSource,
CancellationToken cancellationToken)
{
var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies().Select(assembly => AssemblyIdentity.FromAssemblyDefinition(assembly));
var loadedAssembliesList = new IgnorableAssemblyIdentityList(loadedAssemblies);
var ignorableAssemblyLists = new[] { s_systemPrefixList, s_codeAnalysisPrefixList, s_explicitlyIgnoredAssemblyList, s_assembliesIgnoredByNameList, loadedAssembliesList };
cancellationToken.ThrowIfCancellationRequested();
var results = AnalyzerDependencyChecker.ComputeDependencyConflicts(currentAnalyzerPaths, ignorableAssemblyLists, s_bindingRedirectionService, cancellationToken);
var builder = ImmutableArray.CreateBuilder <DiagnosticData>();
var conflicts = results.Conflicts;
var missingDependencies = results.MissingDependencies;
foreach (var project in solution.Projects)
{
builder.Clear();
// If our analysis has been cancelled, it means another request has been queued behind us; thus it's OK to stop
// doing the analysis now and let that other one fix up any stale results.
cancellationToken.ThrowIfCancellationRequested();
var analyzerFilePaths = new HashSet <string>(
project.AnalyzerReferences
.OfType <AnalyzerFileReference>()
.Select(f => f.FullPath),
StringComparer.OrdinalIgnoreCase);
foreach (var conflict in conflicts)
{
if (analyzerFilePaths.Contains(conflict.AnalyzerFilePath1) ||
analyzerFilePaths.Contains(conflict.AnalyzerFilePath2))
{
var messageArguments = new string[] { conflict.AnalyzerFilePath1, conflict.AnalyzerFilePath2, conflict.Identity.ToString() };
if (DiagnosticData.TryCreate(s_analyzerDependencyConflictRule, messageArguments, project.Id, solution.Workspace, out var diagnostic))
{
builder.Add(diagnostic);
}
}
}
foreach (var missingDependency in missingDependencies)
{
if (analyzerFilePaths.Contains(missingDependency.AnalyzerPath))
{
var messageArguments = new string[] { missingDependency.AnalyzerPath, missingDependency.DependencyIdentity.ToString() };
if (DiagnosticData.TryCreate(s_missingAnalyzerReferenceRule, messageArguments, project.Id, solution.Workspace, out var diagnostic))
{
builder.Add(diagnostic);
}
}
}
hostDiagnosticUpdateSource.UpdateDiagnosticsForProject(project.Id, s_dependencyConflictErrorId, builder.ToImmutable());
}
foreach (var conflict in conflicts)
{
LogConflict(conflict);
}
foreach (var missingDependency in missingDependencies)
{
LogMissingDependency(missingDependency);
}
}
public async void CheckForConflictsAsync()
{
AnalyzerDependencyResults results = null;
try
{
results = await GetConflictsAsync().ConfigureAwait(continueOnCapturedContext: true);
}
catch
{
return;
}
if (results == null)
{
return;
}
var builder = ImmutableArray.CreateBuilder <DiagnosticData>();
var conflicts = results.Conflicts;
var missingDependencies = results.MissingDependencies;
foreach (var project in _workspace.ProjectTracker.Projects)
{
builder.Clear();
foreach (var conflict in conflicts)
{
if (project.CurrentProjectAnalyzersContains(conflict.AnalyzerFilePath1) ||
project.CurrentProjectAnalyzersContains(conflict.AnalyzerFilePath2))
{
var messageArguments = new string[] { conflict.AnalyzerFilePath1, conflict.AnalyzerFilePath2, conflict.Identity.ToString() };
DiagnosticData diagnostic;
if (DiagnosticData.TryCreate(_analyzerDependencyConflictRule, messageArguments, project.Id, _workspace, out diagnostic))
{
builder.Add(diagnostic);
}
}
}
foreach (var missingDependency in missingDependencies)
{
if (project.CurrentProjectAnalyzersContains(missingDependency.AnalyzerPath))
{
var messageArguments = new string[] { missingDependency.AnalyzerPath, missingDependency.DependencyIdentity.ToString() };
DiagnosticData diagnostic;
if (DiagnosticData.TryCreate(_missingAnalyzerReferenceRule, messageArguments, project.Id, _workspace, out diagnostic))
{
builder.Add(diagnostic);
}
}
}
_updateSource.UpdateDiagnosticsForProject(project.Id, s_dependencyConflictErrorId, builder.ToImmutable());
}
foreach (var conflict in conflicts)
{
LogConflict(conflict);
}
foreach (var missingDependency in missingDependencies)
{
LogMissingDependency(missingDependency);
}
}