public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
{
ITextSnapshot snapshot = _textBuffer.CurrentSnapshot;
// trigger point
SnapshotPoint?point = session.GetTriggerPoint(snapshot);
if (point == null)
{
return;
}
// get syntax tree
SyntaxTree syntaxTree = snapshot.GetSyntaxTree();
var root = syntaxTree.Root as RobotsTxtDocumentSyntax;
// find line in syntax tree
ITextSnapshotLine line = point.Value.GetContainingLine();
RobotsTxtLineSyntax lineSyntax = root.Records.SelectMany(r => r.Lines)
.Where(l => !l.NameToken.IsMissing && !l.DelimiterToken.IsMissing)
.FirstOrDefault(l => l.Span.IntersectsWith(line.Extent));
// found
if (lineSyntax != null)
{
if (lineSyntax.DelimiterToken.Span.Span.End <= point.Value)
{
// get semantic model
ISemanticModel model = syntaxTree.GetSemanticModel();
// add signature
signatures.Add(new RobotsTxtSignature(model, lineSyntax));
}
}
}
protected override Tuple <ITextSnapshot, List <ITagSpan <ITextMarkerTag> > > GetTags(ITextSnapshot snapshot, CancellationToken cancellationToken)
{
if (snapshot != _textView.TextSnapshot)
{
return(Tuple.Create(snapshot, _emptyList));
}
var syntaxTree = snapshot.GetSyntaxTree(cancellationToken);
var unmappedPosition = _textView.GetPosition(snapshot);
var position = syntaxTree.MapRootFilePosition(unmappedPosition);
var result = _braceMatcher.MatchBraces(syntaxTree, position);
if (!result.IsValid)
{
return(Tuple.Create(snapshot, _emptyList));
}
var leftTag = new TagSpan <ITextMarkerTag>(new SnapshotSpan(snapshot, result.Left.Start, result.Left.Length), _tag);
var rightTag = new TagSpan <ITextMarkerTag>(new SnapshotSpan(snapshot, result.Right.Start, result.Right.Length), _tag);
return(Tuple.Create(snapshot, new List <ITagSpan <ITextMarkerTag> > {
leftTag, rightTag
}));
}
public static SemanticModel GetSemanticModel(this ITextSnapshot snapshot, CancellationToken cancellationToken)
{
var syntaxTree = snapshot.GetSyntaxTree(cancellationToken);
var compilation = new Compilation.Compilation(syntaxTree);
return(compilation.GetSemanticModel());
}
protected override Tuple <ITextSnapshot, List <ITagSpan <IClassificationTag> > > GetTags(ITextSnapshot snapshot, CancellationToken cancellationToken)
{
var results = new List <ITagSpan <IClassificationTag> >();
var worker = new SyntaxTaggerWorker(_classificationService, results, snapshot, cancellationToken);
worker.ClassifySyntax(snapshot.GetSyntaxTree(cancellationToken));
return(Tuple.Create(snapshot, results));
}
public void AugmentQuickInfoSession(IQuickInfoSession session, IList <object> quickInfoContent, out ITrackingSpan applicableToSpan)
{
ITextSnapshot snapshot = _buffer.CurrentSnapshot;
ITrackingPoint triggerPoint = session.GetTriggerPoint(_buffer);
SnapshotPoint point = triggerPoint.GetPoint(snapshot);
SyntaxTree syntax = snapshot.GetSyntaxTree();
RobotsTxtDocumentSyntax root = syntax.Root as RobotsTxtDocumentSyntax;
applicableToSpan = null;
// find section
RobotsTxtLineSyntax line = root.Records
.SelectMany(r => r.Lines)
.FirstOrDefault(s => s.NameToken.Span.Span.Contains(point));
if (line != null)
{
IClassificationFormatMap formatMap = _classificationFormatMapService.GetClassificationFormatMap(session.TextView);
string fieldName = line.NameToken.Value;
// get glyph
var glyph = _glyphService.GetGlyph(StandardGlyphGroup.GlyphGroupProperty, StandardGlyphItem.GlyphItemPublic);
var classificationType = _classificationRegistry.GetClassificationType("RobotsTxt/RecordName");
var format = formatMap.GetTextProperties(classificationType);
// construct content
ISemanticModel model = syntax.GetSemanticModel();
var field = model.GetFieldSymbol(line);
var content = new QuickInfoContent
{
Glyph = glyph,
Signature = new Run(field.Name)
{
Foreground = format.ForegroundBrush
},
Documentation = RobotsTxtDocumentation.GetDocumentation(field),
};
// add to session
quickInfoContent.Add(
new ContentPresenter
{
Content = content,
ContentTemplate = Template,
}
);
applicableToSpan = snapshot.CreateTrackingSpan(line.NameToken.Span.Span, SpanTrackingMode.EdgeInclusive);
return;
}
}
protected override Tuple <ITextSnapshot, List <ITagSpan <IOutliningRegionTag> > > GetTags(ITextSnapshot snapshot, CancellationToken cancellationToken)
{
if (!_enabled)
{
return(Tuple.Create(snapshot, new List <ITagSpan <IOutliningRegionTag> >()));
}
var outliningRegions = new List <ITagSpan <IOutliningRegionTag> >();
var outliningVisitor = new OutliningVisitor(snapshot, outliningRegions, cancellationToken);
outliningVisitor.VisitCompilationUnit((CompilationUnitSyntax)snapshot.GetSyntaxTree(cancellationToken).Root);
return(Tuple.Create(snapshot, outliningRegions));
}
private async Task InvalidateTargets(ITextSnapshot snapshot, CancellationToken cancellationToken)
{
var navigationTargets = new List<EditorTypeNavigationTarget>();
var navigationTargetsVisitor = new NavigationTargetsVisitor(snapshot, _glyphService, cancellationToken);
await Task.Run(() =>
{
var syntaxTree = snapshot.GetSyntaxTree(cancellationToken);
navigationTargets.AddRange(navigationTargetsVisitor.GetTargets((CompilationUnitSyntax) syntaxTree.Root));
}, cancellationToken);
_navigationTargets = navigationTargets;
OnNavigationTargetsChanged(EventArgs.Empty);
}
private async Task InvalidateTargets(ITextSnapshot snapshot, CancellationToken cancellationToken)
{
var navigationTargets = new List <EditorTypeNavigationTarget>();
var navigationTargetsVisitor = new NavigationTargetsVisitor(snapshot, _glyphService, cancellationToken);
await Task.Run(() =>
{
var syntaxTree = snapshot.GetSyntaxTree(cancellationToken);
navigationTargets.AddRange(navigationTargetsVisitor.GetTargets((CompilationUnitSyntax)syntaxTree.Root));
}, cancellationToken);
_navigationTargets = navigationTargets;
OnNavigationTargetsChanged(EventArgs.Empty);
}
protected override void CreateSyntaxTree(ITextSnapshot snapshot, CancellationToken cancellationToken)
{
// Force creation of SyntaxTree.
snapshot.GetSyntaxTree(cancellationToken);
}
protected override Tuple <SyntaxTreeBase, IEnumerable <Diagnostic> > GetDiagnostics(ITextSnapshot snapshot, CancellationToken cancellationToken)
{
var syntaxTree = snapshot.GetSyntaxTree(cancellationToken);
return(Tuple.Create((SyntaxTreeBase)syntaxTree, syntaxTree.GetDiagnostics()));
}
protected override IEnumerable <Diagnostic> GetDiagnostics(ITextSnapshot snapshot, CancellationToken cancellationToken)
{
return(snapshot.GetSyntaxTree(cancellationToken).GetDiagnostics());
}
protected override IEnumerable<Diagnostic> GetDiagnostics(ITextSnapshot snapshot, CancellationToken cancellationToken)
{
return snapshot.GetSyntaxTree(cancellationToken).GetDiagnostics();
}
protected override void CreateSyntaxTree(ITextSnapshot snapshot, CancellationToken cancellationToken)
{
// Force creation of SyntaxTree.
snapshot.GetSyntaxTree(cancellationToken);
}
public void AugmentCompletionSession(ICompletionSession session, IList <CompletionSet> completionSets)
{
if (_disposed)
{
return;
}
// get snapshot
ITextSnapshot snapshot = _buffer.CurrentSnapshot;
var triggerPoint = session.GetTriggerPoint(snapshot);
if (triggerPoint == null)
{
return;
}
// get or compute syntax tree
SyntaxTree syntaxTree = snapshot.GetSyntaxTree();
RobotsTxtDocumentSyntax root = syntaxTree.Root as RobotsTxtDocumentSyntax;
// find line
var lineSyntax = root.Records
.SelectMany(r => r.Lines)
.FirstOrDefault(l => l.Span.ContainsOrEndsWith(triggerPoint.Value));
if (lineSyntax != null)
{
// complete existing field
if (lineSyntax.NameToken.Span.Span.ContainsOrEndsWith(triggerPoint.Value))
{
IList <Completion> completions = new List <Completion>();
// applicable to
ITrackingSpan applicableTo = snapshot.CreateTrackingSpan(lineSyntax.NameToken.Span.Span, SpanTrackingMode.EdgeInclusive);
// find lines before
var before = lineSyntax.Record.Lines
.TakeWhile(l => l != lineSyntax)
.ToList();
// compute completions
AugmentCompletionsBasedOnLinesBefore(before, completions);
completionSets.Add(
new CompletionSet("All", "All", applicableTo, completions, Enumerable.Empty <Completion>())
);
}
}
// blank line
else
{
ITextSnapshotLine line = triggerPoint.Value.GetContainingLine();
// check whether the trigger point is in comment
int commentIndex = line.GetText().IndexOf(RobotsTxtSyntaxFacts.Comment);
if (commentIndex != -1)
{
if (commentIndex < (triggerPoint.Value - line.Start))
{
return;
}
}
IList <Completion> completions = new List <Completion>();
// find last line before
RobotsTxtLineSyntax lineBefore = root.Records
.SelectMany(r => r.Lines)
.TakeWhile(l => l.Span.End < triggerPoint.Value)
.LastOrDefault();
// no line before
if (lineBefore == null)
{
completions.Add(ToCompletion("User-agent"));
}
// there is a line before
else
{
// same record
if (lineBefore.Span.Start.GetContainingLine().LineNumber ==
triggerPoint.Value.GetContainingLine().LineNumber - 1)
{
// find lines before
var before = lineBefore.Record.Lines
.TakeWhile(l => l != lineSyntax)
.ToList();
// compute completions
AugmentCompletionsBasedOnLinesBefore(before, completions);
}
// new record
else
{
completions.Add(ToCompletion("User-agent"));
}
}
var applicableTo = snapshot.CreateTrackingSpan(new SnapshotSpan(triggerPoint.Value, triggerPoint.Value), SpanTrackingMode.EdgeInclusive);
completionSets.Add(
new CompletionSet("All", "All", applicableTo, completions, Enumerable.Empty <Completion>())
);
}
}
