public RemoteHostClientServiceFactory( [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners, IDiagnosticAnalyzerService analyzerService) { _listener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.RemoteHostClient); _analyzerService = analyzerService; }
public TagComputer( ITextBuffer subjectBuffer, IForegroundNotificationService notificationService, IAsynchronousOperationListener asyncListener, ClassificationTypeMap typeMap, SyntacticClassificationTaggerProvider taggerProvider, IViewSupportsClassificationService viewSupportsClassificationServiceOpt, ITextBufferAssociatedViewService associatedViewService, IEditorClassificationService editorClassificationService, string languageName) { _subjectBuffer = subjectBuffer; _notificationService = notificationService; _listener = asyncListener; _typeMap = typeMap; _taggerProvider = taggerProvider; _viewSupportsClassificationServiceOpt = viewSupportsClassificationServiceOpt; _associatedViewService = associatedViewService; _editorClassificationService = editorClassificationService; _languageName = languageName; _workQueue = new AsynchronousSerialWorkQueue(asyncListener); _reportChangeCancellationSource = new CancellationTokenSource(); _lastLineCache = new LastLineCache(); _workspaceRegistration = Workspace.GetWorkspaceRegistration(subjectBuffer.AsTextContainer()); _workspaceRegistration.WorkspaceChanged += OnWorkspaceRegistrationChanged; ConnectToWorkspace(_workspaceRegistration.Workspace); }
private static DiagnosticAnalyzerService CreateDiagnosticAnalyzerService( Dictionary<string, DiagnosticAnalyzer[]> analyzerMap, IAsynchronousOperationListener listener) { return analyzerMap == null || analyzerMap.Count == 0 ? new MyDiagnosticAnalyzerService(DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap(), listener: listener) : new MyDiagnosticAnalyzerService(analyzerMap.ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray()), listener: listener); }
public CallHierarchyProvider( [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners, IGlyphService glyphService) { _asyncListener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.CallHierarchy); this.GlyphService = glyphService; }
public VisualStudioRuleSetManager( IVsFileChangeEx fileChangeService, IForegroundNotificationService foregroundNotificationService, IAsynchronousOperationListener listener) { _fileChangeService = fileChangeService; _foregroundNotificationService = foregroundNotificationService; _listener = listener; }
public VisualStudioErrorReportingService( VisualStudioWorkspaceImpl workspace, IForegroundNotificationService foregroundNotificationService, IAsynchronousOperationListener listener) { _workspace = workspace; _foregroundNotificationService = foregroundNotificationService; _listener = listener; }
public Searcher( Solution solution, IAsynchronousOperationListener asyncListener, INavigateToItemDisplayFactory displayFactory, INavigateToCallback callback, string searchPattern, bool searchCurrentDocument, CancellationToken cancellationToken) { _solution = solution; _displayFactory = displayFactory; _callback = callback; _searchPattern = searchPattern; _searchCurrentDocument = searchCurrentDocument; _cancellationToken = cancellationToken; _progress = new ProgressTracker(callback.ReportProgress); _asyncListener = asyncListener; if (_searchCurrentDocument) { var documentService = _solution.Workspace.Services.GetService<IDocumentTrackingService>(); var activeId = documentService.GetActiveDocument(); _currentDocument = activeId != null ? _solution.GetDocument(activeId) : null; } }
public CodeModelIncrementalAnalyzerProvider( IForegroundNotificationService notificationService, [ImportMany]IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> listeners) { _listener = new AggregateAsynchronousOperationListener(listeners, FeatureAttribute.CodeModel); _notificationService = notificationService; }
public TagComputer( ITextBuffer subjectBuffer, IForegroundNotificationService notificationService, IAsynchronousOperationListener asyncListener, ClassificationTypeMap typeMap, SyntacticClassificationTaggerProvider taggerProvider) { _subjectBuffer = subjectBuffer; _notificationService = notificationService; _listener = asyncListener; _typeMap = typeMap; _taggerProvider = taggerProvider; _workQueue = new AsynchronousSerialWorkQueue(asyncListener); _reportChangeCancellationSource = new CancellationTokenSource(); _lastLineCache = new LastLineCache(); _workspaceRegistration = Workspace.GetWorkspaceRegistration(subjectBuffer.AsTextContainer()); _workspaceRegistration.WorkspaceChanged += OnWorkspaceRegistrationChanged; if (_workspaceRegistration.Workspace != null) { ConnectToWorkspace(_workspaceRegistration.Workspace); } }
public NavigationBarController( INavigationBarPresenter presenter, ITextBuffer subjectBuffer, IWaitIndicator waitIndicator, IAsynchronousOperationListener asyncListener) { _presenter = presenter; _subjectBuffer = subjectBuffer; _waitIndicator = waitIndicator; _asyncListener = asyncListener; _workspaceRegistration = Workspace.GetWorkspaceRegistration(subjectBuffer.AsTextContainer()); _workspaceRegistration.WorkspaceChanged += OnWorkspaceRegistrationChanged; presenter.CaretMoved += OnCaretMoved; presenter.ViewFocused += OnViewFocused; presenter.DropDownFocused += OnDropDownFocused; presenter.ItemSelected += OnItemSelected; subjectBuffer.PostChanged += OnSubjectBufferPostChanged; // Initialize the tasks to be an empty model so we never have to deal with a null case. _modelTask = Task.FromResult( new NavigationBarModel( SpecializedCollections.EmptyList<NavigationBarItem>(), default(VersionStamp), null)); _selectedItemInfoTask = Task.FromResult(new NavigationBarSelectedTypeAndMember(null, null)); if (_workspaceRegistration.Workspace != null) { ConnectToWorkspace(_workspaceRegistration.Workspace); } }
public TrackingSession(StateMachine stateMachine, SnapshotSpan snapshotSpan, IAsynchronousOperationListener asyncListener) { AssertIsForeground(); _asyncListener = asyncListener; _trackingSpan = snapshotSpan.Snapshot.CreateTrackingSpan(snapshotSpan.Span, SpanTrackingMode.EdgeInclusive); _cancellationTokenSource = new CancellationTokenSource(); _cancellationToken = _cancellationTokenSource.Token; if (snapshotSpan.Length > 0) { // If the snapshotSpan is nonempty, then the session began with a change that // was touching a word. Asynchronously determine whether that word was a // renamable identifier. If it is, alert the state machine so it can trigger // tagging. _originalName = snapshotSpan.GetText(); _isRenamableIdentifierTask = Task.Factory.SafeStartNewFromAsync( () => DetermineIfRenamableIdentifierAsync(snapshotSpan, initialCheck: true), _cancellationToken, TaskScheduler.Default); QueueUpdateToStateMachine(stateMachine, _isRenamableIdentifierTask); } else { // If the snapshotSpan is empty, that means text was added in a location that is // not touching an existing word, which happens a fair amount when writing new // code. In this case we already know that the user is not renaming an // identifier. _isRenamableIdentifierTask = s_notRenamableTask; } }
public StateMachine(ITextBuffer buffer, IInlineRenameService inlineRenameService, IAsynchronousOperationListener asyncListener) { _buffer = buffer; _buffer.Changed += Buffer_Changed; _inlineRenameService = inlineRenameService; _asyncListener = asyncListener; }
public StreamingFindReferencesPresenter( Shell.SVsServiceProvider serviceProvider, ITextBufferFactoryService textBufferFactoryService, IProjectionBufferFactoryService projectionBufferFactoryService, IEditorOptionsFactoryService editorOptionsFactoryService, ITextEditorFactoryService textEditorFactoryService, IContentTypeRegistryService contentTypeRegistryService, ClassificationTypeMap typeMap, IEditorFormatMapService formatMapService, [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners) { _serviceProvider = serviceProvider; _textBufferFactoryService = textBufferFactoryService; _projectionBufferFactoryService = projectionBufferFactoryService; _editorOptionsFactoryService = editorOptionsFactoryService; _contentTypeRegistryService = contentTypeRegistryService; _textEditorFactoryService = textEditorFactoryService; _typeMap = typeMap; _formatMapService = formatMapService; _asyncListener = new AggregateAsynchronousOperationListener( asyncListeners, FeatureAttribute.ReferenceHighlighting); _vsFindAllReferencesService = (IFindAllReferencesService)_serviceProvider.GetService(typeof(SVsFindAllReferences)); }
public SolutionCrawlerProgressReporter(IAsynchronousOperationListener listener) { _listener = listener; _eventQueue = new SimpleTaskQueue(TaskScheduler.Default); _eventMap = new EventMap(); _count = 0; }
public SuggestedActionWithPreview( Workspace workspace, ITextBuffer subjectBuffer, ICodeActionEditHandlerService editHandler, IWaitIndicator waitIndicator, CodeAction codeAction, object provider, IAsynchronousOperationListener operationListener) : base(workspace, subjectBuffer, editHandler, waitIndicator, codeAction, provider, operationListener, actionSets: null) { }
public AggregateAsynchronousOperationListener( IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> listeners, string featureName) { _listener = (from lazy in listeners where lazy.Metadata.FeatureName == featureName select lazy.Value).SingleOrDefault(); }
protected AbstractCallFinder(ISymbol symbol, Project project, IAsynchronousOperationListener asyncListener, CallHierarchyProvider provider) { _asyncListener = asyncListener; _symbol = symbol.GetSymbolKey(); this.SymbolName = symbol.Name; _project = project; this.Provider = provider; }
public VisualStudioErrorReportingService( VisualStudioWorkspaceImpl workspace, IForegroundNotificationService foregroundNotificationService, IAsynchronousOperationListener listener) { _workspace = workspace; _foregroundNotificationService = foregroundNotificationService; _listener = listener; _documentTrackingService = workspace.Services.GetService<IDocumentTrackingService>(); }
public VisualStudioRuleSetManagerFactory( SVsServiceProvider serviceProvider, IForegroundNotificationService foregroundNotificationService, [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners) { _serviceProvider = serviceProvider; _foregroundNotificationService = foregroundNotificationService; _listener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.RuleSetEditor); }
public FixMultipleOccurrencesService( ICodeActionEditHandlerService editHandler, IWaitIndicator waitIndicator, [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners) { _editHandler = editHandler; _waitIndicator = waitIndicator; _listener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.LightBulb); }
public LineSeparatorAdornmentManagerProvider( IViewTagAggregatorFactoryService tagAggregatorFactoryService, [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners) { _tagAggregatorFactoryService = tagAggregatorFactoryService; _asyncListener = new AggregateAsynchronousOperationListener( asyncListeners, FeatureAttribute.LineSeparators); }
public WorkCoordinatorRegistrationService( [ImportMany] IEnumerable<Lazy<IIncrementalAnalyzerProvider, IncrementalAnalyzerProviderMetadata>> analyzerProviders, [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners) { _gate = new object(); _analyzerProviders = analyzerProviders.ToImmutableArray(); _documentWorkCoordinatorMap = new Dictionary<Workspace, WorkCoordinator>(ReferenceEqualityComparer.Instance); _listener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.SolutionCrawler); }
public AsynchronousSerialWorkQueue(IAsynchronousOperationListener asyncListener) : base(assertIsForeground: false) { Contract.ThrowIfNull(asyncListener); _asyncListener = asyncListener; // Initialize so we don't have to check for null below. Force the background task to run // on the threadpool. _currentBackgroundTask = SpecializedTasks.EmptyTask; }
protected SuggestedActionWithFlavors( Workspace workspace, ITextBuffer subjectBuffer, ICodeActionEditHandlerService editHandler, IWaitIndicator waitIndicator, CodeAction codeAction, object provider, IAsynchronousOperationListener operationListener) : base(workspace, subjectBuffer, editHandler, waitIndicator, codeAction, provider, operationListener) { }
public IdleProcessor( IAsynchronousOperationListener listener, int backOffTimeSpanInMS, CancellationToken cancellationToken) { this.Listener = listener; this.CancellationToken = cancellationToken; _backOffTimeSpanInMS = backOffTimeSpanInMS; _lastAccessTimeInMS = Environment.TickCount; }
public CodeRefactoringSuggestedAction( Workspace workspace, ITextBuffer subjectBuffer, ICodeActionEditHandlerService editHandler, IWaitIndicator waitIndicator, CodeAction codeAction, CodeRefactoringProvider provider, IAsynchronousOperationListener operationListener) : base(workspace, subjectBuffer, editHandler, waitIndicator, codeAction, provider, operationListener) { }
internal PreviewChangesSuggestedAction( Workspace workspace, ITextBuffer subjectBuffer, ICodeActionEditHandlerService editHandler, IWaitIndicator waitIndicator, PreviewChangesCodeAction codeAction, object provider, IAsynchronousOperationListener operationListener) : base(workspace, subjectBuffer, editHandler, waitIndicator, codeAction, provider, operationListener) { }
public StateMachine( ITextBuffer buffer, IInlineRenameService inlineRenameService, IAsynchronousOperationListener asyncListener, IDiagnosticAnalyzerService diagnosticAnalyzerService) { _buffer = buffer; _buffer.Changed += Buffer_Changed; _inlineRenameService = inlineRenameService; _asyncListener = asyncListener; _diagnosticAnalyzerService = diagnosticAnalyzerService; }
public RemoteHostClientService( IAsynchronousOperationListener listener, Workspace workspace, IDiagnosticAnalyzerService analyzerService) : base() { _gate = new object(); _listener = listener; _workspace = workspace; _analyzerService = analyzerService; }
public SuggestedActionsSourceProvider( ICodeRefactoringService codeRefactoringService, IDiagnosticAnalyzerService diagnosticService, ICodeFixService codeFixService, ICodeActionEditHandlerService editHandler, [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners) { _codeRefactoringService = codeRefactoringService; _diagnosticService = diagnosticService; _codeFixService = codeFixService; _editHandler = editHandler; _listener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.LightBulb); }
protected AsynchronousViewTaggerProvider(IThreadingContext threadingContext, IAsynchronousOperationListener asyncListener, IForegroundNotificationService _) : base(threadingContext, asyncListener) { }
protected AsynchronousViewTaggerProvider( IAsynchronousOperationListener asyncListener, IForegroundNotificationService notificationService) : this(((Implementation.ForegroundNotification.ForegroundNotificationService)notificationService).ThreadingContext, asyncListener, notificationService) { }
public GlobalOperationNotificationServiceFactory(IAsynchronousOperationListenerProvider listenerProvider) { _listener = listenerProvider.GetListener(FeatureAttribute.GlobalOperation); _singleton = new GlobalOperationNotificationService(_listener); }
protected AbstractController(IThreadingContext threadingContext, ITextView textView, ITextBuffer subjectBuffer, IIntelliSensePresenter <TPresenterSession, TEditorSession> presenter, IAsynchronousOperationListener asyncListener, IDocumentProvider documentProvider, string asyncOperationId) : base(threadingContext) { this.TextView = textView; this.SubjectBuffer = subjectBuffer; this.Presenter = presenter; _asyncListener = asyncListener; this.DocumentProvider = documentProvider; _asyncOperationId = asyncOperationId; this.TextView.Closed += OnTextViewClosed; // Caret position changed only fires if the caret is explicitly moved. It doesn't fire // when the caret is moved because of text change events. this.TextView.Caret.PositionChanged += this.OnCaretPositionChanged; this.TextView.TextBuffer.PostChanged += this.OnTextViewBufferPostChanged; }
internal static List <IGraphQuery> GetGraphQueries( IGraphContext context, IThreadingContext threadingContext, IAsynchronousOperationListener asyncListener) { var graphQueries = new List <IGraphQuery>(); if (context.Direction == GraphContextDirection.Self && context.RequestedProperties.Contains(DgmlNodeProperties.ContainsChildren)) { graphQueries.Add(new ContainsChildrenGraphQuery()); } if (context.Direction == GraphContextDirection.Contains || (context.Direction == GraphContextDirection.Target && context.LinkCategories.Contains(CodeLinkCategories.Contains))) { graphQueries.Add(new ContainsGraphQuery()); } if (context.LinkCategories.Contains(CodeLinkCategories.InheritsFrom)) { if (context.Direction == GraphContextDirection.Target) { graphQueries.Add(new InheritsGraphQuery()); } else if (context.Direction == GraphContextDirection.Source) { graphQueries.Add(new InheritedByGraphQuery()); } } if (context.LinkCategories.Contains(CodeLinkCategories.SourceReferences)) { graphQueries.Add(new IsUsedByGraphQuery()); } if (context.LinkCategories.Contains(CodeLinkCategories.Calls)) { if (context.Direction == GraphContextDirection.Target) { graphQueries.Add(new CallsGraphQuery()); } else if (context.Direction == GraphContextDirection.Source) { graphQueries.Add(new IsCalledByGraphQuery()); } } if (context.LinkCategories.Contains(CodeLinkCategories.Implements)) { if (context.Direction == GraphContextDirection.Target) { graphQueries.Add(new ImplementsGraphQuery()); } else if (context.Direction == GraphContextDirection.Source) { graphQueries.Add(new ImplementedByGraphQuery()); } } if (context.LinkCategories.Contains(RoslynGraphCategories.Overrides)) { if (context.Direction == GraphContextDirection.Source) { graphQueries.Add(new OverridesGraphQuery()); } else if (context.Direction == GraphContextDirection.Target) { graphQueries.Add(new OverriddenByGraphQuery()); } } if (context.Direction == GraphContextDirection.Custom) { var searchParameters = context.GetValue <ISolutionSearchParameters>(typeof(ISolutionSearchParameters).GUID.ToString()); if (searchParameters != null) { // WARNING: searchParameters.SearchQuery returns an IVsSearchQuery object, which // is a COM type. Therefore, it's probably best to grab the values we want now // rather than get surprised by COM marshalling later. graphQueries.Add(new SearchGraphQuery( searchParameters.SearchQuery.SearchString, threadingContext, asyncListener)); } } return(graphQueries); }
public TagSource( ITextView textViewOpt, ITextBuffer subjectBuffer, AbstractAsynchronousTaggerProvider <TTag> dataSource, IAsynchronousOperationListener asyncListener) : base(dataSource.ThreadingContext) { this.AssertIsForeground(); if (dataSource.SpanTrackingMode == SpanTrackingMode.Custom) { throw new ArgumentException("SpanTrackingMode.Custom not allowed.", "spanTrackingMode"); } _subjectBuffer = subjectBuffer; _textViewOpt = textViewOpt; _dataSource = dataSource; _asyncListener = asyncListener; _highPriTagsChangedQueue = new AsyncBatchingWorkQueue <NormalizedSnapshotSpanCollection>( TaggerDelay.NearImmediate.ComputeTimeDelay(), ProcessTagsChangedAsync, equalityComparer: null, asyncListener, _tagSourceState.Target.DisposalToken); if (_dataSource.AddedTagNotificationDelay == TaggerDelay.NearImmediate) { // if the tagger wants "added tags" to be reported "NearImmediate"ly, then just reuse // the "high pri" queue as that already reports things at that cadence. _normalPriTagsChangedQueue = _highPriTagsChangedQueue; } else { _normalPriTagsChangedQueue = new AsyncBatchingWorkQueue <NormalizedSnapshotSpanCollection>( _dataSource.AddedTagNotificationDelay.ComputeTimeDelay(), ProcessTagsChangedAsync, equalityComparer: null, asyncListener, _tagSourceState.Target.DisposalToken); } DebugRecordInitialStackTrace(); _eventSource = CreateEventSource(); Connect(); // Start computing the initial set of tags immediately. We want to get the UI // to a complete state as soon as possible. EnqueueWork(initialTags: true); return; void Connect() { this.AssertIsForeground(); _eventSource.Changed += OnEventSourceChanged; if (_dataSource.TextChangeBehavior.HasFlag(TaggerTextChangeBehavior.TrackTextChanges)) { _subjectBuffer.Changed += OnSubjectBufferChanged; } if (_dataSource.CaretChangeBehavior.HasFlag(TaggerCaretChangeBehavior.RemoveAllTagsOnCaretMoveOutsideOfTag)) { if (_textViewOpt == null) { throw new ArgumentException( nameof(_dataSource.CaretChangeBehavior) + " can only be specified for an " + nameof(IViewTaggerProvider)); } _textViewOpt.Caret.PositionChanged += OnCaretPositionChanged; } // Tell the interaction object to start issuing events. _eventSource.Connect(); } }
public WorkspaceAsynchronousOperationListenerProvider(IAsynchronousOperationListenerProvider listenerProvider) { _listener = listenerProvider.GetListener(FeatureAttribute.Workspace); }
public InProcOrRemoteHostAnalyzerRunner(IAsynchronousOperationListener operationListener, DiagnosticAnalyzerInfoCache analyzerInfoCache) { _asyncOperationListener = operationListener; _analyzerInfoCache = analyzerInfoCache; }
public GlobalOperationNotificationService(IAsynchronousOperationListener listener) { _listener = listener; }
public AbstractAsynchronousBufferTaggerProvider( IAsynchronousOperationListener asyncListener, IForegroundNotificationService notificationService) : base(asyncListener, notificationService) { }
public Service(IAsyncServiceProvider2 serviceProvider, IThreadingContext threadingContext, IAsynchronousOperationListener listener) { _serviceProvider = serviceProvider; _threadingContext = threadingContext; _loadHubClientPackage = _threadingContext.JoinableTaskFactory.RunAsync(async() => { // Use the disposal token, since the caller's cancellation token will apply instead to the // JoinAsync operation in GetProgressStageStatusAsync. await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(alwaysYield: true, _threadingContext.DisposalToken); // Make sure the HubClient package is loaded, since we rely on it for proffered OOP services var shell = await _serviceProvider.GetServiceAsync <SVsShell, IVsShell7>().ConfigureAwait(true); Assumes.Present(shell); await shell.LoadPackageAsync(Guids.GlobalHubClientPackageGuid); }); _progressStageStatus = _threadingContext.JoinableTaskFactory.RunAsync(async() => { // pre-emptively make sure event is subscribed. if APIs are called before it is done, calls will be blocked // until event subscription is done using var asyncToken = listener.BeginAsyncOperation("StatusChanged_EventSubscription"); await threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(alwaysYield: true, _threadingContext.DisposalToken); var service = await serviceProvider.GetServiceAsync <SVsOperationProgress, IVsOperationProgressStatusService>(throwOnFailure: false).ConfigureAwait(true); if (service is null) { return(null); } var status = service.GetStageStatusForSolutionLoad(CommonOperationProgressStageIds.Intellisense); status.PropertyChanged += (_, _) => StatusChanged?.Invoke(this, EventArgs.Empty); return(status); }); }
protected AsynchronousTaggerProvider( IAsynchronousOperationListener asyncListener, IForegroundNotificationService notificationService) : base(asyncListener, notificationService) { }
protected AsynchronousViewTaggerProvider(IThreadingContext threadingContext, IAsynchronousOperationListener asyncListener) : base(threadingContext, asyncListener) { }
public BaseMemberFinder(ISymbol symbol, Project project, IAsynchronousOperationListener asyncListener, CallHierarchyProvider provider) : base(symbol, project, asyncListener, provider) { _text = string.Format(EditorFeaturesResources.Calls_To_Base_Member_0, symbol.ToDisplayString()); }
internal GraphQueryManager(Workspace workspace, IAsynchronousOperationListener asyncListener) { _workspace = workspace; _asyncListener = asyncListener; }
internal static IEnumerable <Lazy <IAsynchronousOperationListener, FeatureMetadata> > CreateListeners( string featureName, IAsynchronousOperationListener listener) { return(CreateListeners(ValueTuple.Create(featureName, listener))); }
public Analyzer(IForegroundNotificationService notificationService, IAsynchronousOperationListener listener, VisualStudioWorkspaceImpl workspace) { _notificationService = notificationService; _listener = listener; _workspace = workspace; }
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.Workspace.Services.GetRequiredService <IOptionService>(); _documentTrackingService = _registration.Workspace.Services.GetService <IDocumentTrackingService>(); // event and worker queues _shutdownNotificationSource = new CancellationTokenSource(); _shutdownToken = _shutdownNotificationSource.Token; _eventProcessingQueue = new TaskQueue(listener, 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; } }
public FieldReferenceFinder(ISymbol symbol, ProjectId projectId, IAsynchronousOperationListener asyncListener, CallHierarchyProvider provider) : base(symbol, projectId, asyncListener, provider) { }
public InlineRenameSession( IThreadingContext threadingContext, InlineRenameService renameService, Workspace workspace, SnapshotSpan triggerSpan, IInlineRenameInfo renameInfo, IWaitIndicator waitIndicator, ITextBufferAssociatedViewService textBufferAssociatedViewService, ITextBufferFactoryService textBufferFactoryService, IFeatureServiceFactory featureServiceFactory, IEnumerable <IRefactorNotifyService> refactorNotifyServices, IAsynchronousOperationListener asyncListener) : base(threadingContext, assertIsForeground: true) { // This should always be touching a symbol since we verified that upon invocation _renameInfo = renameInfo; _triggerDocument = triggerSpan.Snapshot.GetOpenDocumentInCurrentContextWithChanges(); if (_triggerDocument == null) { throw new InvalidOperationException(EditorFeaturesResources.The_triggerSpan_is_not_included_in_the_given_workspace); } _inlineRenameSessionDurationLogBlock = Logger.LogBlock(FunctionId.Rename_InlineSession, CancellationToken.None); _workspace = workspace; _workspace.WorkspaceChanged += OnWorkspaceChanged; _textBufferFactoryService = textBufferFactoryService; _textBufferAssociatedViewService = textBufferAssociatedViewService; _textBufferAssociatedViewService.SubjectBuffersConnected += OnSubjectBuffersConnected; // Disable completion when an inline rename session starts _featureService = featureServiceFactory.GlobalFeatureService; _completionDisabledToken = _featureService.Disable(PredefinedEditorFeatureNames.Completion, this); _renameService = renameService; _waitIndicator = waitIndicator; _refactorNotifyServices = refactorNotifyServices; _asyncListener = asyncListener; _triggerView = textBufferAssociatedViewService.GetAssociatedTextViews(triggerSpan.Snapshot.TextBuffer).FirstOrDefault(v => v.HasAggregateFocus) ?? textBufferAssociatedViewService.GetAssociatedTextViews(triggerSpan.Snapshot.TextBuffer).First(); _optionSet = renameInfo.ForceRenameOverloads ? workspace.Options.WithChangedOption(RenameOptions.RenameOverloads, true) : workspace.Options; this.ReplacementText = triggerSpan.GetText(); _baseSolution = _triggerDocument.Project.Solution; this.UndoManager = workspace.Services.GetService <IInlineRenameUndoManager>(); _debuggingWorkspaceService = workspace.Services.GetService <IDebuggingWorkspaceService>(); _debuggingWorkspaceService.BeforeDebuggingStateChanged += OnBeforeDebuggingStateChanged; var experimentationService = workspace.Services.GetRequiredService <IExperimentationService>(); if (experimentationService.IsExperimentEnabled(WellKnownExperimentNames.RoslynInlineRenameFile) && _renameInfo is IInlineRenameInfoWithFileRename renameInfoWithFileRename) { FileRenameInfo = renameInfoWithFileRename.GetFileRenameInfo(); } else { FileRenameInfo = InlineRenameFileRenameInfo.NotAllowed; } InitializeOpenBuffers(triggerSpan); }