private HashSet <Completion> CompleteWord(int pos, IAst astRoot, IParseResult parseResult, SourceSnapshot source, ITextSnapshot compiledSnapshot)
{
var completionList = new HashSet <Completion>();
var nspan = new NSpan(pos, pos);
if (IsInsideComment(parseResult, nspan))
{
return(completionList);
}
var visitor = new FindNodeAstVisitor(nspan);
visitor.Visit(astRoot);
var stack = visitor.Stack
.Where(ast => !(ast is IEnumerable)) // Skip IAstList
.ToArray();
if (ShouldComplete(stack, pos, compiledSnapshot))
{
GetCompletions(completionList, stack);
AddKeywordCompletions(stack, completionList);
}
return(completionList);
}
public NitraError(CompilerMessage compilerMessage)
{
_compilerMessage = compilerMessage;
var loc = _compilerMessage.Location;
var nitraFile = (XXLanguageXXFile)loc.Source.File;
var span = loc.Span;
NitraFile = nitraFile;
var doc = nitraFile.Document;
// ReSharper don't show message for empty span
if (span.IsEmpty)
{
if (span.StartPos > 0)
{
span = new NSpan(span.StartPos - 1, span.EndPos);
}
else if (span.EndPos < doc.GetTextLength())
{
span = new NSpan(span.StartPos, span.EndPos + 1);
}
}
DocumentRange = new DocumentRange(doc, new TextRange(span.StartPos, span.EndPos));
}
public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
//Debug.WriteLine($"GetTags({spans}) begin");
var oldSnapshot = _oldSnapshot;
var outlining = _outlining;
foreach (var span in spans)
{
var translatedSnapshotSpan = span.TranslateTo(oldSnapshot, SpanTrackingMode.EdgeExclusive);
var translatedSpan = translatedSnapshotSpan.Span;
var nSpan = new NSpan(translatedSpan.Start, translatedSpan.End);
var info = new OutliningInfo(nSpan, false, false);
foreach (var currentInfo in outlining)
{
var currentSpan = currentInfo.Span;
if (!nSpan.IntersectsWith(currentSpan))
{
continue;
}
var tagSpan = new TagSpan <IOutliningRegionTag>(
new SnapshotSpan(oldSnapshot, new Span(currentSpan.StartPos, currentSpan.Length))
.TranslateTo(span.Snapshot, SpanTrackingMode.EdgeExclusive),
new OutliningRegionTag(currentInfo.IsDefaultCollapsed, currentInfo.IsImplementation, "...", "colapsed code..."));
Debug.WriteLine($" tagSpan={{Start={tagSpan.Span.Start.Position}, Len={tagSpan.Span.Length}}}");
yield return(tagSpan);
}
//Debug.WriteLine($"GetTags({spans}) end");
}
}
private void CollectError(RecoveryParser rp, FlattenSequences results)
{
//var text = rp.ParseResult.Text;
var expected = new Dictionary <NSpan, HashSet <ParsedSequenceAndSubrule> >();
var failSeq = default(ParsedSequence);
var failSubrule = default(ParsedSubrule);
var skipRecovery = false;
foreach (var result in results)
{
var reverse = result.ToArray().Reverse();
foreach (var x in reverse)
{
var ins = x.TokenChanges;
var seq = x.Seq;
var subrule = x.Subrule;
if (skipRecovery)
{
if (!ins.HasChanges && seq.ParsingSequence.RuleName != "s")
{
skipRecovery = false;
//Debug.WriteLine(x);
HashSet <ParsedSequenceAndSubrule> parsedNodes;
var span = new NSpan(failSubrule.Begin, subrule.Begin);
if (!expected.TryGetValue(span, out parsedNodes))
{
parsedNodes = new HashSet <ParsedSequenceAndSubrule>();
expected[span] = parsedNodes;
}
if (failSubrule.IsEmpty)
{
parsedNodes.Add(new ParsedSequenceAndSubrule(failSeq, failSubrule));
}
else
{
parsedNodes.Add(new ParsedSequenceAndSubrule(seq, subrule));
}
}
}
else
{
if (ins.HasChanges)
{
failSeq = seq;
failSubrule = subrule;
skipRecovery = true;
}
}
}
}
var parseResult = rp.ParseResult;
foreach (var e in expected)
{
parseResult.ReportError(new ExpectedSubrulesError(new Location(parseResult.OriginalSource, e.Key.StartPos, e.Key.EndPos), e.Value));
}
}
public CompletionData(NSpan span, string text, string contentXaml = null, string descriptionXaml = null, double priority = 0.0)
{
Span = span;
ContentXaml = contentXaml ?? text;
DescriptionXaml = descriptionXaml ?? "";
Priority = priority;
Text = text;
}
public PopupItemViewModel(int symbolId, FileVm file, NSpan span, bool isDefenition, IntelliSensePopupViewModel popup)
{
SymbolId = symbolId;
File = file;
Span = span;
IsDefenition = isDefenition;
Text = file.Name + " (" + span + ")"; // TODO: convert to line pos and make line preview
Popup = popup;
}
#pragma warning restore 67
public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan processedSpan)
{
var currentSnapshot = processedSpan.Snapshot;
var result = new List <ClassificationSpan>();
for (int i = 0; i < _spanInfos.Length; i++)
{
var oldSnapshot = _snapshots[i];
var spanInfos = _spanInfos[i];
var translaterSpan = processedSpan.TranslateTo(oldSnapshot, SpanTrackingMode.EdgeExclusive);
NSpan translaterNSpan = new NSpan(translaterSpan.Span.Start, translaterSpan.Span.End);
var processedSpanInfo = new SpanInfo(translaterNSpan, -1);
var index = spanInfos.BinarySearch(processedSpanInfo, SpanInfo.Comparer);
if (index < 0)
{
index = ~index;
if (index > 0)
{
index--;
}
}
var prevSpan = default(NSpan);
for (int k = index; k < spanInfos.Length; k++)
{
var spanInfo = spanInfos[k];
var nSpan = spanInfo.Span;
if (nSpan.EndPos < translaterNSpan.StartPos)
{
continue;
}
if (nSpan.StartPos > translaterNSpan.EndPos)
{
break;
}
if (prevSpan == nSpan)
{
continue;
}
prevSpan = nSpan;
var newSpan = new SnapshotSpan(oldSnapshot, new Span(nSpan.StartPos, nSpan.Length))
.TranslateTo(currentSnapshot, SpanTrackingMode.EdgeExclusive);
if (ClassificationMap.TryGetValue(spanInfo.SpanClassId, out var classificationType))
{
result.Add(new ClassificationSpan(newSpan, classificationType));
}
else
{
}
}
}
return(result);
}
public PopupItemViewModel(int symbolId, FileVm file, NSpan span, bool isDefenition, IntelliSensePopupViewModel popup)
{
SymbolId = symbolId;
File = file;
Span = span;
IsDefenition = isDefenition;
Text = file.Name + " (" + span + ")"; // TODO: convert to line pos and make line preview
Popup = popup;
}
public void SelectText(FileVm file, NSpan span)
{
if (Host.CurrentSolution == null)
return;
if (file == null)
return;
file.IsSelected = true;
Selection = span;
ScrollPosition = new ScrollPosition(CaretLine, CaretColumn);
}
protected override void FormatString(IPrettyPrintSource source, NSpan token, string text, SpanClass spanClass)
{
if (token.IsEmpty)
{
if ((Options & PrettyPrintOptions.MissingNodes) == PrettyPrintOptions.MissingNodes)
{
WriteSpan(_missingNodeClass, text);
}
}
else
{
WebUtility.HtmlEncode(text, _writer);
}
}
void ShowInFindResultWindow(FileModel fileModel, NSpan span, Location[] locations)
{
Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread();
CheckDisposed();
if (locations.Length == 0)
{
return;
}
if (locations.Length == 1)
{
GoToLocation(fileModel, locations[0]);
return;
}
var findSvc = (IVsFindSymbol)fileModel.Server.ServiceProvider.GetService(typeof(SVsObjectSearch));
Debug.Assert(findSvc != null);
var caption = _wpfTextView.TextBuffer.CurrentSnapshot.GetText(VsUtils.Convert(span));
var libSearchResults = new LibraryNode("<Nitra>", LibraryNode.LibraryNodeType.References, LibraryNode.LibraryNodeCapabilities.None, null);
foreach (var location in locations)
{
var inner = new GotoInfoLibraryNode(location, caption, fileModel.Server);
libSearchResults.AddNode(inner);
}
var package = NitraCommonVsPackage.Instance;
package.SetFindResult(libSearchResults);
var criteria =
new[]
{
new VSOBSEARCHCRITERIA2
{
eSrchType = VSOBSEARCHTYPE.SO_ENTIREWORD,
grfOptions = (uint)_VSOBSEARCHOPTIONS.VSOBSO_CASESENSITIVE,
szName = "<dummy>",
dwCustom = Library.FindAllReferencesMagicNum,
}
};
var scope = Library.MagicGuid;
var hr = findSvc.DoSearch(ref scope, criteria);
}
protected override void FormatToken(IPrettyPrintSource source, NSpan token, bool canBeEmpty, string ruleName, SpanClass spanClass)
{
TryPrintGarbage(source, token);
if (token.IsEmpty)
{
if (!canBeEmpty && (Options & PrettyPrintOptions.MissingNodes) == PrettyPrintOptions.MissingNodes)
{
WriteSpan(_missingNodeClass, ruleName);
}
}
else
{
var text = source.Text.Substring(token.StartPos, token.Length);
WebUtility.HtmlEncode(text, _writer);
}
}
public void SelectText(FileVm file, NSpan span)
{
if (Host.CurrentSolution == null)
{
return;
}
if (file == null)
{
return;
}
file.IsSelected = true;
Selection = span;
ScrollPosition = new ScrollPosition(CaretLine, CaretColumn);
}
private static bool IsInsideComment(IParseResult parseResult, NSpan nspan)
{
var voidRuleWalker = new VoidRuleWalker(nspan);
var spans = new HashSet <SpanInfo>();
voidRuleWalker.Walk(parseResult, spans);
foreach (var span in spans)
{
if (span.Span.Contains(nspan) && span.SpanClass != Nitra.Language.DefaultSpanClass)
{
return(true);
}
}
return(false);
}
private void SelectText(File file, NSpan span)
{
if (_currentTestFolder != null)
{
foreach (var test in _currentTestFolder.Tests)
{
if (test.File == file)
{
test.IsSelected = true;
break;
}
}
}
_text.CaretOffset = span.StartPos;
_text.Select(span.StartPos, span.Length);
_text.ScrollTo(_text.TextArea.Caret.Line, _text.TextArea.Caret.Column);
}
void ShowInFindResultWindow(FileModel fileModel, NSpan span, Location[] locations)
{
CheckDisposed();
if (locations.Length == 1)
{
GoToLocation(fileModel, locations[0]);
return;
}
var findSvc = (IVsObjectSearch)fileModel.Server.ServiceProvider.GetService(typeof(SVsObjectSearch));
Debug.Assert(findSvc != null);
var caption = _wpfTextView.TextBuffer.CurrentSnapshot.GetText(VsUtils.Convert(span));
var libSearchResults = new LibraryNode("<Nitra>", LibraryNode.LibraryNodeType.References, LibraryNode.LibraryNodeCapabilities.None, null);
foreach (var location in locations)
{
var inner = new GotoInfoLibraryNode(location, caption, fileModel.Server);
libSearchResults.AddNode(inner);
}
var package = NitraCommonVsPackage.Instance;
package.SetFindResult(libSearchResults);
var criteria =
new[]
{
new VSOBSEARCHCRITERIA
{
eSrchType = VSOBSEARCHTYPE.SO_ENTIREWORD,
grfOptions = (uint)_VSOBSEARCHOPTIONS.VSOBSO_CASESENSITIVE,
szName = "<dummy>",
dwCustom = Library.FindAllReferencesMagicNum,
}
};
IVsObjectList results;
var hr = findSvc.Find((uint)__VSOBSEARCHFLAGS.VSOSF_EXPANDREFS, criteria, out results);
}
public bool GoToDefinition(int position)
{
var result = _compilerService.LatestResult?.GetFile(_document.FilePath);
if (result == null)
{
return(false);
}
var span = new NSpan(position, position);
var quickInfoContent = new List <object>();
bool foundSomething;
var symbol = QuickInfoSource.SpanToSymbol(quickInfoContent, span, result.Ast, out foundSomething);
var declaration = symbol?.FirstDeclarationOrDefault;
var source = declaration?.Source;
if (source != null && source != SourceSnapshot.Default)
{
return(Utils.MoveToLocation(declaration.Location));
}
return(false);
}
void OnGoToBrace()
{
var brackets = _textViewModel.MatchedBrackets;
var pairs = brackets?.results;
if (!pairs.HasValue || pairs.Value.IsDefaultOrEmpty)
{
return;
}
var caretPosition = _wpfTextView.Caret.Position;
var caretPosOpt = caretPosition.Point.GetPoint(_wpfTextView.TextBuffer, caretPosition.Affinity);
if (!caretPosOpt.HasValue)
{
return;
}
var caretPos = caretPosOpt.Value;
if (caretPos.Snapshot.Version.VersionNumber != brackets.Version + 1)
{
return;
}
var span = new NSpan(caretPos.Position, caretPos.Position);
foreach (var pair in pairs.Value)
{
if (pair.Open.IntersectsWith(span))
{
NavigateTo(caretPos.Snapshot, pair.Close.EndPos);
}
else if (pair.Close.IntersectsWith(span))
{
NavigateTo(caretPos.Snapshot, pair.Open.StartPos);
}
}
}
protected override void Garbage(IPrettyPrintSource source, NSpan skip)
{
var text = source.Text.Substring(skip.StartPos, skip.Length);
WriteSpan(_garbageClass, text);
}
public static DeclarationSymbol SpanToSymbol(IList <object> quickInfoContent, NSpan span, IAst ast, out bool foundSomething)
{
var cts = new CancellationTokenSource();
DeclarationSymbol symbol = null;
var visitor = new CollectSymbolsAndRefsInSpanAstVisitor(cts.Token, span);
visitor.Visit(ast);
foreach (var rf in visitor.Refs)
{
if (rf.IsAmbiguous)
{
var foundHint = false;
foreach (var ambiguity in rf.Ambiguities)
{
var hint = SymbolToHint(ambiguity);
if (hint != null)
{
quickInfoContent.Add(hint);
symbol = ambiguity;
foundHint = true;
break;
}
}
if (foundHint)
{
break;
}
}
else if (rf.IsSymbolEvaluated)
{
var hint = SymbolToHint(rf.Symbol);
if (hint != null)
{
quickInfoContent.Add(hint);
symbol = rf.Symbol;
break;
}
}
}
foundSomething = visitor.Refs.Count > 0 || visitor.Names.Count > 0;
return(symbol);
}
internal static void NavigateTo(IServiceProvider serviceProvider, string filename, NSpan span)
{
IVsTextView viewAdapter;
IVsWindowFrame pWindowFrame;
OpenDocument(serviceProvider, filename, out viewAdapter, out pWindowFrame);
if (pWindowFrame == null || viewAdapter == null)
{
return;
}
ErrorHandler.ThrowOnFailure(pWindowFrame.Show());
var wpfTextView = viewAdapter.ToIWpfTextView();
var textViewModel = wpfTextView.TryGetTextViewModel();
if (textViewModel == null)
{
return;
}
var snapshot = wpfTextView.TextSnapshot;
if (span.EndPos >= snapshot.Length)
{
return;
}
textViewModel.NavigateTo(wpfTextView.TextSnapshot, span.StartPos);
wpfTextView.Selection.Select(new SnapshotSpan(snapshot, new Span(span.StartPos, span.Length)), false);
}
public static Span Convert(NSpan span)
{
return(new Span(span.StartPos, span.Length));
}
void OnGoToBrace()
{
var brackets = _textViewModel.MatchedBrackets;
var pairs = brackets?.results;
if (!pairs.HasValue || pairs.Value.IsDefaultOrEmpty)
return;
var caretPosition = _wpfTextView.Caret.Position;
var caretPosOpt = caretPosition.Point.GetPoint(_wpfTextView.TextBuffer, caretPosition.Affinity);
if (!caretPosOpt.HasValue)
return;
var caretPos = caretPosOpt.Value;
if (caretPos.Snapshot.Version.VersionNumber != brackets.Version + 1)
return;
var span = new NSpan(caretPos.Position, caretPos.Position);
foreach (var pair in pairs.Value)
{
if (pair.Open.IntersectsWith(span))
NavigateTo(caretPos.Snapshot, pair.Close.EndPos);
else if (pair.Close.IntersectsWith(span))
NavigateTo(caretPos.Snapshot, pair.Open.StartPos);
}
}
public static TagSpan <TextMarkerTag> MakeTagSpan(ITextSnapshot currentSnapshot, NSpan nSpan, string tagType)
{
var span = new SnapshotSpan(currentSnapshot, VsUtils.Convert(nSpan));
return(new TagSpan <TextMarkerTag>(span, new TextMarkerTag(tagType)));
}
protected override void Garbage(IPrettyPrintSource source, NSpan skip)
{
var text = source.Text.Substring(skip.StartPos, skip.Length);
WriteSpan(_garbageClass, text);
}
private void SelectText(File file, NSpan span)
{
if (_currentTestFolder != null)
{
foreach (var test in _currentTestFolder.Tests)
{
if (test.File == file)
{
test.IsSelected = true;
break;
}
}
}
_text.CaretOffset = span.StartPos;
_text.Select(span.StartPos, span.Length);
_text.ScrollTo(_text.TextArea.Caret.Line, _text.TextArea.Caret.Column);
}
private bool TryMatchBrace(NSpan brace, int pos, int gotoPos)
{
if (!brace.IntersectsWith(pos))
return false;
_text.CaretOffset = gotoPos;
_text.ScrollTo(_text.TextArea.Caret.Line, _text.TextArea.Caret.Column);
return true;
}
protected override void FormatString(IPrettyPrintSource source, NSpan token, string text)
{
if (token.IsEmpty)
{
if ((Options & PrettyPrintOptions.MissingNodes) == PrettyPrintOptions.MissingNodes)
WriteSpan(_missingNodeClass, text);
}
else
WebUtility.HtmlEncode(text, _writer);
}
public CollectSymbolsAstVisitor(NSpan span) { _span = span; SpanInfos = new List<SpanInfo>(); }
public FindSpansForVisitor(SnapshotSpan span)
{
_span = new NSpan(span.Start, span.End);
SpanInfos = new List <SpanInfo>();
}
protected override void FormatToken(IPrettyPrintSource source, NSpan token, bool canBeEmpty, string ruleName)
{
TryPrintGarbage(source, token);
if (token.IsEmpty)
{
if (!canBeEmpty && (Options & PrettyPrintOptions.MissingNodes) == PrettyPrintOptions.MissingNodes)
WriteSpan(_missingNodeClass, ruleName);
}
else
{
var text = source.Text.Substring(token.StartPos, token.Length);
WebUtility.HtmlEncode(text, _writer);
}
}
public NitraError(CompilerMessage compilerMessage)
{
_compilerMessage = compilerMessage;
var loc = _compilerMessage.Location;
var nitraFile = (XXLanguageXXFile)loc.Source.File;
var span = loc.Span;
NitraFile = nitraFile;
var doc = nitraFile.Document;
// ReSharper don't show message for empty span
if (span.IsEmpty)
{
if (span.StartPos > 0)
span = new NSpan(span.StartPos - 1, span.EndPos);
else if (span.EndPos < doc.GetTextLength())
span = new NSpan(span.StartPos, span.EndPos + 1);
}
DocumentRange = new DocumentRange(doc, new TextRange(span.StartPos, span.EndPos));
}
public static TagSpan <TextMarkerTag> MakeTagSpan(ITextSnapshot lastSnapshot, ITextSnapshot currentSnapshot, NSpan nSpan, string tagType)
{
var span = new SnapshotSpan(lastSnapshot, VsUtils.Convert(nSpan));
var translatedSpan = span.TranslateTo(currentSnapshot, SpanTrackingMode.EdgeExclusive);
return(new TagSpan <TextMarkerTag>(translatedSpan, new TextMarkerTag(tagType)));
}
private void CollectError(RecoveryParser rp, FlattenSequences results)
{
//var text = rp.ParseResult.Text;
var expected = new Dictionary<NSpan, HashSet<ParsedSequenceAndSubrule>>();
var failSeq = default(ParsedSequence);
var failSubrule = default(ParsedSubrule);
var skipRecovery = false;
foreach (var result in results)
{
var reverse = result.ToArray().Reverse();
foreach (var x in reverse)
{
var ins = x.TokenChanges;
var seq = x.Seq;
var subrule = x.Subrule;
if (skipRecovery)
{
if (!ins.HasChanges && seq.ParsingSequence.RuleName != "s")
{
skipRecovery = false;
//Debug.WriteLine(x);
HashSet<ParsedSequenceAndSubrule> parsedNodes;
var span = new NSpan(failSubrule.Begin, subrule.Begin);
if (!expected.TryGetValue(span, out parsedNodes))
{
parsedNodes = new HashSet<ParsedSequenceAndSubrule>();
expected[span] = parsedNodes;
}
if (failSubrule.IsEmpty)
parsedNodes.Add(new ParsedSequenceAndSubrule(failSeq, failSubrule));
else
parsedNodes.Add(new ParsedSequenceAndSubrule(seq, subrule));
}
}
else
{
if (ins.HasChanges)
{
failSeq = seq;
failSubrule = subrule;
skipRecovery = true;
}
}
}
}
var parseResult = rp.ParseResult;
foreach (var e in expected)
parseResult.ReportError(new ExpectedSubrulesError(new Location(parseResult.OriginalSource, e.Key.StartPos, e.Key.EndPos), e.Value));
}
