private void AddClassifiedSpansForPreviousTree(
IClassificationService classificationService,
SnapshotSpan span,
ITextSnapshot lastSnapshot,
Document lastDocument,
List <ClassifiedSpan> classifiedSpans)
{
// Slightly more complicated case. They're asking for the classifications for a
// different snapshot than what we have a parse tree for. So we first translate the span
// that they're asking for so that is maps onto the tree that we have spans for. We then
// get the classifications from that tree. We then take the results and translate them
// back to the snapshot they want. Finally, as some of the classifications may have
// changed, we check for some common cases and touch them up manually so that things
// look right for the user.
// Note the handling of SpanTrackingModes here: We do EdgeExclusive while mapping back ,
// and EdgeInclusive mapping forward. What I've convinced myself is that EdgeExclusive
// is best when mapping back over a deletion, so that we don't end up classifying all of
// the deleted code. In most addition/modification cases, there will be overlap with
// existing spans, and so we'll end up classifying well. In the worst case, there is a
// large addition that doesn't exist when we map back, and so we don't have any
// classifications for it. That's probably okay, because:
// 1. If it's that large, it's likely that in reality there are multiple classification
// spans within it.
// 2.We'll eventually call ClassificationsChanged and re-classify that region anyway.
// When mapping back forward, we use EdgeInclusive so that in the common typing cases we
// don't end up with half a token colored differently than the other half.
// See bugs like http://vstfdevdiv:8080/web/wi.aspx?id=6176 for an example of what can
// happen when this goes wrong.
// 1) translate the requested span onto the right span for the snapshot that corresponds
// to the syntax tree.
var translatedSpan = span.TranslateTo(lastSnapshot, SpanTrackingMode.EdgeExclusive);
if (translatedSpan.IsEmpty)
{
// well, there is no information we can get from previous tree, use lexer to
// classify given span. soon we will re-classify the region.
AddClassifiedSpansForTokens(classificationService, span, classifiedSpans);
return;
}
var tempList = ClassificationUtilities.GetOrCreateClassifiedSpanList();
AddClassifiedSpansForCurrentTree(
classificationService, translatedSpan, lastDocument, tempList);
var currentSnapshot = span.Snapshot;
var currentText = currentSnapshot.AsText();
foreach (var lastClassifiedSpan in tempList)
{
// 2) Translate those classifications forward so that they correspond to the true
// requested snapshot.
var lastSnapshotSpan = lastClassifiedSpan.TextSpan.ToSnapshotSpan(lastSnapshot);
var currentSnapshotSpan = lastSnapshotSpan.TranslateTo(currentSnapshot, SpanTrackingMode.EdgeInclusive);
var currentClassifiedSpan = new ClassifiedSpan(lastClassifiedSpan.ClassificationType, currentSnapshotSpan.Span.ToTextSpan());
// 3) The classifications may be incorrect due to changes in the text. For example,
// if "clss" becomes "class", then we want to changes the classification from
// 'identifier' to 'keyword'.
currentClassifiedSpan = classificationService.AdjustStaleClassification(currentText, currentClassifiedSpan);
classifiedSpans.Add(currentClassifiedSpan);
}
ClassificationUtilities.ReturnClassifiedSpanList(tempList);
}
public ClassifiedSpan AdjustStaleClassification(SourceText text, ClassifiedSpan classifiedSpan) => _originalService.AdjustStaleClassification(text, classifiedSpan);
