public void CreateSquiggleSpan(SimpleTagger <ErrorTag> tagger) { if (_rawSpan.Start >= _rawSpan.End || _spanTranslator == null) { return; } // TODO: Map between versions rather than using the current snapshot var snapshot = _spanTranslator.TextBuffer.CurrentSnapshot; var target = _rawSpan.ToSnapshotSpan(snapshot); //SnapshotSpan target = _spanTranslator.TranslateForward( // new Span(_rawSpan.Start.Index, _rawSpan.Length) //); if (target.Length <= 0) { return; } var tagSpan = snapshot.CreateTrackingSpan( target.Start, target.Length, SpanTrackingMode.EdgeInclusive ); tagger.CreateTagSpan(tagSpan, new ErrorTag(ErrorType, _message)); }
private void CreateTracking(IWpfTextView textView, ITextSnapshot textSnapshot, Span span) { if (_trackingSpan != null) { return; } _textView = textView; if (_tagger == null) { IComponentModel componentModel = (IComponentModel)_serviceProvider.GetService(typeof(SComponentModel)); ISarifLocationProviderFactory sarifLocationProviderFactory = componentModel.GetService <ISarifLocationProviderFactory>(); // Get a SimpleTagger over the buffer to color _tagger = sarifLocationProviderFactory.GetTextMarkerTagger(_textView.TextBuffer); } // Add the marker if (_tagger != null) { // The list of colors for TextMarkerTag are defined in Platform\Text\Impl\TextMarkerAdornment\TextMarkerProviderFactory.cs _trackingSpan = textSnapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeExclusive); } }
private void ParseSnapshot(ISnapshotTextContentProvider snapshotContent) { // queue analysis of the parsed tree at High Pri so the active buffer is quickly re-analyzed var snapshot = snapshotContent.Snapshot; if (snapshot.TextBuffer.ContentType.IsOfType(PythonCoreConstants.ContentType)) { PythonAst ast; CollectingErrorSink errorSink; ParsePythonCode((TextContentProvider)snapshotContent, out ast, out errorSink); if (ast != null) { IPythonProjectEntry analysis; if (snapshot.TextBuffer.TryGetPythonAnalysis(out analysis)) { // only update the AST when we're error free, this way we don't remove // a useful analysis with an incomplete and useless analysis. if (errorSink.Errors.Count == 0) { analysis.UpdateTree(ast, new SnapshotCookie(snapshot)); _analysisQueue.Enqueue(analysis, AnalysisPriority.High); } SimpleTagger <ErrorTag> squiggles = _squiggleProvider.GetErrorTagger(snapshot.TextBuffer); squiggles.RemoveTagSpans(x => true); // update squiggles for the live buffer foreach (ErrorResult warning in errorSink.Warnings) { var span = warning.Span; var tspan = CreateSpan(snapshot, span); squiggles.CreateTagSpan(tspan, new ErrorTag("Warning", warning.Message)); } foreach (ErrorResult error in errorSink.Errors) { var span = error.Span; var tspan = CreateSpan(snapshot, span); squiggles.CreateTagSpan(tspan, new ErrorTag("Error", error.Message)); } } } } else if (snapshot.TextBuffer.ContentType.IsOfType("xaml")) { string path = snapshot.TextBuffer.GetFilePath(); if (path != null) { IProjectEntry analysis; XamlProjectEntry xamlProject; if (_projectFiles.TryGetValue(path, out analysis) && (xamlProject = analysis as XamlProjectEntry) != null) { xamlProject.UpdateContent(((TextContentProvider)snapshotContent).GetReader(), new SnapshotCookie(snapshotContent.Snapshot)); _analysisQueue.Enqueue(analysis, AnalysisPriority.High); } } } }
public VersionTrackingTagger(ITextBuffer buffer) { m_buffer = buffer ?? throw new ArgumentNullException(nameof(buffer)); m_storage = new SimpleTagger <T>(buffer); m_buffer.Changed += Buffer_Changed; m_storage.TagsChanged += Storage_TagsChanged; }
internal static SimpleTagger <TextMarkerTag> CreateSarifLocationTaggerInternal(ITextBuffer textBuffer) { SimpleTagger <TextMarkerTag> sarifLocationTagger = textBuffer.Properties.GetOrCreateSingletonProperty <SimpleTagger <TextMarkerTag> >(delegate { return(new SimpleTagger <TextMarkerTag>(textBuffer)); }); return(sarifLocationTagger); }
public SimpleTagger<TextMarkerTag> GetTextMarkerTagger(ITextBuffer textBuffer) { SimpleTagger<TextMarkerTag> tagger; if (textBuffer.Properties.TryGetProperty(typeof(SimpleTagger<TextMarkerTag>), out tagger)) { return tagger; } tagger = new SimpleTagger<TextMarkerTag>(textBuffer); textBuffer.Properties.AddProperty(typeof(SimpleTagger<TextMarkerTag>), tagger); return tagger; }
public SimpleTagger <TextMarkerTag> GetTextMarkerTagger(ITextBuffer textBuffer) { if (textBuffer.Properties.TryGetProperty(typeof(SimpleTagger <TextMarkerTag>), out SimpleTagger <TextMarkerTag> tagger)) { return(tagger); } tagger = new SimpleTagger <TextMarkerTag>(textBuffer); textBuffer.Properties.AddProperty(typeof(SimpleTagger <TextMarkerTag>), tagger); return(tagger); }
public ErrorListPresenter(ITextBuffer textBuffer, IErrorProviderFactory squiggleProviderFactory, IServiceProvider serviceProvider) { _textBuffer = textBuffer; _textBuffer.Changed += OnTextBufferChanged; _serviceProvider = serviceProvider; _squiggleTagger = squiggleProviderFactory.GetErrorTagger(_textBuffer); _errorListProvider = new Microsoft.VisualStudio.Shell.ErrorListProvider(serviceProvider); _previousErrors = new List <ErrorTask>(); _previousSquiggles = new List <TrackingTagSpan <IErrorTag> >(); }
public ErrorListPresenter(ITextBuffer textBuffer, IErrorProviderFactory squiggleProviderFactory, IServiceProvider serviceProvider) { _textBuffer = textBuffer; _textBuffer.Changed += OnTextBufferChanged; _serviceProvider = serviceProvider; _squiggleTagger = squiggleProviderFactory.GetErrorTagger(_textBuffer); _errorListProvider = new Microsoft.VisualStudio.Shell.ErrorListProvider(serviceProvider); _previousErrors = new List<ErrorTask>(); _previousSquiggles = new List<TrackingTagSpan<IErrorTag>>(); }
private void RemoveTracking() { if (_trackingSpan != null) { // TODO: Find a way to delete TrackingSpan _marker = _tagger.CreateTagSpan(_trackingSpan, new TextMarkerTag(Color)); RemoveHighlightMarker(); _trackingSpan = null; _tagger = null; _docCookie = null; } }
private void RemoveTracking() { if (m_trackingSpan != null) { // TODO: Find a way to delete TrackingSpan m_marker = m_tagger.CreateTagSpan(m_trackingSpan, new TextMarkerTag(Color)); RemoveMarker(); m_trackingSpan = null; m_tagger = null; m_docCookie = null; } }
public void Parse(TextContentProvider /*!*/ content) { var errorSink = new CollectingErrorSink(); SourceUnitTree ast = MakeParseTree(content, errorSink); ISnapshotTextContentProvider snapshotContent = content as ISnapshotTextContentProvider; if (snapshotContent != null) { // queue analysis of the parsed tree at High Pri so the active buffer is quickly re-analyzed var snapshot = snapshotContent.Snapshot; var analysis = AnalysisItem.GetAnalysis(snapshot.TextBuffer); // only update the AST when we're error free, this way we don't remove // a useful analysis with an incomplete and useless analysis. if (errorSink.Errors.Count == 0) { analysis.UpdateTree(ast, new SnapshotCookie(snapshot)); _analysisQueue.Enqueue(analysis, AnalysisPriority.High); } SimpleTagger <ErrorTag> squiggles = _squiggleProvider.GetErrorTagger(snapshot.TextBuffer); squiggles.RemoveTagSpans(x => true); // update squiggles for the live buffer foreach (ErrorResult warning in errorSink.Warnings) { var span = warning.Span; var tspan = CreateSpan(snapshot, span); squiggles.CreateTagSpan(tspan, new ErrorTag("Warning", warning.Message)); } foreach (ErrorResult error in errorSink.Errors) { var span = error.Span; var tspan = CreateSpan(snapshot, span); squiggles.CreateTagSpan(tspan, new ErrorTag("Error", error.Message)); } } else { FileTextContentProvider fileContent = content as FileTextContentProvider; AnalysisItem analysis; if (fileContent != null && _projectFiles.TryGetValue(fileContent.Path, out analysis)) { analysis.UpdateTree(ast, new FileCookie(fileContent.Path)); _analysisQueue.Enqueue(analysis, AnalysisPriority.Normal); } } }
/// <summary> /// Clear all markers and tracking classes /// </summary> public void Clear() { if (m_marker != null) { RemoveMarker(); } if (IsTracking()) { RemoveTracking(); } m_tagger = null; }
public void CreateSquiggleSpan(SimpleTagger <ErrorTag> tagger) { SnapshotSpan target = _spanTranslator.TranslateForward( new Span(_rawSpan.Start.Index, _rawSpan.Length) ); var tagSpan = _spanTranslator.TextBuffer.CurrentSnapshot.CreateTrackingSpan( target.Start, target.Length, SpanTrackingMode.EdgeInclusive ); tagger.CreateTagSpan(tagSpan, new ErrorTag(ErrorType, _message)); }
public SquiggleErrorPresenter(IWpfTextView textView, IErrorProviderFactory squiggleProviderFactory, IServiceProvider serviceProvider) { this.textView = textView; this.textView.TextBuffer.Changed += OnTextBufferChanged; //this.textView.Closed += new EventHandler(OnTextViewClosed); textView.GotAggregateFocus += new EventHandler(OnTextViewGotFocus); this.errorListProvider = new StaDynErrorListProvider(); this.squiggleTagger = squiggleProviderFactory.GetErrorTagger(textView.TextBuffer); previousSquiggles = new List <TrackingTagSpan <IErrorTag> >(); //CreateErrors(); }
/// <summary> /// Clear all markers and tracking classes /// </summary> public void Clear() { if (_marker != null) { RemoveHighlightMarker(); } if (IsTracking()) { RemoveTracking(); } _tagger = null; }
public ErrorListPresenter(IWpfTextView textView, IErrorProviderFactory squiggleProviderFactory, IServiceProvider serviceProvider) { this.textView = textView; this.textView.TextBuffer.Changed += OnTextBufferChanged; this.textView.Closed += new EventHandler(OnTextViewClosed); this.errorListProvider = new PyErrorListProvider(); this.squiggleTagger = squiggleProviderFactory.GetErrorTagger(textView.TextBuffer); errorList = new Microsoft.VisualStudio.Shell.ErrorListProvider(serviceProvider); previousErrors = new List <ErrorTask>(); previousSquiggles = new List <TrackingTagSpan <IErrorTag> >(); CreateErrors(); }
public ErrorListPresenter(IWpfTextView textView, IErrorProviderFactory squiggleProviderFactory, IServiceProvider serviceProvider) { this.textView = textView; this.textView.TextBuffer.Changed += OnTextBufferChanged; this.textView.Closed += new EventHandler(OnTextViewClosed); this.errorListProvider = new PyErrorListProvider(); this.squiggleTagger = squiggleProviderFactory.GetErrorTagger(textView.TextBuffer); errorList = new Microsoft.VisualStudio.Shell.ErrorListProvider(serviceProvider); previousErrors = new List<ErrorTask>(); previousSquiggles = new List<TrackingTagSpan<IErrorTag>>(); CreateErrors(); }
public void CreateSquiggleSpan(SimpleTagger <ErrorTag> tagger) { if (_rawSpan.Start >= _rawSpan.End || _spanTranslator == null) { return; } var snapshot = _spanTranslator.TextBuffer.CurrentSnapshot; var target = _spanTranslator.Translate(_rawSpan, _fromVersion, snapshot); if (target.Length <= 0) { return; } var tagSpan = snapshot.CreateTrackingSpan( target.Start, target.Length, SpanTrackingMode.EdgeInclusive ); tagger.CreateTagSpan(tagSpan, new ErrorTagWithMoniker(ErrorType, _message, _moniker)); }
// Re-collapse the spans public void CollapseRegions() { if (_outliningManager == null || _textView == null || _collapsedSpans == null) { return; } ITextSnapshot snapshot = _textView.TextBuffer.CurrentSnapshot; // Get a span that includes all collapsed regions int min = Int32.MinValue; int max = Int32.MinValue; foreach (Tuple <Span, IOutliningRegionTag> span in _collapsedSpans) { if (min == Int32.MinValue || span.Item1.Start < min) { min = span.Item1.Start; } if (max == Int32.MinValue || span.Item1.End > max) { max = span.Item1.End; } } // avoid running if there were no spans if (min == Int32.MinValue) { Debug.Fail("No spans"); return; } // span containing all collapsed regions SnapshotSpan entireSpan = new SnapshotSpan(snapshot, min, max - min); // regions have not yet been tagged by the language service during the undo/redo and // so we need to tag them again in order to do the collapse SimpleTagger <IOutliningRegionTag> simpleTagger = _textView.TextBuffer.Properties.GetOrCreateSingletonProperty <SimpleTagger <IOutliningRegionTag> >(() => new SimpleTagger <IOutliningRegionTag>(_textView.TextBuffer)); Debug.Assert(!simpleTagger.GetTaggedSpans(entireSpan).GetEnumerator().MoveNext(), "The code is not expecting the regions to be tagged already. Verify that redundant tagging is not occurring."); List <Span> toCollapse = new List <Span>(); // tag the regions and add them to the list to be bulk collapsed foreach (Tuple <Span, IOutliningRegionTag> span in _collapsedSpans) { ITrackingSpan tspan = snapshot.CreateTrackingSpan(span.Item1, SpanTrackingMode.EdgeExclusive); simpleTagger.CreateTagSpan(tspan, span.Item2); toCollapse.Add(span.Item1); } // Disable the OutliningUndoManager to avoid it adding our collapse to the undo stack as an expand bool disableOutliningUndo = _textView.Options.IsOutliningUndoEnabled(); try { if (disableOutliningUndo) { _textView.Options.SetOptionValue(DefaultTextViewOptions.OutliningUndoOptionId, false); } // Do the collapse _outliningManager.CollapseAll(entireSpan, colSpan => (!colSpan.IsCollapsed && toCollapse.Contains(colSpan.Extent.GetSpan(snapshot)))); } finally { if (disableOutliningUndo) { _textView.Options.SetOptionValue(DefaultTextViewOptions.OutliningUndoOptionId, true); } } }
private void RemoveTracking() { if (m_trackingSpan != null) { // TODO: Find a way to delete TrackingSpan m_marker = m_tagger.CreateTagSpan(m_trackingSpan, new TextMarkerTag(Color)); RemoveHighlightMarker(); m_trackingSpan = null; m_tagger = null; m_docCookie = null; } }
public void ParseBuffers(BufferParser bufferParser, Severity indentationSeverity, params ITextSnapshot[] snapshots) { IProjectEntry analysis; lock (_openFiles) { if (!_openFiles.TryGetValue(bufferParser, out analysis)) { return; } } IPythonProjectEntry pyProjEntry = analysis as IPythonProjectEntry; List <PythonAst> asts = new List <PythonAst>(); bool hasErrors = false; foreach (var snapshot in snapshots) { var snapshotContent = new SnapshotSpanSourceCodeReader(new SnapshotSpan(snapshot, new Span(0, snapshot.Length))); if (pyProjEntry != null && snapshot.TextBuffer.ContentType.IsOfType(PythonCoreConstants.ContentType)) { if (!snapshot.IsReplBufferWithCommand()) { PythonAst ast; CollectingErrorSink errorSink; ParsePythonCode(snapshotContent, indentationSeverity, out ast, out errorSink); if (ast != null) { asts.Add(ast); if (errorSink.Errors.Count != 0) { hasErrors = true; } // update squiggles for the buffer var buffer = snapshot.TextBuffer; SimpleTagger <ErrorTag> squiggles = _errorProvider.GetErrorTagger(snapshot.TextBuffer); squiggles.RemoveTagSpans(x => true); TaskProvider provider = GetTaskListProviderForProject(bufferParser._currentProjEntry); AddWarnings(snapshot, errorSink, squiggles, provider); AddErrors(snapshot, errorSink, squiggles, provider); UpdateErrorList(errorSink, buffer.GetFilePath(), provider); } } } else { // other file such as XAML IExternalProjectEntry externalEntry; if ((externalEntry = (analysis as IExternalProjectEntry)) != null) { externalEntry.ParseContent(snapshotContent, new SnapshotCookie(snapshotContent.Snapshot)); _analysisQueue.Enqueue(analysis, AnalysisPriority.High); } } } if ((!hasErrors && asts.Count > 0) || asts.Count > 1) { // only update the AST when we're error free, this way we don't remove // a useful analysis with an incomplete and useless analysis. // If we have more than one AST we're in the REPL - we'll update the // AST in that case as errors won't go away. PythonAst finalAst; if (asts.Count == 1) { finalAst = asts[0]; } else { // multiple ASTs, merge them together List <Statement> bodies = new List <Statement>(); foreach (var ast in asts) { bodies.Add(ast.Body); } finalAst = new PythonAst(new SuiteStatement(bodies.ToArray()), new int[0]); } pyProjEntry.UpdateTree(finalAst, new SnapshotCookie(snapshots[0])); // SnapshotCookie is ot entirely right, we should merge the snapshots _analysisQueue.Enqueue(analysis, AnalysisPriority.High); } }
private static void AddErrors(ITextSnapshot snapshot, CollectingErrorSink errorSink, SimpleTagger <ErrorTag> squiggles, TaskProvider provider) { foreach (ErrorResult error in errorSink.Errors) { var span = error.Span; var tspan = CreateSpan(snapshot, span); squiggles.CreateTagSpan(tspan, new ErrorTag(PredefinedErrorTypeNames.SyntaxError, error.Message)); if (provider != null) { provider.AddError(error); } } }
private static void AddWarnings(ITextSnapshot snapshot, CollectingErrorSink errorSink, SimpleTagger <ErrorTag> squiggles, TaskProvider provider) { foreach (ErrorResult warning in errorSink.Warnings) { var span = warning.Span; var tspan = CreateSpan(snapshot, span); squiggles.CreateTagSpan(tspan, new ErrorTag(PredefinedErrorTypeNames.Warning, warning.Message)); if (provider != null) { provider.AddWarning(warning); } } }
public AgentTagger(ITextBuffer buffer) { _buffer = buffer; tagger = new SimpleTagger <RemoteAgentTag>(buffer); tagger.TagsChanged += (sender, args) => TagsChanged(this, args); }
private void CreateTracking(IWpfTextView textView, ITextSnapshot textSnapshot, Span span) { if (m_trackingSpan != null) return; m_textView = textView; if (m_tagger == null) { IComponentModel componentModel = (IComponentModel)m_serviceProvider.GetService(typeof(SComponentModel)); ISarifLocationProviderFactory sarifLocationProviderFactory = componentModel.GetService<ISarifLocationProviderFactory>(); // Get a SimpleTagger over the buffer to color m_tagger = sarifLocationProviderFactory.GetTextMarkerTagger(m_textView.TextBuffer); } // Add the marker if (m_tagger != null) { // The list of colors for TextMarkerTag are defined in Platform\Text\Impl\TextMarkerAdornment\TextMarkerProviderFactory.cs m_trackingSpan = textSnapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeExclusive); } }
/////////////////////////////////////////////////////////////////////////////////// // // Validate the mardown directive syntax according to the ruleset definitions // // Copyright (c) 2014 Microsoft Corporation. // Author: Junyi Yi ([email protected]) - Initial version // /////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Validate the whole document according to the specified ruleset. /// </summary> /// <param name="snapshot">The whole document snapshot.</param> /// <param name="errorTagger">The tagger used to generate error squiggles.</param> /// <param name="ruleset">The specified ruleset.</param> public static void ValidateDirectiveSyntax(ITextSnapshot snapshot, DirectiveRuleset ruleset, SimpleTagger<ErrorTag> errorTagger) { // Remove all current error squiggles errorTagger.RemoveTagSpans(errorTagSpan => true); // Get the full document text and clear all HTML tags string text = snapshot.GetText(); text = MarkdownParser.DestroyHtmlTags(text); // Three cases: // 0123456789 01234567 8 01234567 8 // [ WA ab ] [ WA ab \n [ WA ab EOT // | |-endIndex=9 | |-endIndex=8 | |-endIndex=8 // |-startIndex=0 |-startIndex=0 |-startIndex=0 // Greedily search for the pair of '[...]' (supports nested pair '[... [...] ...]') // Here 'Greedily' means if we have a string '[...[...]', it would also treat the latter '[...]' as the pair for (int startIndex = text.IndexOf('['); startIndex >= 0; startIndex = text.IndexOf('[', startIndex)) { int endIndex = MarkdownParser.FindCorrespondingEndBracket(text, startIndex + 1); // Get the directive content string ITrackingSpan overallDirective = snapshot.CreateTrackingSpan(startIndex + 1, endIndex - startIndex - 1, SpanTrackingMode.EdgeInclusive); string directive = overallDirective.GetText(snapshot); var directiveMatches = Regex.Matches(directive, string.Concat(@"^\s*(", ValidationUtilities.DirectiveNameRegularPattern, @")(.*)$")); if (directiveMatches.Count != 1 || !directiveMatches[0].Success || directiveMatches[0].Groups.Count != 3 || directiveMatches[0].Value != directive) { startIndex++; continue; } string directiveName = directiveMatches[0].Groups[1].Value; string directiveContent = directiveMatches[0].Groups[2].Value; var rule = ruleset.TryGetDirectiveRule(directiveName); if (rule != null) { // Get the preceding and following directive string of the same line ITextSnapshotLine line = snapshot.GetLineFromPosition(startIndex); string precedingText = snapshot.GetText(line.Start, startIndex - line.Start); string followingText = endIndex < line.End ? snapshot.GetText(endIndex + 1, line.End - endIndex - 1) : string.Empty; // If we found a exactly-matched rule, just validate it string message = rule.Validate(directiveContent, precedingText, followingText); if (message != null) { ITrackingSpan squiggleSpan = overallDirective; if (rule.SquiggleWholeLine) { squiggleSpan = snapshot.CreateTrackingSpan(line.Start, line.Length, SpanTrackingMode.EdgeInclusive); } errorTagger.CreateTagSpan(squiggleSpan, new ErrorTag(PredefinedErrorTypeNames.SyntaxError, message)); } // If we miss the closing bracket, give out the prompt message if (endIndex >= text.Length || text[endIndex] != ']') { errorTagger.CreateTagSpan(snapshot.CreateTrackingSpan(line.End, 0, SpanTrackingMode.EdgePositive), new ErrorTag(PredefinedErrorTypeNames.CompilerError, "Missing the closing bracket")); } } else { // Otherwise we may take a look at the suspects var suspects = ruleset.GetSuspects(directive); if (suspects.Count() > 0) { StringBuilder suspectPrompt = new StringBuilder(); suspectPrompt.AppendLine("Are you trying to enter one of the following directives?"); foreach (var suspect in suspects) { suspectPrompt.AppendLine(string.Format(" \u2022 {0} - {1}", suspect.ParentRule.DirectiveName, suspect.SuggestionMessage)); } errorTagger.CreateTagSpan(overallDirective, new ErrorTag(PredefinedErrorTypeNames.Warning, suspectPrompt.ToString().TrimEnd())); } } startIndex = endIndex; } }
public SimpleTagger <ErrorTag> GetErrorTagger(Microsoft.VisualStudio.Text.ITextBuffer textBuffer) { return(_instance = _instance ?? new SimpleTagger <ErrorTag>(textBuffer)); }
public void SetBuffer(ITextBuffer buffer) { if(buffer == null) throw new ArgumentNullException("buffer"); _Buffer = buffer; _Tagger = null; }
public SimpleTagger<ErrorTag> GetErrorTagger(Microsoft.VisualStudio.Text.ITextBuffer textBuffer) { return _instance = _instance ?? new SimpleTagger<ErrorTag>(textBuffer); }
public void CreateSquiggleSpan(SimpleTagger <ErrorTag> tagger) { tagger.CreateTagSpan(_span, new ErrorTag(ErrorType, _message)); }
/// <summary> /// Clear all markers and tracking classes /// </summary> public void Clear() { if (m_marker != null) { RemoveHighlightMarker(); } if (IsTracking()) { RemoveTracking(); } m_tagger = null; }