public RoslynDocumentProvider( IVisualStudioHostProjectContainer projectContainer, IServiceProvider serviceProvider, IDocumentTrackingService documentTrackingService = null) : base(projectContainer, serviceProvider, signUpForFileChangeNotification: true) { _documentTrackingService = documentTrackingService as VisualStudioDocumentTrackingService; }
public VisualStudioErrorReportingService( VisualStudioWorkspaceImpl workspace, IForegroundNotificationService foregroundNotificationService, IAsynchronousOperationListener listener) { _workspace = workspace; _foregroundNotificationService = foregroundNotificationService; _listener = listener; _documentTrackingService = workspace.Services.GetService<IDocumentTrackingService>(); }
public ActiveProjectCacheManager(IDocumentTrackingService documentTrackingService, ProjectCacheService projectCacheService) { _documentTrackingService = documentTrackingService; _projectCacheService = projectCacheService; if (documentTrackingService != null) { documentTrackingService.ActiveDocumentChanged += UpdateCache; UpdateCache(null, documentTrackingService.GetActiveDocument()); } }
public WorkCoordinator( IAsynchronousOperationListener listener, IEnumerable <Lazy <IIncrementalAnalyzerProvider, IncrementalAnalyzerProviderMetadata> > analyzerProviders, bool initializeLazily, Registration registration) { _logAggregator = new LogAggregator(); _registration = registration; _gate = new object(); _listener = listener; _optionService = _registration.GetService <IOptionService>(); _documentTrackingService = _registration.GetService <IDocumentTrackingService>(); // event and worker queues _shutdownNotificationSource = new CancellationTokenSource(); _shutdownToken = _shutdownNotificationSource.Token; _eventProcessingQueue = new SimpleTaskQueue(TaskScheduler.Default); var activeFileBackOffTimeSpanInMS = _optionService.GetOption(InternalSolutionCrawlerOptions.ActiveFileWorkerBackOffTimeSpanInMS); var allFilesWorkerBackOffTimeSpanInMS = _optionService.GetOption(InternalSolutionCrawlerOptions.AllFilesWorkerBackOffTimeSpanInMS); var entireProjectWorkerBackOffTimeSpanInMS = _optionService.GetOption(InternalSolutionCrawlerOptions.EntireProjectWorkerBackOffTimeSpanInMS); _documentAndProjectWorkerProcessor = new IncrementalAnalyzerProcessor( listener, analyzerProviders, initializeLazily, _registration, activeFileBackOffTimeSpanInMS, allFilesWorkerBackOffTimeSpanInMS, entireProjectWorkerBackOffTimeSpanInMS, _shutdownToken); var semanticBackOffTimeSpanInMS = _optionService.GetOption(InternalSolutionCrawlerOptions.SemanticChangeBackOffTimeSpanInMS); var projectBackOffTimeSpanInMS = _optionService.GetOption(InternalSolutionCrawlerOptions.ProjectPropagationBackOffTimeSpanInMS); _semanticChangeProcessor = new SemanticChangeProcessor(listener, _registration, _documentAndProjectWorkerProcessor, semanticBackOffTimeSpanInMS, projectBackOffTimeSpanInMS, _shutdownToken); // if option is on if (_optionService.GetOption(InternalSolutionCrawlerOptions.SolutionCrawler)) { _registration.Workspace.WorkspaceChanged += OnWorkspaceChanged; _registration.Workspace.DocumentOpened += OnDocumentOpened; _registration.Workspace.DocumentClosed += OnDocumentClosed; } // subscribe to option changed event after all required fields are set // otherwise, we can get null exception when running OnOptionChanged handler _optionService.OptionChanged += OnOptionChanged; // subscribe to active document changed event for active file background analysis scope. if (_documentTrackingService != null) { _lastActiveDocument = _documentTrackingService.GetActiveDocument(_registration.Workspace.CurrentSolution); _documentTrackingService.ActiveDocumentChanged += OnActiveDocumentChanged; } }
private async Task SearchProjectsInPriorityOrder(IDocumentTrackingService docTrackingService) { var processedProjects = new HashSet <Project>(); var activeDocOpt = docTrackingService.GetActiveDocument(_solution); var visibleDocs = docTrackingService.GetVisibleDocuments(_solution) .Where(d => d != activeDocOpt) .ToImmutableArray(); // First, if there's an active document, search that project first, prioritizing // that active document and all visible documents from it. if (activeDocOpt != null) { var activeProject = activeDocOpt.Project; processedProjects.Add(activeProject); var visibleDocsFromProject = visibleDocs.Where(d => d.Project == activeProject); var priorityDocs = ImmutableArray.Create(activeDocOpt).AddRange(visibleDocsFromProject); // Search the active project first. That way we can deliver results that are // closer in scope to the user quicker without forcing them to do something like // NavToInCurrentDoc await Task.Run(() => SearchAsync(activeProject, priorityDocs), _cancellationToken).ConfigureAwait(false); } // Now, process all visible docs that were not from the active project. var tasks = new List <Task>(); foreach (var(currentProject, priorityDocs) in visibleDocs.GroupBy(d => d.Project)) { // make sure we only process this project if we didn't already process it above. if (processedProjects.Add(currentProject)) { tasks.Add(Task.Run(() => SearchAsync(currentProject, priorityDocs.ToImmutableArray()), _cancellationToken)); } } await Task.WhenAll(tasks).ConfigureAwait(false); // Now, process the remainder of projects tasks.Clear(); foreach (var currentProject in _solution.Projects) { // make sure we only process this project if we didn't already process it above. if (processedProjects.Add(currentProject)) { tasks.Add(Task.Run(() => SearchAsync(currentProject, ImmutableArray <Document> .Empty), _cancellationToken)); } } await Task.WhenAll(tasks).ConfigureAwait(false); }
public FxCopAnalyzersSuggestedActionCallback( IThreadingContext threadingContext, VisualStudioWorkspace workspace, SVsServiceProvider serviceProvider) : base(threadingContext) { _workspace = workspace; _serviceProvider = serviceProvider; _documentTrackingService = workspace.Services.GetService <IDocumentTrackingService>(); _packageInstallerService = workspace.Services.GetService <IPackageInstallerService>(); _workspace.WorkspaceChanged += OnWorkspaceChanged; }
public ActiveProjectCacheManager( IDocumentTrackingService documentTrackingService, ProjectCacheService projectCacheService ) { _projectCacheService = projectCacheService; if (documentTrackingService != null) { documentTrackingService.ActiveDocumentChanged += UpdateCache; UpdateCache(null, documentTrackingService.TryGetActiveDocument()); } }
public NavigateToItemProvider( Workspace workspace, IAsynchronousOperationListener asyncListener, IDocumentTrackingService documentTrackingService) { Contract.ThrowIfNull(workspace); Contract.ThrowIfNull(asyncListener); _workspace = workspace; _asyncListener = asyncListener; _documentTrackingService = documentTrackingService; _displayFactory = new NavigateToItemDisplayFactory(); }
public BackgroundParser(Workspace workspace) { _workspace = workspace; var listenerProvider = workspace.Services.GetRequiredService <IWorkspaceAsynchronousOperationListenerProvider>(); _taskQueue = new TaskQueue(listenerProvider.GetListener(), TaskScheduler.Default); _documentTrackingService = workspace.Services.GetService <IDocumentTrackingService>(); _workspace.WorkspaceChanged += OnWorkspaceChanged; workspace.DocumentOpened += OnDocumentOpened; workspace.DocumentClosed += OnDocumentClosed; }
public BackgroundParser(Workspace workspace) { _workspace = workspace; var taskSchedulerFactory = workspace.Services.GetService <IWorkspaceTaskSchedulerFactory>(); _taskScheduler = taskSchedulerFactory.CreateBackgroundTaskScheduler(); _documentTrackingService = workspace.Services.GetService <IDocumentTrackingService>(); _workspace.WorkspaceChanged += OnWorkspaceChanged; workspace.DocumentOpened += OnDocumentOpened; workspace.DocumentClosed += OnDocumentClosed; }
public DiagnosticIncrementalAnalyzer( DiagnosticAnalyzerService analyzerService, int correlationId, Workspace workspace, DiagnosticAnalyzerInfoCache analyzerInfoCache) { Contract.ThrowIfNull(analyzerService); AnalyzerService = analyzerService; Workspace = workspace; _documentTrackingService = workspace.Services.GetRequiredService <IDocumentTrackingService>(); _correlationId = correlationId; _stateManager = new StateManager(workspace, analyzerInfoCache); _stateManager.ProjectAnalyzerReferenceChanged += OnProjectAnalyzerReferenceChanged; _telemetry = new DiagnosticAnalyzerTelemetry(); _diagnosticAnalyzerRunner = new InProcOrRemoteHostAnalyzerRunner(analyzerInfoCache, analyzerService.Listener); _projectCompilationsWithAnalyzers = new ConditionalWeakTable <Project, CompilationWithAnalyzers?>(); }
public IncrementalAnalyzerProcessor( IAsynchronousOperationListener listener, IEnumerable <Lazy <IIncrementalAnalyzerProvider, IncrementalAnalyzerProviderMetadata> > analyzerProviders, bool initializeLazily, Registration registration, int highBackOffTimeSpanInMs, int normalBackOffTimeSpanInMs, int lowBackOffTimeSpanInMs, CancellationToken shutdownToken) { _logAggregator = new LogAggregator(); _listener = listener; _registration = registration; _cacheService = registration.GetService <IProjectCacheService>(); _lazyDiagnosticAnalyzerService = new Lazy <IDiagnosticAnalyzerService?>(() => GetDiagnosticAnalyzerService(analyzerProviders)); var analyzersGetter = new AnalyzersGetter(analyzerProviders); // create analyzers lazily. var lazyActiveFileAnalyzers = new Lazy <ImmutableArray <IIncrementalAnalyzer> >(() => GetIncrementalAnalyzers(_registration, analyzersGetter, onlyHighPriorityAnalyzer: true)); var lazyAllAnalyzers = new Lazy <ImmutableArray <IIncrementalAnalyzer> >(() => GetIncrementalAnalyzers(_registration, analyzersGetter, onlyHighPriorityAnalyzer: false)); if (!initializeLazily) { // realize all analyzer right away _ = lazyActiveFileAnalyzers.Value; _ = lazyAllAnalyzers.Value; } // event and worker queues _documentTracker = _registration.GetService <IDocumentTrackingService>(); var globalNotificationService = _registration.GetService <IGlobalOperationNotificationService>(); _highPriorityProcessor = new HighPriorityProcessor(listener, this, lazyActiveFileAnalyzers, highBackOffTimeSpanInMs, shutdownToken); _normalPriorityProcessor = new NormalPriorityProcessor(listener, this, lazyAllAnalyzers, globalNotificationService, normalBackOffTimeSpanInMs, shutdownToken); _lowPriorityProcessor = new LowPriorityProcessor(listener, this, lazyAllAnalyzers, globalNotificationService, lowBackOffTimeSpanInMs, shutdownToken); }
protected AbstractVisualStudioErrorTaskList( SVsServiceProvider serviceProvider, VisualStudioWorkspace workspace, IForegroundNotificationService notificationService, IDiagnosticService diagnosticService, IEnumerable <Lazy <IAsynchronousOperationListener, FeatureMetadata> > asyncListeners) : base(serviceProvider, notificationService, FeatureAttribute.ErrorList, asyncListeners) { _gate = new object(); _workspace = workspace; // we should have document tracking service in visual studio host _documentTracker = _workspace.Services.GetService <IDocumentTrackingService>(); Contract.ThrowIfNull(_documentTracker); _taskQueue = new SimpleTaskQueue(TaskScheduler.Default); _reportedItemsMap = new Dictionary <object, VisualStudioTaskItem[]>(); _notReportedProjectItemsMap = new Dictionary <ProjectId, Dictionary <object, VisualStudioTaskItem[]> >(); _notReportedDocumentItemMap = new Dictionary <DocumentId, Dictionary <object, VisualStudioTaskItem[]> >(); _openedFiles = new HashSet <DocumentId>(); _inProcessSet = new HashSet <object>(); _lastNewItemAddedOrRemoved = Environment.TickCount; _lastReported = Environment.TickCount; _reportRequestRunning = false; _reportedCount = 0; if (ErrorListInstalled) { return; } // this should be called after all fields are initialized InitializeTaskList(); diagnosticService.DiagnosticsUpdated += this.OnDiagnosticUpdated; }
public IncrementalAnalyzerProcessor( IAsynchronousOperationListener listener, IEnumerable <Lazy <IIncrementalAnalyzerProvider, IncrementalAnalyzerProviderMetadata> > analyzerProviders, Registration registration, int highBackOffTimeSpanInMs, int normalBackOffTimeSpanInMs, int lowBackOffTimeSpanInMs, CancellationToken shutdownToken) { _logAggregator = new LogAggregator(); _listener = listener; _registration = registration; var lazyActiveFileAnalyzers = new Lazy <ImmutableArray <IIncrementalAnalyzer> >(() => GetActiveFileIncrementalAnalyzers(_registration, analyzerProviders)); var lazyAllAnalyzers = new Lazy <ImmutableArray <IIncrementalAnalyzer> >(() => GetIncrementalAnalyzers(_registration, analyzerProviders)); // event and worker queues _documentTracker = _registration.GetService <IDocumentTrackingService>(); var globalNotificationService = _registration.GetService <IGlobalOperationNotificationService>(); _highPriorityProcessor = new HighPriorityProcessor(listener, this, lazyActiveFileAnalyzers, highBackOffTimeSpanInMs, shutdownToken); _normalPriorityProcessor = new NormalPriorityProcessor(listener, this, lazyAllAnalyzers, globalNotificationService, normalBackOffTimeSpanInMs, shutdownToken); _lowPriorityProcessor = new LowPriorityProcessor(listener, this, lazyAllAnalyzers, globalNotificationService, lowBackOffTimeSpanInMs, shutdownToken); }
private static bool AnalysisEnabled(TextDocument document, IDocumentTrackingService documentTrackingService) { if (document.Services.GetService <DocumentPropertiesService>()?.DiagnosticsLspClientName != null) { // This is a generated Razor document, and they want diagnostics, so let's report it return(true); } if (!document.SupportsDiagnostics()) { return(false); } // change it to check active file (or visible files), not open files if active file tracking is enabled. // otherwise, use open file. if (SolutionCrawlerOptions.GetBackgroundAnalysisScope(document.Project) == BackgroundAnalysisScope.ActiveFile) { return(documentTrackingService.TryGetActiveDocument() == document.Id); } else { return(document.IsOpen()); } }
public IncrementalAnalyzerProcessor( IAsynchronousOperationListener listener, int correlationId, Workspace workspace, IEnumerable <Lazy <IIncrementalAnalyzerProvider, IncrementalAnalyzerProviderMetadata> > analyzerProviders, int highBackOffTimeSpanInMs, int normalBackOffTimeSpanInMs, int lowBackOffTimeSpanInMs, CancellationToken shutdownToken) { this.logAggregator = new LogAggregator(); this.listener = listener; var lazyActiveFileAnalyzers = new Lazy <ImmutableArray <IIncrementalAnalyzer> >(() => GetActiveFileIncrementalAnalyzers(correlationId, workspace, analyzerProviders)); var lazyAllAnalyzers = new Lazy <ImmutableArray <IIncrementalAnalyzer> >(() => GetIncrementalAnalyzers(correlationId, workspace, analyzerProviders)); // event and worker queues this.correlationId = correlationId; this.workspace = workspace; this.documentTracker = workspace.Services.GetService <IDocumentTrackingService>(); var globalNotificationService = workspace.Services.GetService <IGlobalOperationNotificationService>(); this.highPriorityProcessor = new HighPriorityProcessor(listener, this, lazyActiveFileAnalyzers, highBackOffTimeSpanInMs, shutdownToken); this.normalPriorityProcessor = new NormalPriorityProcessor(listener, this, lazyAllAnalyzers, globalNotificationService, normalBackOffTimeSpanInMs, shutdownToken); this.lowPriorityProcessor = new LowPriorityProcessor(listener, this, lazyAllAnalyzers, globalNotificationService, lowBackOffTimeSpanInMs, shutdownToken); }
internal void InitializeWorkspace( TestWorkspace workspace, IDocumentTrackingService documentTrackingService) { _provider = new NavigateToItemProvider(workspace, AsynchronousOperationListenerProvider.NullListener, documentTrackingService); _aggregator = new NavigateToTestAggregator(_provider); }
public DocumentTrackingService(IDocumentTrackingService inner) { _inner = inner; }
public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices) { return(_singleton ?? (_singleton = new VisualStudioDocumentTrackingService(_serviceProvider))); }
public VisualStudioErrorReportingService(VisualStudioWorkspaceImpl workspace, IForegroundNotificationService foregroundNotificationService) { _workspace = workspace; _foregroundNotificationService = foregroundNotificationService; _documentTrackingService = workspace.Services.GetService <IDocumentTrackingService>(); }
public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices) { return _singleton ?? (_singleton = new VisualStudioDocumentTrackingService(_serviceProvider)); }
/// <summary> /// Get a read only collection of all the unique visible documents in the workspace that are /// contained within <paramref name="solution"/>. /// </summary> public static ImmutableArray <Document> GetVisibleDocuments(this IDocumentTrackingService service, Solution solution) => service.GetVisibleDocuments() .Select(d => solution.GetDocument(d)) .WhereNotNull() .Distinct() .ToImmutableArray();
/// <summary> /// Gets the active <see cref="Document"/> the user is currently working in. May be null if /// there is no active document or the active document is not in this <paramref name="solution"/>. /// </summary> public static Document GetActiveDocument(this IDocumentTrackingService service, Solution solution) { // Note: GetDocument checks that the DocId is contained in the solution, and returns null if not. return(solution.GetDocument(service.TryGetActiveDocument())); }
public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices) { return(service ?? (service = new MonoDevelopDocumentTrackingService())); }