public IEnumerable <ITagSpan <GLSLHighlightTag> > GetTags(NormalizedSnapshotSpanCollection spans) { if (_currentToken.HasValue) { UpdateTrackedSpans(spans); // Hold on to a "snapshot" of the word spans and current word, so that we maintain the same collection throughout SnapshotSpan currentToken = _currentToken.Value; NormalizedSnapshotSpanCollection wordSpans = _wordSpans; if (spans.Count > 0 && wordSpans.Count > 0) { // If the requested snapshot isn't the same as the one our words are on, translate our spans to the expected snapshot if (spans.First().Snapshot != wordSpans.First().Snapshot) { wordSpans = new NormalizedSnapshotSpanCollection(wordSpans.Select(s => s.TranslateTo(spans.First().Snapshot, SpanTrackingMode.EdgeExclusive))); currentToken = currentToken.TranslateTo(spans.First().Snapshot, SpanTrackingMode.EdgeExclusive); } // First, yield back the word the cursor is under (if it overlaps) // Note that we'll yield back the same word again in the wordspans collection; the duplication here is expected. yield return(new TagSpan <GLSLHighlightTag>(currentToken, new GLSLHighlightTag())); foreach (var span in wordSpans) { yield return(new TagSpan <GLSLHighlightTag>(span, new GLSLHighlightTag())); } } } }
public IEnumerable <ITagSpan <TextMarkerTag> > GetTags(NormalizedSnapshotSpanCollection spans) { if (_highlightedSpans?.Any() ?? false) { if (spans.First().Snapshot != _highlightedSpans.First().Snapshot) { _highlightedSpans = new NormalizedSnapshotSpanCollection( from span in _highlightedSpans select span.TranslateTo(spans.First().Snapshot, SpanTrackingMode.EdgeExclusive) ); } foreach (var span in NormalizedSnapshotSpanCollection.Overlap(spans, _highlightedSpans)) { yield return(new TagSpan <FrameNameReferenceTag>(span, FrameNameReferenceTag.Instance)); } } if (_definitionSpans?.Any() ?? false) { if (spans.First().Snapshot != _definitionSpans.First().Snapshot) { _definitionSpans = new NormalizedSnapshotSpanCollection( from span in _definitionSpans select span.TranslateTo(spans.First().Snapshot, SpanTrackingMode.EdgeExclusive) ); } foreach (var span in NormalizedSnapshotSpanCollection.Overlap(spans, _definitionSpans)) { yield return(new TagSpan <FrameNameDefinitionTag>(span, FrameNameDefinitionTag.Instance)); } } }
public IEnumerable <ITagSpan <IClassificationTag> > GetAllTags(NormalizedSnapshotSpanCollection spans, CancellationToken cancellationToken) { this.AssertIsForeground(); if (spans.Count == 0) { return(Array.Empty <ITagSpan <IClassificationTag> >()); } var firstSpan = spans.First(); var snapshot = firstSpan.Snapshot; Debug.Assert(snapshot.TextBuffer == _subjectBuffer); // We want to classify from the start of the first requested span to the end of the // last requested span. var spanToTag = new SnapshotSpan(snapshot, Span.FromBounds(spans.First().Start, spans.Last().End)); // We don't need to actually classify if what we're being asked for is a subspan // of the last classification we performed. var cachedTaggedSpan = this.CachedTaggedSpan; var canReuseCache = cachedTaggedSpan?.Snapshot == snapshot && cachedTaggedSpan.Value.Contains(spanToTag); if (!canReuseCache) { // Our cache is not there, or is out of date. We need to compute the up to date // results. var document = snapshot.GetOpenDocumentInCurrentContextWithChanges(); if (document == null) { return(Array.Empty <ITagSpan <IClassificationTag> >()); } _classificationService = _classificationService ?? document.Project.LanguageServices.GetService <IEditorClassificationService>(); var context = new TaggerContext <IClassificationTag>(document, snapshot, cancellationToken: cancellationToken); var task = SemanticClassificationUtilities.ProduceTagsAsync( context, new DocumentSnapshotSpan(document, spanToTag), _classificationService, _owner._typeMap); task.Wait(cancellationToken); CachedTaggedSpan = spanToTag; CachedTags = new TagSpanIntervalTree <IClassificationTag>(snapshot.TextBuffer, SpanTrackingMode.EdgeExclusive, context.tagSpans); } if (this.CachedTags == null) { return(Array.Empty <ITagSpan <IClassificationTag> >()); } return(this.CachedTags.GetIntersectingTagSpans(spans)); }
public IEnumerable <ITagSpan <IClassificationTag> > GetAllTags(NormalizedSnapshotSpanCollection spans, CancellationToken cancellationToken) { this.AssertIsForeground(); if (spans.Count == 0) { return(Array.Empty <ITagSpan <IClassificationTag> >()); } var firstSpan = spans.First(); var snapshot = firstSpan.Snapshot; Debug.Assert(snapshot.TextBuffer == _subjectBuffer); var document = snapshot.GetOpenDocumentInCurrentContextWithChanges(); if (document == null) { return(Array.Empty <ITagSpan <IClassificationTag> >()); } // We want to classify from the start of the first requested span to the end of the // last requested span. var spanToTag = new SnapshotSpan(snapshot, Span.FromBounds(spans.First().Start, spans.Last().End)); GetCachedInfo(out var cachedTaggedSpan, out var cachedTags); // We don't need to actually classify if what we're being asked for is a subspan // of the last classification we performed. var canReuseCache = cachedTaggedSpan?.Snapshot == snapshot && cachedTaggedSpan.Value.Contains(spanToTag); if (!canReuseCache) { // Our cache is not there, or is out of date. We need to compute the up to date results. var context = new TaggerContext <IClassificationTag>(document, snapshot); this.ThreadingContext.JoinableTaskFactory.Run( () => ProduceTagsAsync(context, new DocumentSnapshotSpan(document, spanToTag), _owner._typeMap, cancellationToken)); cachedTaggedSpan = spanToTag; cachedTags = new TagSpanIntervalTree <IClassificationTag>(snapshot.TextBuffer, SpanTrackingMode.EdgeExclusive, context.tagSpans); lock (_gate) { _cachedTaggedSpan = cachedTaggedSpan; _cachedTags = cachedTags; } } return(cachedTags == null ? Array.Empty <ITagSpan <IClassificationTag> >() : cachedTags.GetIntersectingTagSpans(spans)); }
public IEnumerable <ITagSpan <ITextMarkerTag> > GetTags(NormalizedSnapshotSpanCollection spans) { AssertIsForeground(); var service = _trackingServiceOpt; if (service == null) { yield break; } var snapshot = spans.First().Snapshot; foreach (var asSpan in service.GetSpans(snapshot.AsText())) { if (asSpan.IsLeaf) { continue; } var snapshotSpan = new SnapshotSpan(snapshot, Span.FromBounds(asSpan.Span.Start, asSpan.Span.End)); if (spans.OverlapsWith(snapshotSpan)) { yield return(new TagSpan <ITextMarkerTag>(snapshotSpan, ActiveStatementTag.Instance)); } } }
public IEnumerable <ITagSpan <T> > GetTags(NormalizedSnapshotSpanCollection spans) { if (_renameService.ActiveSession == null) { yield break; } var renameSpans = _currentSpans; if (renameSpans != null) { var snapshot = spans.First().Snapshot; foreach (var renameSpan in renameSpans) { var span = renameSpan.TrackingSpan.GetSpan(snapshot); if (spans.OverlapsWith(span)) { TagSpan <T> tagSpan; if (TryCreateTagSpan(span, renameSpan.Type, out tagSpan)) { yield return(tagSpan); } } } } }
internal static NormalizedSnapshotSpanCollection CoalesceSpans(NormalizedSnapshotSpanCollection normalizedSpans) { var snapshot = normalizedSpans.First().Snapshot; // Coalesce the spans if there are a lot of them. if (normalizedSpans.Count > CoalesceDifferenceCount) { // Spans are normalized. So to find the whole span we just go from the // start of the first span to the end of the last span. normalizedSpans = new NormalizedSnapshotSpanCollection(snapshot.GetSpanFromBounds( normalizedSpans.First().Start, normalizedSpans.Last().End)); } return(normalizedSpans); }
public IEnumerable <ITagSpan <IErrorTag> > GetTags(NormalizedSnapshotSpanCollection spans) { ITextBuffer buffer = spans.First().Snapshot.TextBuffer; SyntaxTree syntax = buffer.GetSyntaxTree(); return // find intersecting nodes (from node in syntax.Root.DescendantsAndSelf() where spans.IntersectsWith(node.Span) let type = node.GetType() // find analyzers for node from analyzer in _analyzers from @interface in analyzer.GetType().GetInterfaces() where @interface.IsGenericType && @interface.GetGenericTypeDefinition() == typeof(ISyntaxNodeAnalyzer <>) let analyzerNodeType = @interface.GetGenericArguments().Single() where analyzerNodeType.IsAssignableFrom(type) // analyze node from diagnostic in typeof(ISyntaxNodeAnalyzer <>) .MakeGenericType(analyzerNodeType) .GetMethod("Analyze") .Invoke(analyzer, new [] { node }) as IEnumerable <ITagSpan <IErrorTag> > select diagnostic ); }
private IEnumerable <ITagSpan <TTag> > GetTagsWorker( NormalizedSnapshotSpanCollection requestedSpans, bool accurate, CancellationToken cancellationToken) { if (requestedSpans.Count == 0) { return(SpecializedCollections.EmptyEnumerable <ITagSpan <TTag> >()); } var buffer = requestedSpans.First().Snapshot.TextBuffer; var tags = accurate ? _tagSource.GetAccurateTagIntervalTreeForBuffer(buffer, cancellationToken) : _tagSource.GetTagIntervalTreeForBuffer(buffer); if (tags == null) { return(SpecializedCollections.EmptyEnumerable <ITagSpan <TTag> >()); } var result = GetIntersectingTagSpans(requestedSpans, tags); DebugVerifyTags(requestedSpans, result); return(result); }
IEnumerable <ITagSpan <AlertTag> > ITagger <AlertTag> .GetTags(NormalizedSnapshotSpanCollection spans) { if (spans.Count == 0 || PackageSecurityPackage.Vulnurabilities == null) { yield break; } SnapshotSpan span = spans.First(); ITextSnapshotLine line = span.Snapshot.GetLineFromPosition(span.Start.Position); string text = line.Extent.GetText(); Match match = _regex.Match(text); if (match.Success) { string name = match.Groups["name"].Value; string version = match.Groups["version"].Value; Vulnerability vul = PackageSecurityPackage.Vulnurabilities.CheckPackage(name, version); if (vul.Severity != VulnerabilityLevel.None) { yield return(new TagSpan <AlertTag>(line.Extent, new AlertTag(vul))); } } }
public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans) { ITextBuffer buffer = spans.First().Snapshot.TextBuffer; SyntaxTree syntax = buffer.GetSyntaxTree(); RobotsTxtDocumentSyntax root = syntax.Root as RobotsTxtDocumentSyntax; return (from record in root.Records where record.Lines.Count() >= 2 where spans.IntersectsWith(record.Span) let first = record.Lines.First() where first.NameToken.Value.Equals("User-agent", StringComparison.InvariantCultureIgnoreCase) let last = record.Lines.Last() let collapsibleSpan = new SnapshotSpan( first.Span.End, (last.TrailingTrivia.LastOrDefault() ?? last.ValueToken).Span.Span.End ) select new TagSpan <IOutliningRegionTag>( collapsibleSpan, new OutliningRegionTag( collapsedForm: "...", collapsedHintForm: collapsibleSpan.GetText().Trim() ) ) ); }
public virtual IEnumerable <ITagSpan <ParamStorageTag> > GetTags(NormalizedSnapshotSpanCollection spans) { UpdateStcSpans(); // Note that the spans argument can contain spans that are sub-spans of lines or intersect multiple lines. if (_stcLocs != null) { for (int i = 0; i + 1 < _stcLocs.Length; i += 2) { // need to compare manually as info is on different snapshots int pos = _stcLocs[i + 1]; bool intersects = false; foreach (var span in spans) { if (span.Start.Position <= pos && pos <= span.End.Position) { intersects = true; } } if (intersects) { var point = new SnapshotPoint(spans.First().Snapshot, pos); SnapshotSpan span = new SnapshotSpan(point, 1); yield return(new TagSpan <ParamStorageTag>(span, new ParamStorageTag(_stcLocs[i]))); } } } }
private void NotifyTagChanged(ITextSnapshot snapshot) { IMappingSpan t = tagsChanged.Dequeue(); NormalizedSnapshotSpanCollection sp = t.GetSpans(snapshot); if (TagsChanged != null) { TagsChanged.Invoke(this, new SnapshotSpanEventArgs(sp.First())); } }
public IEnumerable <ITagSpan <CssClassReferenceTag> > GetTags(NormalizedSnapshotSpanCollection spans) { var actual = _highlightedSpans; if (actual?.Any() ?? false) { if (spans.First().Snapshot != actual.First().Snapshot) { actual = new NormalizedSnapshotSpanCollection( from span in actual select span.TranslateTo(spans.First().Snapshot, SpanTrackingMode.EdgeExclusive) ); } foreach (var span in NormalizedSnapshotSpanCollection.Overlap(spans, actual)) { yield return(new TagSpan <CssClassReferenceTag>(span, CssClassReferenceTag.Instance)); } } }
public IEnumerable <ITagSpan <TextMarkerTag> > GetTags(NormalizedSnapshotSpanCollection spans) { if (!_textView.Properties.TryGetProperty(PropertyName, out List <Span> allSpans)) { return(null); } return(allSpans .Where(s => spans.Any(ss => ss.IntersectsWith(s))) .Select(s => new TagSpan <TextMarkerTag>(new SnapshotSpan(spans.First().Snapshot, s), ProjectionSpanTag.Instance))); }
/// <inheritdoc/> public IEnumerable <ITagSpan <TTag> >?GetTags(NormalizedSnapshotSpanCollection spans) { if (spans[0].IsEmpty) { return(null); } bool isFullParse = spans.First().Start == 0 && spans.Last().End == spans[0].Snapshot.Length; return(GetTags(spans, isFullParse)); }
public IEnumerable <ITagSpan <IErrorTag> > GetTags(NormalizedSnapshotSpanCollection spans) { this.BackgroundCompilation.CheckCompilationVersion(); var compilationSnapshot = this.BackgroundCompilation.CompilationSnapshot; if (compilationSnapshot.Compilation == null) { yield break; } ImmutableArray <Diagnostic> diagnostics = compilationSnapshot.Compilation.GetDiagnostics(); ITextSnapshot textSnapshot = compilationSnapshot.Text; if (textSnapshot == null || spans.Count == 0 || spans.First().Snapshot.Version != textSnapshot.Version) { yield break; } if (diagnostics != null) { foreach (var diagnostic in diagnostics) { if (diagnostic.Severity == DiagnosticSeverity.Hidden) { continue; } SnapshotSpan diagnosticSpan = new SnapshotSpan(textSnapshot, Span.FromBounds(diagnostic.Location.SourceSpan.Start, diagnostic.Location.SourceSpan.End)); if (spans.IntersectsWith(diagnosticSpan)) { string errorType = PredefinedErrorTypeNames.HintedSuggestion; switch (diagnostic.Severity) { case DiagnosticSeverity.Hidden: break; case DiagnosticSeverity.Info: errorType = PredefinedErrorTypeNames.HintedSuggestion; break; case DiagnosticSeverity.Warning: errorType = PredefinedErrorTypeNames.Warning; break; case DiagnosticSeverity.Error: errorType = PredefinedErrorTypeNames.SyntaxError; break; default: break; } yield return(new TagSpan <IErrorTag>(diagnosticSpan, new ErrorTag(errorType, diagnostic.GetMessage()))); } } } }
private async Task <CommentSelectionResult> ToggleBlockCommentsAsync(Document document, CommentSelectionInfo commentInfo, ITextStructureNavigator navigator, NormalizedSnapshotSpanCollection selectedSpans, CancellationToken cancellationToken) { var firstLineAroundSelection = selectedSpans.First().Start.GetContainingLine().Start; var lastLineAroundSelection = selectedSpans.Last().End.GetContainingLine().End; var linesContainingSelection = TextSpan.FromBounds(firstLineAroundSelection, lastLineAroundSelection); var blockCommentedSpans = await GetBlockCommentsInDocumentAsync( document, selectedSpans.First().Snapshot, linesContainingSelection, commentInfo, cancellationToken).ConfigureAwait(false); var blockCommentSelections = selectedSpans.SelectAsArray(span => new BlockCommentSelectionHelper(blockCommentedSpans, span)); var returnOperation = Operation.Uncomment; var textChanges = ArrayBuilder <TextChange> .GetInstance(); var trackingSpans = ArrayBuilder <CommentTrackingSpan> .GetInstance(); // Try to uncomment until an already uncommented span is found. foreach (var blockCommentSelection in blockCommentSelections) { // If any selection does not have comments to remove, then the operation should be comment. if (!TryUncommentBlockComment(blockCommentedSpans, blockCommentSelection, textChanges, trackingSpans, commentInfo)) { returnOperation = Operation.Comment; break; } } if (returnOperation == Operation.Comment) { textChanges.Clear(); trackingSpans.Clear(); foreach (var blockCommentSelection in blockCommentSelections) { BlockCommentSpan(blockCommentSelection, navigator, textChanges, trackingSpans, commentInfo); } } return(new CommentSelectionResult(textChanges.ToArrayAndFree(), trackingSpans.ToArrayAndFree(), returnOperation)); }
public static IElisionBuffer CreateElisionBufferWithoutIndentation( this IProjectionBufferFactoryService factoryService, IEditorOptions editorOptions, IContentType contentType, IEnumerable<SnapshotSpan> exposedSpans) { var spans = new NormalizedSnapshotSpanCollection(exposedSpans); if (spans.Count > 0) { // BUG(6335): We have to make sure that the spans refer to the current snapshot of // the buffer. var buffer = spans.First().Snapshot.TextBuffer; var currentSnapshot = buffer.CurrentSnapshot; spans = new NormalizedSnapshotSpanCollection( spans.Select(s => s.TranslateTo(currentSnapshot, SpanTrackingMode.EdgeExclusive))); } contentType = contentType ?? factoryService.ProjectionContentType; var elisionBuffer = factoryService.CreateElisionBuffer( null, spans, ElisionBufferOptions.None, contentType); if (spans.Count > 0) { var snapshot = spans.First().Snapshot; var buffer = snapshot.TextBuffer; // We need to figure out the shorted indentation level of the exposed lines. We'll // then remove that indentation from all lines. var indentationColumn = DetermineIndentationColumn(editorOptions, spans); var spansToElide = new List<Span>(); foreach (var span in spans) { var startLineNumber = snapshot.GetLineNumberFromPosition(span.Start); var endLineNumber = snapshot.GetLineNumberFromPosition(span.End); for (var lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) { var line = snapshot.GetLineFromLineNumber(lineNumber); var lineOffsetOfColumn = line.GetLineOffsetFromColumn(indentationColumn, editorOptions); spansToElide.Add(Span.FromBounds(line.Start, line.Start + lineOffsetOfColumn)); } } elisionBuffer.ElideSpans(new NormalizedSpanCollection(spansToElide)); } return elisionBuffer; }
public static IElisionBuffer CreateElisionBufferWithoutIndentation( this IProjectionBufferFactoryService factoryService, IEditorOptions editorOptions, IContentType contentType, IEnumerable <SnapshotSpan> exposedSpans) { var spans = new NormalizedSnapshotSpanCollection(exposedSpans); if (spans.Count > 0) { // BUG(6335): We have to make sure that the spans refer to the current snapshot of // the buffer. var buffer = spans.First().Snapshot.TextBuffer; var currentSnapshot = buffer.CurrentSnapshot; spans = new NormalizedSnapshotSpanCollection( spans.Select(s => s.TranslateTo(currentSnapshot, SpanTrackingMode.EdgeExclusive))); } contentType = contentType ?? factoryService.ProjectionContentType; var elisionBuffer = factoryService.CreateElisionBuffer( null, spans, ElisionBufferOptions.None, contentType); if (spans.Count > 0) { var snapshot = spans.First().Snapshot; var buffer = snapshot.TextBuffer; // We need to figure out the shorted indentation level of the exposed lines. We'll // then remove that indentation from all lines. var indentationColumn = DetermineIndentationColumn(editorOptions, spans); var spansToElide = new List <Span>(); foreach (var span in spans) { var startLineNumber = snapshot.GetLineNumberFromPosition(span.Start); var endLineNumber = snapshot.GetLineNumberFromPosition(span.End); for (var lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) { var line = snapshot.GetLineFromLineNumber(lineNumber); var lineOffsetOfColumn = line.GetLineOffsetFromColumn(indentationColumn, editorOptions); spansToElide.Add(Span.FromBounds(line.Start, line.Start + lineOffsetOfColumn)); } } elisionBuffer.ElideSpans(new NormalizedSpanCollection(spansToElide)); } return(elisionBuffer); }
public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans) { if (spans.Count == 0 || _doc == null || !MarkdownEditorPackage.Options.EnableOutlining) { yield break; } var descendants = _doc.Descendants(); var snapshot = spans.First().Snapshot; // Code blocks var codeBlocks = descendants.OfType <FencedCodeBlock>(); foreach (var block in codeBlocks) { if (block.IsOpen || block.Lines.Count == 0) { continue; } string text = $"{block.Info.ToUpperInvariant()} Code Block".Trim(); string tooltip = new string(block.Lines.ToString().Take(800).ToArray()); var span = new SnapshotSpan(snapshot, block.ToSimpleSpan()); var tag = new OutliningRegionTag(false, false, text, tooltip); yield return(new TagSpan <IOutliningRegionTag>(span, tag)); } // HTML Blocks var htmlBlocks = descendants.OfType <HtmlBlock>(); foreach (var block in htmlBlocks) { // This prevents outlining for single line comments if (block.Lines.Count == 1) { continue; } string text = "HTML Block"; string tooltip = new string(block.Lines.ToString().Take(800).ToArray()); var span = new SnapshotSpan(snapshot, block.ToSimpleSpan()); var tag = new OutliningRegionTag(false, false, text, tooltip); yield return(new TagSpan <IOutliningRegionTag>(span, tag)); } }
public IEnumerable <ITagSpan <TTag> > GetTags(NormalizedSnapshotSpanCollection requestedSpans) { this.AssertIsForeground(); if (requestedSpans.Count == 0) { return(SpecializedCollections.EmptyEnumerable <ITagSpan <TTag> >()); } var buffer = requestedSpans.First().Snapshot.TextBuffer; var tags = this.TryGetTagIntervalTreeForBuffer(buffer); return(tags == null ? SpecializedCollections.EmptyEnumerable <ITagSpan <TTag> >() : tags.GetIntersectingTagSpans(requestedSpans)); }
public IEnumerable <ITagSpan <TTag> > GetTags(NormalizedSnapshotSpanCollection requestedSpans) { _dataSource.ThreadingContext.ThrowIfNotOnUIThread(); if (requestedSpans.Count == 0) { return(SpecializedCollections.EmptyEnumerable <ITagSpan <TTag> >()); } var buffer = requestedSpans.First().Snapshot.TextBuffer; var tags = this.TryGetTagIntervalTreeForBuffer(buffer); return(tags == null ? SpecializedCollections.EmptyEnumerable <ITagSpan <TTag> >() : tags.GetIntersectingTagSpans(requestedSpans)); }
public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans) { var textSnapshot = spans.First().Snapshot; foreach (var tag in _aggregator.GetTags(spans)) { if (tag.Tag is GLSLClassifierTag) { foreach (var span in tag.Span.GetSpans(textSnapshot)) { // Ensure that we translate our span to the expected snapshot var translatedSpan = span.Translated(textSnapshot); yield return(new TagSpan <ClassificationTag>(translatedSpan, new ClassificationTag(_glslTypes[tag.Tag.TokenType]))); } } } }
public IEnumerable <ITagSpan <IClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans) { this.BackgroundCompilation.CheckCompilationVersion(); var compilationSnapshot = this.BackgroundCompilation.CompilationSnapshot; var symbolTokens = compilationSnapshot?.SymbolTokens; if (symbolTokens == null) { return(ImmutableArray <ITagSpan <IClassificationTag> > .Empty); } ITextSnapshot textSnapshot = compilationSnapshot.Text; if (textSnapshot == null || spans.Count == 0 || spans.First().Snapshot.Version != textSnapshot.Version) { return(ImmutableArray <ITagSpan <IClassificationTag> > .Empty); } return(symbolTokens.Select(t => new TagSpan <IClassificationTag>(new SnapshotSpan(textSnapshot, new Span(t.Key.Span.Start, t.Key.Span.Length)), t.Value))); }
internal void EnqueueChanges(NormalizedSnapshotSpanCollection changedSpans) { AssertIsForeground(); if (changedSpans.Count == 0) { return; } var snapshot = changedSpans.First().Snapshot; var version = snapshot.Version.VersionNumber; var currentSpans = _snapshotVersionToSpansMap.GetOrAdd(version, s_addFunction); var allSpans = NormalizedSnapshotSpanCollection.Union(currentSpans, changedSpans); _snapshotVersionToSpansMap[version] = allSpans; EnqueueNotificationRequest(TaggerDelay.NearImmediate); }
internal async override Task<CommentSelectionResult> CollectEditsAsync(Document document, ICommentSelectionService service, ITextBuffer subjectBuffer, NormalizedSnapshotSpanCollection selectedSpans, ValueTuple command, CancellationToken cancellationToken) { using (Logger.LogBlock(FunctionId.CommandHandler_ToggleLineComment, KeyValueLogMessage.Create(LogType.UserAction, m => { m[LanguageNameString] = document.Project.Language; m[LengthString] = subjectBuffer.CurrentSnapshot.Length; }), cancellationToken)) { var commentInfo = await service.GetInfoAsync(document, selectedSpans.First().Span.ToTextSpan(), cancellationToken).ConfigureAwait(false); if (commentInfo.SupportsSingleLineComment) { return ToggleLineComment(commentInfo, selectedSpans); } return s_emptyCommentSelectionResult; } }
public IEnumerable <ITagSpan <IClassificationTag> > GetAllTags(NormalizedSnapshotSpanCollection spans, CancellationToken cancellationToken) { this.AssertIsForeground(); if (spans.Count == 0) { return(Array.Empty <ITagSpan <IClassificationTag> >()); } var firstSpan = spans.First(); var snapshot = firstSpan.Snapshot; Debug.Assert(snapshot.TextBuffer == _subjectBuffer); var cachedSnapshot = this.CachedSnapshot; if (snapshot != cachedSnapshot) { // Our cache is not there, or is out of date. We need to compute the up to date // results. var document = snapshot.GetOpenDocumentInCurrentContextWithChanges(); if (document == null) { return(Array.Empty <ITagSpan <IClassificationTag> >()); } _classificationService = _classificationService ?? document.Project.LanguageServices.GetService <IEditorClassificationService>(); var context = new TaggerContext <IClassificationTag>(document, snapshot, cancellationToken: cancellationToken); var spanToTag = new DocumentSnapshotSpan(document, snapshot.GetFullSpan()); var task = SemanticClassificationUtilities.ProduceTagsAsync(context, spanToTag, _classificationService, _owner._typeMap); task.Wait(cancellationToken); CachedSnapshot = snapshot; CachedTags = new TagSpanIntervalTree <IClassificationTag>(snapshot.TextBuffer, SpanTrackingMode.EdgeExclusive, context.tagSpans); } if (this.CachedTags == null) { return(Array.Empty <ITagSpan <IClassificationTag> >()); } return(this.CachedTags.GetIntersectingTagSpans(spans)); }
public IEnumerable <ITagSpan <IErrorTag> > GetTags(NormalizedSnapshotSpanCollection spans) { if (m_failures != null && m_failures.Count > 0) { var first = m_failures.First(); if (spans.Count > 0 && spans.First().Snapshot.Version != first.Span.Snapshot.Version) { Update(false); } foreach (var f in m_failures) { if (spans.IntersectsWith(f.Span)) { yield return(new TagSpan <IErrorTag>(f.Span, new ErrorTag(PredefinedErrorTypeNames.Warning, f.FailureText.m_description))); } } } }
public IEnumerable <ITagSpan <ITextMarkerTag> > GetTags(NormalizedSnapshotSpanCollection spans) { var snapshot = spans.First().Snapshot; foreach (ActiveStatementTextSpan asSpan in _trackingService.GetSpans(snapshot.AsText())) { if ((asSpan.Flags & ActiveStatementFlags.LeafFrame) != 0) { continue; } var snapshotSpan = new SnapshotSpan(snapshot, Span.FromBounds(asSpan.Span.Start, asSpan.Span.End)); if (spans.OverlapsWith(snapshotSpan)) { yield return(new TagSpan <ITextMarkerTag>(snapshotSpan, ActiveStatementTag.Instance)); } } }
public IEnumerable <ITagSpan <PlayGlyphTag> > GetTags(NormalizedSnapshotSpanCollection spans) { var textSnapshot = (spans.Any()) ? spans.First().Snapshot : null; if (!features.Any() && textSnapshot != null && !tokenParser.LastParseFailed()) { tokenParser.ForceParse(textSnapshot); } var tagSPans = new List <ITagSpan <PlayGlyphTag> >(); foreach (var line in textSnapshot.Lines) { var spanLine = line.LineNumber + 1; AddFeatureTagSpan(spanLine, textSnapshot, line, tagSPans); AddScenarioTagSpan(spanLine, textSnapshot, line, tagSPans); } return(tagSPans); }
internal static NormalizedSnapshotSpanCollection CoalesceSpans(NormalizedSnapshotSpanCollection normalizedSpans) { var snapshot = normalizedSpans.First().Snapshot; // Coalesce the spans if there are a lot of them. if (normalizedSpans.Count > CoalesceDifferenceCount) { // Spans are normalized. So to find the whole span we just go from the // start of the first span to the end of the last span. normalizedSpans = new NormalizedSnapshotSpanCollection(snapshot.GetSpanFromBounds( normalizedSpans.First().Start, normalizedSpans.Last().End)); } return normalizedSpans; }