public void Reanalyze(Workspace workspace, IIncrementalAnalyzer analyzer, IEnumerable<ProjectId> projectIds, IEnumerable<DocumentId> documentIds)
{
lock (_gate)
{
var coordinator = default(WorkCoordinator);
if (!_documentWorkCoordinatorMap.TryGetValue(workspace, out coordinator))
{
throw new ArgumentException("workspace");
}
// no specific projects or documents provided
if (projectIds == null && documentIds == null)
{
coordinator.Reanalyze(analyzer, workspace.CurrentSolution.Projects.SelectMany(p => p.DocumentIds).ToSet());
return;
}
// specific documents provided
if (projectIds == null)
{
coordinator.Reanalyze(analyzer, documentIds.ToSet());
return;
}
var solution = workspace.CurrentSolution;
var set = new HashSet<DocumentId>(documentIds ?? SpecializedCollections.EmptyEnumerable<DocumentId>());
set.Union(projectIds.Select(id => solution.GetProject(id)).SelectMany(p => p.DocumentIds));
coordinator.Reanalyze(analyzer, set);
}
}
public void AddAnalyzer(IIncrementalAnalyzer analyzer)
{
lock (_gate)
{
var analyzers = _lazyAnalyzers.Value;
_lazyAnalyzers = new Lazy<ImmutableArray<IIncrementalAnalyzer>>(() => analyzers.Add(analyzer));
}
}
public void Reanalyze(Workspace workspace, IIncrementalAnalyzer analyzer, IEnumerable<ProjectId> projectIds = null, IEnumerable<DocumentId> documentIds = null, bool highPriority = false)
{
// if solution crawler doesn't exist for the given workspace. don't do anything
var registration = workspace.Services.GetService<ISolutionCrawlerRegistrationService>() as SolutionCrawlerRegistrationService;
if (registration != null)
{
registration.Reanalyze(workspace, analyzer, projectIds, documentIds, highPriority);
}
}
public static void LogReanalyze(int correlationId, IIncrementalAnalyzer analyzer, IEnumerable<DocumentId> documentIds)
{
Logger.Log(FunctionId.WorkCoordinatorRegistrationService_Reanalyze, KeyValueLogMessage.Create(m =>
{
m[Id] = correlationId;
m[Analyzer] = analyzer.ToString();
m[DocumentCount] = documentIds == null ? 0 : documentIds.Count();
}));
}
public void AddAnalyzer(IIncrementalAnalyzer analyzer, bool highPriorityForActiveFile)
{
// add analyzer
_documentAndProjectWorkerProcessor.AddAnalyzer(analyzer, highPriorityForActiveFile);
// and ask to re-analyze whole solution for the given analyzer
var set = _registration.CurrentSolution.Projects.SelectMany(p => p.DocumentIds).ToSet();
Reanalyze(analyzer, set);
}
public void AddAnalyzer(IIncrementalAnalyzer analyzer, bool highPriorityForActiveFile)
{
if (highPriorityForActiveFile)
{
_highPriorityProcessor.AddAnalyzer(analyzer);
}
_normalPriorityProcessor.AddAnalyzer(analyzer);
_lowPriorityProcessor.AddAnalyzer(analyzer);
}
private async Task EnqueueWorkItemAsync(IIncrementalAnalyzer analyzer, ReanalyzeScope scope, bool highPriority)
{
var solution = _registration.GetSolutionToAnalyze();
var invocationReasons = highPriority ? InvocationReasons.ReanalyzeHighPriority : InvocationReasons.Reanalyze;
foreach (var(project, documentId) in scope.GetDocumentIds(solution))
{
await EnqueueWorkItemAsync(analyzer, project, documentId, document : null, invocationReasons).ConfigureAwait(false);
}
}
public void AddAnalyzer(IIncrementalAnalyzer analyzer)
{
lock (_gate)
{
var analyzers = _lazyAnalyzers.Value;
_lazyAnalyzers = new Lazy <ImmutableArray <IIncrementalAnalyzer> >(
() => analyzers.Add(analyzer)
);
}
}
public static void LogReanalyze(int correlationId, IIncrementalAnalyzer analyzer, IEnumerable <DocumentId> documentIds, bool highPriority)
{
Logger.Log(FunctionId.WorkCoordinatorRegistrationService_Reanalyze, KeyValueLogMessage.Create(m =>
{
m[Id] = correlationId;
m[Analyzer] = analyzer.ToString();
m[DocumentCount] = documentIds == null ? 0 : documentIds.Count();
m[HighPriority] = highPriority;
}));
}
public void AddAnalyzer(IIncrementalAnalyzer analyzer, bool highPriorityForActiveFile)
{
// add analyzer
_documentAndProjectWorkerProcessor.AddAnalyzer(analyzer, highPriorityForActiveFile);
// and ask to re-analyze whole solution for the given analyzer
var set = _registration.CurrentSolution.Projects.SelectMany(p => p.DocumentIds).ToSet();
Reanalyze(analyzer, set);
}
public void AddAnalyzer(IIncrementalAnalyzer analyzer, bool highPriorityForActiveFile)
{
// add analyzer
_documentAndProjectWorkerProcessor.AddAnalyzer(analyzer, highPriorityForActiveFile);
// and ask to re-analyze whole solution for the given analyzer
var scope = new ReanalyzeScope(_registration.GetSolutionToAnalyze().Id);
Reanalyze(analyzer, scope);
}
public static BackgroundAnalysisScope GetOverriddenBackgroundAnalysisScope(this IIncrementalAnalyzer incrementalAnalyzer, OptionSet options, BackgroundAnalysisScope defaultBackgroundAnalysisScope)
{
// Unit testing analyzer has special semantics for analysis scope.
if (incrementalAnalyzer is UnitTestingIncrementalAnalyzer)
{
return(UnitTestingIncrementalAnalyzer.GetBackgroundAnalysisScope(options));
}
return(defaultBackgroundAnalysisScope);
}
public void Reanalyze(Workspace workspace, IIncrementalAnalyzer analyzer, IEnumerable <ProjectId> projectIds = null, IEnumerable <DocumentId> documentIds = null)
{
// if solution crawler doesn't exist for the given workspace. don't do anything
var registration = workspace.Services.GetService <ISolutionCrawlerRegistrationService>() as SolutionCrawlerRegistrationService;
if (registration != null)
{
registration.Reanalyze(workspace, analyzer, projectIds, documentIds);
}
}
private async Task EnqueueWorkItemAsync(IIncrementalAnalyzer analyzer, ReanalyzeScope scope, bool highPriority)
{
var solution = _registration.CurrentSolution;
var invocationReasons = highPriority ? InvocationReasons.ReanalyzeHighPriority : InvocationReasons.Reanalyze;
foreach (var document in scope.GetDocuments(solution))
{
await EnqueueWorkItemAsync(analyzer, document, invocationReasons).ConfigureAwait(false);
}
}
private async Task EnqueueWorkItemAsync(
IIncrementalAnalyzer analyzer, Project project, DocumentId documentId, Document?document, InvocationReasons invocationReasons)
{
var priorityService = project.GetLanguageService <IWorkCoordinatorPriorityService>();
var isLowPriority = priorityService != null && await priorityService.IsLowPriorityAsync(
GetRequiredDocument(project, documentId, document), _shutdownToken).ConfigureAwait(false);
_documentAndProjectWorkerProcessor.Enqueue(
new WorkItem(documentId, project.Language, invocationReasons,
isLowPriority, analyzer, _listener.BeginAsyncOperation("WorkItem")));
}
static async Task AnalyzeSyntaxAsync(IIncrementalAnalyzer analyzer, TextDocument textDocument, InvocationReasons reasons, CancellationToken cancellationToken)
{
if (textDocument is Document document)
{
await analyzer.AnalyzeSyntaxAsync((Document)document, reasons, cancellationToken).ConfigureAwait(false);
}
else if (analyzer is IIncrementalAnalyzer2 analyzer2)
{
await analyzer2.AnalyzeNonSourceDocumentAsync(textDocument, reasons, cancellationToken).ConfigureAwait(false);
}
}
static async Task DocumentResetAsync(IIncrementalAnalyzer analyzer, TextDocument textDocument, CancellationToken cancellationToken)
{
if (textDocument is Document document)
{
await analyzer.DocumentResetAsync(document, cancellationToken).ConfigureAwait(false);
}
else if (analyzer is IIncrementalAnalyzer2 analyzer2)
{
await analyzer2.NonSourceDocumentResetAsync(textDocument, cancellationToken).ConfigureAwait(false);
}
}
private bool TryGetAnalyzer(Project project, out IIncrementalAnalyzer analyzer)
{
if (!this.Analyzers.TryGetValue(project.Language, out var lazyAnalyzer))
{
analyzer = null;
return(false);
}
analyzer = lazyAnalyzer.Value;
return(true);
}
private bool TryGetAnalyzer(Project project, out IIncrementalAnalyzer analyzer)
{
Lazy<IIncrementalAnalyzer> lazyAnalyzer;
if (!this.Analyzers.TryGetValue(project.Language, out lazyAnalyzer))
{
analyzer = null;
return false;
}
analyzer = lazyAnalyzer.Value;
return true;
}
public void Reanalyze(IIncrementalAnalyzer analyzer, ISet <DocumentId> documentIds, bool highPriority = false)
{
var asyncToken = _listener.BeginAsyncOperation("Reanalyze");
_eventProcessingQueue.ScheduleTask(
() => EnqueueWorkItemAsync(analyzer, documentIds, highPriority), _shutdownToken).CompletesAsyncOperation(asyncToken);
if (documentIds?.Count > 1)
{
// log big reanalysis request from things like fix all, suppress all or option changes
// we are not interested in 1 file re-analysis request which can happen from like venus typing
SolutionCrawlerLogger.LogReanalyze(CorrelationId, analyzer, documentIds, highPriority);
}
}
public void Reanalyze(IIncrementalAnalyzer analyzer, ReanalyzeScope scope, bool highPriority = false)
{
_eventProcessingQueue.ScheduleTask("Reanalyze",
() => EnqueueWorkItemAsync(analyzer, scope, highPriority), _shutdownToken);
if (scope.HasMultipleDocuments)
{
// log big reanalysis request from things like fix all, suppress all or option changes
// we are not interested in 1 file re-analysis request which can happen from like venus typing
var solution = _registration.CurrentSolution;
SolutionCrawlerLogger.LogReanalyze(
CorrelationId, analyzer, scope.GetDocumentCount(solution), scope.GetLanguagesStringForTelemetry(solution), highPriority);
}
}
public static void LogReanalyze(
int correlationId,
IIncrementalAnalyzer analyzer,
int documentCount,
string languages,
bool highPriority)
{
Logger.Log(FunctionId.WorkCoordinatorRegistrationService_Reanalyze, KeyValueLogMessage.Create(m =>
{
m[Id] = correlationId;
m[Analyzer] = analyzer.ToString();
m[DocumentCount] = documentCount;
m[HighPriority] = highPriority;
m[Languages] = languages;
}));
}
private void EnqueueWorkItem(IIncrementalAnalyzer analyzer, IEnumerable <DocumentId> documentIds)
{
var solution = _workspace.CurrentSolution;
foreach (var documentId in documentIds)
{
var document = solution.GetDocument(documentId);
if (document == null)
{
continue;
}
var priorityService = document.GetLanguageService <IWorkCoordinatorPriorityService>();
_documentAndProjectWorkerProcessor.Enqueue(
new WorkItem(documentId, document.Project.Language, InvocationReasons.Reanalyze,
priorityService != null && priorityService.IsLowPriority(document),
analyzer, _listener.BeginAsyncOperation("WorkItem")));
}
}
private async Task EnqueueWorkItemAsync(IIncrementalAnalyzer analyzer, IEnumerable <DocumentId> documentIds)
{
var solution = _registration.CurrentSolution;
foreach (var documentId in documentIds)
{
var document = solution.GetDocument(documentId);
if (document == null)
{
continue;
}
var priorityService = document.GetLanguageService <IWorkCoordinatorPriorityService>();
var isLowPriority = priorityService != null && await priorityService.IsLowPriorityAsync(document, _shutdownToken).ConfigureAwait(false);
_documentAndProjectWorkerProcessor.Enqueue(
new WorkItem(documentId, document.Project.Language, InvocationReasons.Reanalyze,
isLowPriority, analyzer, _listener.BeginAsyncOperation("WorkItem")));
}
}
public void Reanalyze(Workspace workspace, IIncrementalAnalyzer analyzer, IEnumerable <ProjectId>?projectIds, IEnumerable <DocumentId>?documentIds, bool highPriority)
{
lock (_gate)
{
if (!_documentWorkCoordinatorMap.TryGetValue(workspace, out var coordinator))
{
// this can happen if solution crawler is already unregistered from workspace.
// one of those example will be VS shutting down so roslyn package is disposed but there is a pending
// async operation.
return;
}
// no specific projects or documents provided
if (projectIds == null && documentIds == null)
{
coordinator.Reanalyze(analyzer, new ReanalyzeScope(workspace.CurrentSolution.Id), highPriority);
return;
}
coordinator.Reanalyze(analyzer, new ReanalyzeScope(projectIds, documentIds), highPriority);
}
}
public void Reanalyze(
Workspace workspace,
IIncrementalAnalyzer analyzer,
IEnumerable <ProjectId>?projectIds = null,
IEnumerable <DocumentId>?documentIds = null,
bool highPriority = false
)
{
// if solution crawler doesn't exist for the given workspace. don't do anything
if (
workspace.Services.GetService <ISolutionCrawlerRegistrationService>()
is SolutionCrawlerRegistrationService registration
)
{
registration.Reanalyze(
workspace,
analyzer,
projectIds,
documentIds,
highPriority
);
}
}
private void EnqueueWorkItem(IIncrementalAnalyzer analyzer, IEnumerable<DocumentId> documentIds)
{
var solution = _workspace.CurrentSolution;
foreach (var documentId in documentIds)
{
var document = solution.GetDocument(documentId);
if (document == null)
{
continue;
}
var priorityService = document.GetLanguageService<IWorkCoordinatorPriorityService>();
_documentAndProjectWorkerProcessor.Enqueue(
new WorkItem(documentId, document.Project.Language, InvocationReasons.Reanalyze,
priorityService != null && priorityService.IsLowPriority(document),
analyzer, _listener.BeginAsyncOperation("WorkItem")));
}
}
public WorkItem(
DocumentId documentId, string language, InvocationReasons invocationReasons, bool isLowPriority,
IIncrementalAnalyzer analyzer, IAsyncToken asyncToken)
: this(documentId, documentId.ProjectId, language, invocationReasons, isLowPriority,
null, analyzer == null ? ImmutableHashSet.Create<IIncrementalAnalyzer>() : ImmutableHashSet.Create<IIncrementalAnalyzer>(analyzer),
false, asyncToken)
{
}
public void Reanalyze(IIncrementalAnalyzer analyzer, IEnumerable<DocumentId> documentIds)
{
var asyncToken = _listener.BeginAsyncOperation("Reanalyze");
_eventProcessingQueue.ScheduleTask(
() => EnqueueWorkItemAsync(analyzer, documentIds), _shutdownToken).CompletesAsyncOperation(asyncToken);
SolutionCrawlerLogger.LogReanalyze(CorrelationId, analyzer, documentIds);
}
private async Task EnqueueWorkItemAsync(IIncrementalAnalyzer analyzer, IEnumerable<DocumentId> documentIds)
{
var solution = _registration.CurrentSolution;
foreach (var documentId in documentIds)
{
var document = solution.GetDocument(documentId);
if (document == null)
{
continue;
}
var priorityService = document.GetLanguageService<IWorkCoordinatorPriorityService>();
var isLowPriority = priorityService != null && await priorityService.IsLowPriorityAsync(document, _shutdownToken).ConfigureAwait(false);
_documentAndProjectWorkerProcessor.Enqueue(
new WorkItem(documentId, document.Project.Language, InvocationReasons.Reanalyze,
isLowPriority, analyzer, _listener.BeginAsyncOperation("WorkItem")));
}
}
public void Reanalyze(Workspace workspace, IIncrementalAnalyzer analyzer, IEnumerable<ProjectId> projectIds = null, IEnumerable<DocumentId> documentIds = null)
{
var registration = workspace.Services.GetService<IWorkCoordinatorRegistrationService>() as WorkCoordinatorRegistrationService;
if (registration != null)
{
registration.Reanalyze(workspace, analyzer, projectIds, documentIds);
}
}
private static async Task RunAllAnalysisAsync(IIncrementalAnalyzer analyzer, Document document)
{
await analyzer.AnalyzeSyntaxAsync(document, InvocationReasons.Empty, CancellationToken.None).ConfigureAwait(false);
await analyzer.AnalyzeDocumentAsync(document, bodyOpt: null, reasons: InvocationReasons.Empty, cancellationToken: CancellationToken.None).ConfigureAwait(false);
await analyzer.AnalyzeProjectAsync(document.Project, semanticsChanged: true, reasons: InvocationReasons.Empty, cancellationToken: CancellationToken.None).ConfigureAwait(false);
}
