Ejemplo n.º 1
0
        public override async ValueTask OnDefinitionFoundAsync(DefinitionItem definition)
        {
            using (await _semaphore.DisposableWaitAsync(CancellationToken).ConfigureAwait(false))
            {
                if (_definitionToId.ContainsKey(definition))
                {
                    return;
                }

                // Assigning a new id to the definition
                _id++;
                _definitionToId.Add(definition, _id);

                // Creating a new VSReferenceItem for the definition
                var definitionItem = await GenerateVSReferenceItemAsync(
                    _id, definitionId : _id, _document, _position, definition.SourceSpans.FirstOrDefault(),
                    definition.DisplayableProperties, _metadataAsSourceFileService, definition.GetClassifiedText(),
                    definition.Tags.GetFirstGlyph(), symbolUsageInfo : null, isWrittenTo : false, CancellationToken).ConfigureAwait(false);

                if (definitionItem != null)
                {
                    // If a definition shouldn't be included in the results list if it doesn't have references, we
                    // have to hold off on reporting it until later when we do find a reference.
                    if (definition.DisplayIfNoReferences)
                    {
                        _workQueue.AddWork(definitionItem);
                    }
                    else
                    {
                        _definitionsWithoutReference.Add(definitionItem.Id, definitionItem);
                    }
                }
            }
        }
 /// <summary>
 /// Callback from the OOP service back into us.
 /// </summary>
 public ValueTask ReportProjectTelemetryDataAsync(
     ProjectTelemetryData info,
     CancellationToken cancellationToken
     )
 {
     Contract.ThrowIfNull(_workQueue);
     _workQueue.AddWork(info);
     return(ValueTaskFactory.CompletedTask);
 }
Ejemplo n.º 3
0
        private void OnWorkspaceChanged(object sender, WorkspaceChangeEventArgs e)
        {
            // Events that can't change existing code model items.  Can just ignore them.
            switch (e.Kind)
            {
            case WorkspaceChangeKind.SolutionAdded:
            case WorkspaceChangeKind.ProjectAdded:
            case WorkspaceChangeKind.DocumentAdded:
            case WorkspaceChangeKind.AdditionalDocumentAdded:
            case WorkspaceChangeKind.AdditionalDocumentRemoved:
            case WorkspaceChangeKind.AdditionalDocumentReloaded:
            case WorkspaceChangeKind.AdditionalDocumentChanged:
            case WorkspaceChangeKind.AnalyzerConfigDocumentAdded:
            case WorkspaceChangeKind.AnalyzerConfigDocumentRemoved:
            case WorkspaceChangeKind.AnalyzerConfigDocumentReloaded:
            case WorkspaceChangeKind.AnalyzerConfigDocumentChanged:
                return;

            case WorkspaceChangeKind.DocumentRemoved:
            case WorkspaceChangeKind.DocumentChanged:
                // Fast path when we know we affected a document that could have had code model elements in it.  No
                // need to do a solution diff in this case.
                _documentsToFireEventsFor.AddWork(e.DocumentId !);
                return;
            }

            // Other type of event that could indicate a doc change/removal. Have to actually analyze the change to
            // determine what we should do here.

            var changes = e.OldSolution.GetChanges(e.NewSolution);

            foreach (var project in changes.GetRemovedProjects())
            {
                _documentsToFireEventsFor.AddWork(project.DocumentIds);
            }

            foreach (var projectChange in changes.GetProjectChanges())
            {
                _documentsToFireEventsFor.AddWork(projectChange.GetRemovedDocuments());
                _documentsToFireEventsFor.AddWork(projectChange.GetChangedDocuments());
            }
        }
        private void DiagnosticService_DiagnosticsUpdated(Solution?solution, DocumentId?documentId)
        {
            // LSP doesn't support diagnostics without a document. So if we get project level diagnostics without a document, ignore them.
            if (documentId != null && solution != null)
            {
                var document = solution.GetDocument(documentId);
                if (document == null || document.FilePath == null)
                {
                    return;
                }

                // Only publish document diagnostics for the languages this provider supports.
                if (!_supportedLanguages.Contains(document.Project.Language))
                {
                    return;
                }

                _diagnosticsWorkQueue.AddWork(document.Id);
            }
        }
 public Task ReportDesignerAttributeDataAsync(ImmutableArray <DesignerAttributeData> data, CancellationToken cancellationToken)
 {
     Contract.ThrowIfNull(_workQueue);
     _workQueue.AddWork(data);
     return(Task.CompletedTask);
 }
Ejemplo n.º 6
0
 private void OnWorkspaceChanged(object?sender, WorkspaceChangeEventArgs eventArgs)
 => _asyncDelay.AddWork();
 public Task ReportTodoCommentDataAsync(DocumentId documentId, ImmutableArray <TodoCommentData> infos, CancellationToken cancellationToken)
 {
     Contract.ThrowIfNull(_workQueue);
     _workQueue.AddWork(new DocumentAndComments(documentId, infos));
     return(Task.CompletedTask);
 }
 private void EnqueueFlushTask()
 {
     // actual value isn't relevant.  this just ensures that a flush will happen in the future.
     _flushQueue.AddWork(true);
 }
            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;

                _eventWorkQueue = new AsyncBatchingWorkQueue <bool>(
                    _dataSource.EventChangeDelay.ComputeTimeDelay(),
                    ProcessEventsAsync,
                    EqualityComparer <bool> .Default,
                    asyncListener,
                    _disposalTokenSource.Token);

                _highPriTagsChangedQueue = new AsyncBatchingWorkQueue <NormalizedSnapshotSpanCollection>(
                    TaggerDelay.NearImmediate.ComputeTimeDelay(),
                    ProcessTagsChangedAsync,
                    equalityComparer: null,
                    asyncListener,
                    _disposalTokenSource.Token);

                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,
                        _disposalTokenSource.Token);
                }

                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.
                _eventWorkQueue.AddWork(/*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();
                }
            }
Ejemplo n.º 10
0
 public Task RegisterDesignerAttributesAsync(IList <DesignerInfo> attributeInfos, CancellationToken cancellationToken)
 {
     _workQueue.AddWork(attributeInfos);
     return(Task.CompletedTask);
 }
 private void OnWorkspaceChanged(object sender, WorkspaceChangeEventArgs eventArgs)
 => _workQueue.AddWork(true);
 private void EnqueueFlushTask()
 {
     _flushQueue.AddWork();
 }