private void ProduceTagsSynchronously(TaggerContext <TTag> context)
{
if (ShouldSkipTagProduction())
{
return;
}
_dataSource.ProduceTagsSynchronously(context);
}
/// <summary>
/// Produce tags for the given context.
/// Keep in sync with <see cref="ProduceTagsAsync(TaggerContext{TTag})"/>
/// </summary>
protected void ProduceTagsSynchronously(TaggerContext <TTag> context)
{
foreach (var spanToTag in context.SpansToTag)
{
context.CancellationToken.ThrowIfCancellationRequested();
ProduceTagsSynchronously(
context, spanToTag,
GetCaretPosition(context.CaretPosition, spanToTag.SnapshotSpan));
}
}
/// <summary>
/// Produce tags for the given context.
/// Keep in sync with <see cref="ProduceTagsSynchronously(TaggerContext{TTag})"/>
/// </summary>
protected virtual async Task ProduceTagsAsync(TaggerContext <TTag> context)
{
foreach (var spanToTag in context.SpansToTag)
{
context.CancellationToken.ThrowIfCancellationRequested();
await ProduceTagsAsync(
context, spanToTag,
GetCaretPosition(context.CaretPosition, spanToTag.SnapshotSpan)).ConfigureAwait(false);
}
}
private Task ProduceTagsAsync(TaggerContext <TTag> context)
{
if (ShouldSkipTagProduction())
{
// If the feature is disabled, then just produce no tags.
return(SpecializedTasks.EmptyTask);
}
return(_dataSource.ProduceTagsAsync(context));
}
protected virtual void ProduceTagsSynchronously(TaggerContext <TTag> context, DocumentSnapshotSpan spanToTag, int?caretPosition)
{
// By default we implement the sync version of this by blocking on the async version.
//
// The benefit of this is that all taggers can implicitly be used as IAccurateTaggers
// without any code changes.
//
// However, the drawback is that it means the UI thread might be blocked waiting for
// tasks to be scheduled and run on the threadpool.
//
// Taggers that need to be called accurately should override this method to produce
// results quickly if possible.
ProduceTagsAsync(context, spanToTag, caretPosition).Wait(context.CancellationToken);
}
private void ProcessContext(
List <DocumentSnapshotSpan> spansToTag,
ImmutableDictionary <ITextBuffer, TagSpanIntervalTree <TTag> > oldTagTrees,
TaggerContext <TTag> context)
{
var buffersToTag = spansToTag.Select(dss => dss.SnapshotSpan.Snapshot.TextBuffer).ToSet();
// Ignore any tag spans reported for any buffers we weren't interested in.
var newTagsByBuffer = context.tagSpans.Where(ts => buffersToTag.Contains(ts.Span.Snapshot.TextBuffer))
.ToLookup(t => t.Span.Snapshot.TextBuffer);
var newTagTrees = ConvertToTagTrees(oldTagTrees, newTagsByBuffer, context._spansTagged);
ProcessNewTagTrees(spansToTag, oldTagTrees, newTagTrees, context.State, context.CancellationToken);
}
private async Task RecomputeTagsAsync(
object oldState,
SnapshotPoint?caretPosition,
TextChangeRange?textChangeRange,
List <DocumentSnapshotSpan> spansToTag,
ImmutableDictionary <ITextBuffer, TagSpanIntervalTree <TTag> > oldTagTrees,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var context = new TaggerContext <TTag>(
oldState, spansToTag, caretPosition, textChangeRange, oldTagTrees, cancellationToken);
await ProduceTagsAsync(context).ConfigureAwait(false);
ProcessContext(spansToTag, oldTagTrees, context);
}
public TagSpanIntervalTree <TTag> GetAccurateTagIntervalTreeForBuffer(ITextBuffer buffer, CancellationToken cancellationToken)
{
_workQueue.AssertIsForeground();
if (!this.UpToDate)
{
// We're not up to date. That means we have an outstanding update that we're
// currently processing. Unfortunately we have no way to track the progress of
// that update (i.e. a Task). Also, even if we did, we'd have the problem that
// we have delays coded into the normal tagging process. So waiting on that Task
// could take a long time.
//
// So, instead, we just cancel whatever work we're currently doing, and we just
// compute the results synchronously in this call.
// We can cancel any background computations currently happening
_workQueue.CancelCurrentWork();
var spansToTag = GetSpansAndDocumentsToTag();
// Safe to access _cachedTagTrees here. We're on the UI thread.
var oldTagTrees = this.CachedTagTrees;
var caretPoint = _dataSource.GetCaretPoint(_textViewOpt, _subjectBuffer);
var context = new TaggerContext <TTag>(
this.State, spansToTag, caretPoint, this.AccumulatedTextChanges, oldTagTrees, cancellationToken);
ProduceTagsSynchronously(context);
ProcessContext(spansToTag, oldTagTrees, context);
}
Debug.Assert(this.UpToDate);
this.CachedTagTrees.TryGetValue(buffer, out var tags);
return(tags);
}
protected virtual Task ProduceTagsAsync(TaggerContext <TTag> context, DocumentSnapshotSpan spanToTag, int?caretPosition)
{
return(SpecializedTasks.EmptyTask);
}
internal Task ProduceTagsAsync_ForTestingPurposesOnly(TaggerContext <TTag> context)
{
return(ProduceTagsAsync(context));
}