public Task <CompletionList> Handle(CompletionParams request, CancellationToken cancellationToken)
{
log.LogDebug($"Completion requested at {request.Position.ToLineChr()}.");
var document = rhetosWorkspace.Value.GetRhetosDocument(request.TextDocument.Uri.ToUri());
if (document == null)
{
return(Task.FromResult <CompletionList>(null));
}
var keywords = document.GetCompletionKeywordsAtPosition(request.Position.ToLineChr());
var completionItems = keywords
.Select(keyword => new CompletionItem()
{
Label = keyword,
Kind = CompletionItemKind.Keyword,
Detail = conceptQueries.Value.GetFullDescription(keyword),
})
.ToList();
var completionList = new CompletionList(completionItems);
log.LogTrace($"Returning completion list with {completionItems.Count} items.");
return(Task.FromResult(completionList));
}
/// <summary>
/// Creates a new code completion window.
/// </summary>
public PythonConsoleCompletionWindow(TextArea textArea, PythonTextEditor textEditor)
: base(textArea)
{
_completionList = new CompletionList();
// keep height automatic
_completionDataProvider = textEditor.CompletionProvider;
_textEditor = textEditor;
CloseAutomatically = true;
SizeToContent = SizeToContent.Height;
MaxHeight = 300;
Width = 250;
Content = _completionList;
// prevent user from resizing window to 0x0
MinHeight = 15;
MinWidth = 30;
_toolTip.PlacementTarget = this;
_toolTip.Placement = PlacementMode.Right;
_toolTip.Closed += ToolTip_Closed;
_completionList.InsertionRequested += CompletionList_InsertionRequested;
_completionList.SelectionChanged += CompletionList_SelectionChanged;
AttachEvents();
_updateDescription = new DispatcherTimer();
_updateDescription.Tick += new EventHandler(CompletionListUpdateDescription);
_updateDescriptionInterval = TimeSpan.FromSeconds(0.3);
EventInfo eventInfo = typeof(TextView).GetEvent("ScrollOffsetChanged");
Delegate methodDelegate = Delegate.CreateDelegate(eventInfo.EventHandlerType, (this as CompletionWindowBase), "TextViewScrollOffsetChanged");
eventInfo.RemoveEventHandler(TextArea.TextView, methodDelegate);
}
// Internal for benchmarking and testing
internal static CompletionList CreateLSPCompletionList(
IReadOnlyList <RazorCompletionItem> razorCompletionItems,
CompletionListCache completionListCache,
IReadOnlyList <ExtendedCompletionItemKinds> supportedItemKinds)
{
var resultId = completionListCache.Set(razorCompletionItems);
var completionItems = new List <CompletionItem>();
foreach (var razorCompletionItem in razorCompletionItems)
{
if (TryConvert(razorCompletionItem, supportedItemKinds, out var completionItem))
{
// The completion items are cached and can be retrieved via this result id to enable the "resolve" completion functionality.
completionItem.SetCompletionListResultId(resultId);
completionItems.Add(completionItem);
}
}
var completionList = new CompletionList(completionItems, isIncomplete: false);
// We wrap the pre-existing completion list with an optimized completion list to better control serialization/deserialization
var optimizedCompletionList = new OptimizedCompletionList(completionList);
return(optimizedCompletionList);
}
/// <summary>
/// Auto-complete completion provider request callback
/// </summary>
/// <param name="textDocumentPosition"></param>
/// <param name="requestContext"></param>
/// <returns></returns>
internal async Task HandleCompletionRequest(TextDocumentPosition textDocumentPosition, RequestContext <CompletionList> requestContext)
{
CompletionList completionList = new CompletionList();
completionList.IsIncomplete = false;
Text text = this.CreateXmlTextFromTextDocumentUri(textDocumentPosition.TextDocument.Uri);
TextPosition textPosition = PositionUtils.CreateTextPosition(text.Content, textDocumentPosition.Position);
XmlCodeCompletionProvider xmlCodeCompletion = this.CreateCodeCompletionProvider(text, textPosition);
XmlCompletionItemCollection xmlCompletionItemCollection = xmlCodeCompletion.RetrieveCompletionItemCollection();
if (xmlCompletionItemCollection != null)
{
foreach (XmlCompletionItem xmlCompletionItem in xmlCompletionItemCollection)
{
completionList.Items.Add(new CompletionItem()
{
Detail = null, //"This is the documentation. Not Implemented",
Documentation = xmlCompletionItem.Documentation,
Kind = CompletionItemKind.Text,
Label = xmlCompletionItem.Text,
});
}
}
await requestContext.SendResult(completionList);
}
public void LibmanCompletion_VersionCompletionInDescendingOrder()
{
_libmanConfig.Open();
Editor.Caret.MoveToExpression("\"libraries\"");
Editor.Caret.MoveDown(1);
Editor.KeyboardCommands.Type("{");
Editor.KeyboardCommands.Enter();
Editor.KeyboardCommands.Type("\"provider\": \"unpkg\",");
Editor.KeyboardCommands.Enter();
Editor.KeyboardCommands.Type("\"library\":");
Editor.KeyboardCommands.Type("jquery@");
CompletionList items = Helpers.Completion.WaitForCompletionItems(Editor, 5000);
Assert.IsNotNull(items, "Time out waiting for the version completion list");
List <SemanticVersion> semanticVersions = new List <SemanticVersion>();
// CompletionList implements the List, so foreach can guarentee its iteration order as original.
foreach (CompletionItem item in items)
{
semanticVersions.Add(SemanticVersion.Parse(item.Text));
}
for (int i = 1; i < semanticVersions.Count; ++i)
{
Assert.IsTrue(semanticVersions[i].CompareTo(semanticVersions[i - 1]) <= 0);
}
}
/// <summary>
/// Shows the completion list automaticly after typing three chars
/// </summary>
private void SciControlCharAdded(ScintillaControl sci, Int32 value)
{
String language = sci.ConfigurationLanguage.ToLower();
if (this.IsSupported(language))
{
Language config = ScintillaControl.Configuration.GetLanguage(sci.ConfigurationLanguage);
String characters = config.characterclass.Characters;
// Do not autocomplete in word
Char c = (char)sci.CharAt(sci.CurrentPos);
if (characters.IndexOf(c) >= 0)
{
return;
}
// Autocomplete after typing word chars only
if (characters.IndexOf((char)value) < 0)
{
return;
}
String curWord = sci.GetWordLeft(sci.CurrentPos - 1, false);
if (curWord == null || curWord.Length < 3)
{
return;
}
List <ICompletionListItem> items = this.GetCompletionListItems(language, sci.FileName);
if (items != null && items.Count > 0)
{
items.Sort();
CompletionList.Show(items, true, curWord);
CompletionList.DisableAutoInsertion();
}
}
}
public async Task ShouldAddUsingOnCommit()
{
const string source = @"
public class Test {
public void Method() {
var list = new
}
}";
var document = GetTestDocument(source);
var listCompletion = (await GetCompletionsAsync(Provider, document, "var list = new "))
.First(c => Matches(c, "List<>", "System.Collections.Generic"));
listCompletion = CompletionList
.Create(new TextSpan(source.IndexOf("var list = new "), 0), ImmutableArray.Create(listCompletion))
.Items[0];
var changes = await Provider.GetChangeAsync(document, listCompletion, ' ', CancellationToken.None);
var textWithChanges = (await document.GetTextAsync()).WithChanges(changes.TextChange).ToString();
Assert.That(NormSpaces(textWithChanges), Is.EqualTo(NormSpaces(@"
using System.Collections.Generic;
public class Test {
public void Method() {
var list = new List
}
}")));
}
/// <summary>
/// 入力補完リスト表示
/// </summary>
/// <param name="itemList"></param>
private void showCompletion(List <ICompletionListItem> itemList)
{
if (itemList == null || itemList.Count == 0)
{
//表示項目がないので何もしない
return;
}
if (string.IsNullOrEmpty(m_compProvider.PreSelection))
{
//選択ワードがないとき
CompletionList.Show(itemList, true);
}
else if (this.CurrentSci.MBSafeTextLength(m_compProvider.PreSelection) != m_compProvider.PreSelection.Length)
{
//日本語単語選択時
this.CurrentSci.SelectWord();
CompletionList.Show(itemList, true);
}
else
{
//通常選択時
CompletionList.Show(itemList, true, m_compProvider.PreSelection);
}
}
public async Task Should_Resolve_Partial()
{
var(client, server) = await Initialize(
options => { }, options => {
options.OnCompletion(
(completionParams, observer) => {
var a = new CompletionList(
new CompletionItem {
Command = new Command {
Name = "execute-a",
Arguments = JArray.FromObject(new object[] { 1, "2", false })
},
}
);
observer.OnNext(a);
observer.OnCompleted();
},
completionItem => {
completionItem.Detail = "resolved";
return(Task.FromResult(completionItem));
},
new CompletionRegistrationOptions()
);
}
);
var item = await client.RequestCompletion(new CompletionParams()).SelectMany(z => z).Take(1).ToTask(CancellationToken);
item = await client.ResolveCompletion(item);
item.Detail.Should().Be("resolved");
}
protected override void OnTextInput(TextCompositionEventArgs e)
{
if (e == null)
{
throw new ArgumentNullException(nameof(e));
}
base.OnTextInput(e);
if (!e.Handled)
{
foreach (var c in e.Text)
{
switch (_itemList.ProcessInput(c))
{
case CompletionItemListKeyResult.BeforeStartKey:
ExpectInsertionBeforeStart = true;
break;
case CompletionItemListKeyResult.NormalKey:
break;
case CompletionItemListKeyResult.InsertionKey:
CompletionList.RequestInsertion(e);
return;
case CompletionItemListKeyResult.Cancel:
Close();
return;
}
}
}
}
public void LibmanCompletion_VersionCompletionInDescendingOrder()
{
_libmanConfig.Open();
Editor.Caret.MoveToExpression("\"libraries\"");
Editor.Caret.MoveDown(1);
Editor.KeyboardCommands.Type("{");
Editor.KeyboardCommands.Enter();
Editor.KeyboardCommands.Type("\"provider\":");
Editor.KeyboardCommands.Type("unpkg\","); // auto-format will put the space & quote after the colon
Editor.KeyboardCommands.Enter();
Editor.KeyboardCommands.Type("\"library\":");
Editor.KeyboardCommands.Type("jquery@");
CompletionList items = Helpers.Completion.WaitForCompletionItems(Editor, 5000);
Assert.IsNotNull(items, "Time out waiting for the version completion list");
var semanticVersions = new List <SemanticVersion>();
foreach (CompletionItem item in items)
{
semanticVersions.Add(SemanticVersion.Parse(item.Text));
}
for (int i = 1; i < semanticVersions.Count; ++i)
{
Assert.IsTrue(semanticVersions[i].CompareTo(semanticVersions[i - 1]) <= 0);
}
}
public void Convert_DataFalse_DoesNotTouchData()
{
// Arrange
var dataObject = new JObject()
{
["resultId"] = 123
};
var completionList = new CompletionList(
new CompletionItem()
{
Label = "Test",
Data = dataObject,
});
var capabilities = new VSCompletionListCapability()
{
Data = false,
};
// Act
var vsCompletionList = VSCompletionList.Convert(completionList, capabilities);
// Assert
Assert.Collection(vsCompletionList.Items, item => Assert.Same(dataObject, item.Data));
Assert.Null(vsCompletionList.Data);
}
public async Task <CompletionList> Completion(CompletionParams @params, CancellationToken cancellationToken)
{
var uri = @params.textDocument.uri;
_log?.Log(TraceEventType.Verbose, $"Completions in {uri} at {@params.position}");
var res = new CompletionList();
var analysis = await Document.GetAnalysisAsync(uri, Services, CompletionAnalysisTimeout, cancellationToken);
if (analysis != null)
{
var result = _completionSource.GetCompletions(analysis, @params.position);
res.items = result?.Completions?.ToArray() ?? Array.Empty <CompletionItem>();
await InvokeExtensionsAsync(async (ext, token)
=> {
switch (ext)
{
case ICompletionExtension2 e:
await e.HandleCompletionAsync(analysis, @params.position, res, cancellationToken);
break;
case ICompletionExtension e:
await e.HandleCompletionAsync(analysis, @params.position, res.items.OfType <CompletionItemEx>().ToArray(), cancellationToken);
break;
default:
// ext is not a completion extension, ignore it.
break;
}
}, cancellationToken);
}
return(res);
}
public CompletionList WaitForCompletionItems(IVisualStudioTextEditorTestExtension editor, int timeout = 1000)
{
CompletionList items = null;
WaitFor.TryIsTrue(() =>
{
try
{
IVisualStudioCompletionListTestExtension completionList = editor.Intellisense.GetActiveCompletionList();
// Make another call if completion list is not available or is still loading.
if (completionList == null || completionList.Items.Count == 1 && completionList.Items[0].Text.Equals(Vsix.Resources.Text.Loading))
{
return(false);
}
items = completionList.Items;
return(true);
}
catch (EditorException)
{
return(false);
}
}, TimeSpan.FromMilliseconds(timeout), TimeSpan.FromMilliseconds(500));
return(items);
}
public void Convert_DataTrue_RemovesDataFromItems()
{
// Arrange
var dataObject = new JObject()
{
["resultId"] = 123
};
var completionList = new CompletionList(
new CompletionItem()
{
Label = "Test",
Data = dataObject,
});
var capabilities = new VSCompletionListCapability()
{
Data = true,
};
// Act
var vsCompletionList = VSCompletionList.Convert(completionList, capabilities);
// Assert
Assert.Collection(vsCompletionList.Items, item => Assert.Null(item.Data));
Assert.Same(dataObject, vsCompletionList.Data);
}
public RCompletionSet(ITextBuffer textBuffer, ITrackingSpan trackingSpan, List <RCompletion> completions) :
base("R Completion", "R Completion", trackingSpan, Enumerable.Empty <RCompletion>(), Enumerable.Empty <RCompletion>())
{
_textBuffer = textBuffer;
_completions = OrderList(completions);
_filteredCompletions = new FilteredObservableCollection <Completion>(_completions);
}
public async Task <CompletionList> Handle(CompletionParams request, CancellationToken cancellationToken)
{
_router.Window.LogMessage(new LogMessageParams()
{
Type = MessageType.Log,
Message = "Proto file completion list request at line: " + (request.Position.Line + 1),
});
_threadManager.AssertBackgroundThread();
var document = await Task.Factory.StartNew(
() => {
_snapshotManager.TryResolveDocument(request.TextDocument.Uri.AbsolutePath, out var doc);
return(doc);
},
CancellationToken.None,
TaskCreationOptions.None,
_threadManager.ForegroundScheduler);
var syntaxTree = await document.GetSyntaxTreeAsync();
var completionItems = new List <CompletionItem>();
foreach (var completionItemProvider in _completionItemProviders)
{
var owner = syntaxTree.Root.GetNodeAt((int)request.Position.Line, (int)request.Position.Character);
var resolvedCompletions = completionItemProvider.GetCompletionItems(owner, request.Position, syntaxTree);
completionItems.AddRange(resolvedCompletions);
}
var completionList = new CompletionList(completionItems);
return(completionList);
}
private async Task UpdateCompletion()
{
int position = EditorControl.CaretOffset;
try
{
string fullSource = OwnerEditor.FullSource;
CompletionWindow.Document = Document.WithText(SourceText.From(fullSource));
CompletionList completion = await CompletionService.GetCompletionsAsync(CompletionWindow.Document, position + OwnerEditor.PreSource.Length + 1);
if (completion != null && completion.Items != null && completion.Items.Length > 0)
{
string filter = fullSource.Substring(completion.Span.Start, completion.Span.Length);
await CompletionWindow.SetCompletionList(completion);
await CompletionWindow.SetFilterText(filter);
if (CompletionWindow.VisibleItems > 0)
{
CompletionWindow.IsVisible = true;
}
}
else
{
CompletionWindow.IsVisible = false;
}
}
catch (Exception ex)
{
Debug.WriteLine("Error while updating completion: {0}", ex.Message);
}
}
static private bool HandleDocTagCompletion(ScintillaNet.ScintillaControl Sci)
{
string txt = Sci.GetLine(Sci.LineFromPosition(Sci.CurrentPos)).TrimStart();
if (!Regex.IsMatch(txt, "^\\*[\\s]*\\@"))
{
return(false);
}
DebugConsole.Trace("Documentation tag completion");
// build tag list
if (docVariables == null)
{
docVariables = new ArrayList();
TagItem item;
string[] tags = ASContext.DocumentationTags.Split(' ');
foreach (string tag in tags)
{
item = new TagItem(tag);
docVariables.Add(item);
}
}
// show
CompletionList.Show(docVariables, true, "");
return(true);
}
public async Task CanSendCompletionResolveWithModulePrefixRequestAsync()
{
await PsesLanguageClient
.SendRequest <EvaluateRequestArguments>(
"evaluate",
new EvaluateRequestArguments
{
Expression = "Import-Module Microsoft.PowerShell.Archive -Prefix Slow"
})
.ReturningVoid(CancellationToken.None).ConfigureAwait(false);
string filePath = NewTestFile("Expand-SlowArch");
CompletionList completionItems = await PsesLanguageClient.TextDocument.RequestCompletion(
new CompletionParams
{
TextDocument = new TextDocumentIdentifier
{
Uri = DocumentUri.FromFileSystemPath(filePath)
},
Position = new Position(line: 0, character: 15)
});
CompletionItem completionItem = Assert.Single(completionItems,
completionItem1 => completionItem1.Label == "Expand-SlowArchive");
CompletionItem updatedCompletionItem = await PsesLanguageClient
.SendRequest <CompletionItem>("completionItem/resolve", completionItem)
.Returning <CompletionItem>(CancellationToken.None).ConfigureAwait(false);
Assert.Contains("Extracts files from a specified archive", updatedCompletionItem.Documentation.String);
}
public CompletionEventArgs(ModuleAnalysis analysis, PythonAst tree, SourceLocation location, CompletionList initialCompletionList)
{
Analysis = analysis;
Tree = tree;
Location = location;
CompletionList = initialCompletionList;
}
static private bool HandleDocTagCompletion(ScintillaControl Sci)
{
if (ASContext.CommonSettings.JavadocTags == null || ASContext.CommonSettings.JavadocTags.Length == 0)
{
return(false);
}
string txt = Sci.GetLine(Sci.LineFromPosition(Sci.CurrentPos)).TrimStart();
if (!Regex.IsMatch(txt, "^\\*[\\s]*\\@"))
{
return(false);
}
// build tag list
if (docVariables == null)
{
docVariables = new List <ICompletionListItem>();
TagItem item;
foreach (string tag in ASContext.CommonSettings.JavadocTags)
{
item = new TagItem(tag);
docVariables.Add(item);
}
}
// show
CompletionList.Show(docVariables, true, "");
return(true);
}
public ScriptEditDialog(string text) : base("Script edit", "cde.ico", SizeToContent.Manual, ResizeMode.CanResize)
{
InitializeComponent();
Extensions.SetMinimalSize(this);
AvalonLoader.Load(_textEditor);
AvalonLoader.SetSyntax(_textEditor, "Script");
string script = ItemParser.Format(text, 0);
_textEditor.Text = script;
_textEditor.TextArea.TextEntered += new TextCompositionEventHandler(_textArea_TextEntered);
_textEditor.TextArea.TextEntering += new TextCompositionEventHandler(_textArea_TextEntering);
_completionWindow = new CompletionWindow(_textEditor.TextArea);
_li = _completionWindow.CompletionList;
ListView lv = _li.ListBox;
lv.SelectionMode = SelectionMode.Single;
//Image
Extensions.GenerateListViewTemplate(lv, new ListViewDataTemplateHelper.GeneralColumnInfo[] {
new ListViewDataTemplateHelper.ImageColumnInfo {
Header = "", DisplayExpression = "Image", TextAlignment = TextAlignment.Center, FixedWidth = 22, MaxHeight = 22, SearchGetAccessor = "Commands"
},
new ListViewDataTemplateHelper.GeneralColumnInfo {
Header = "Commands", DisplayExpression = "Text", TextAlignment = TextAlignment.Left, IsFill = true, ToolTipBinding = "Description"
}
}, null, new string[] { }, "generateHeader", "false");
_completionWindow.Content = null;
_completionWindow = null;
WindowStartupLocation = WindowStartupLocation.CenterOwner;
}
protected override void OnSourceInitialized(EventArgs e)
{
base.OnSourceInitialized(e);
if (_itemList.PreselectionLength > 0 && _itemList.SuggestedItem == null)
{
var preselection = TextArea.Document.GetText(StartOffset, EndOffset - StartOffset);
CompletionList.SelectItem(preselection);
}
}
public async Task GetCompletions_Should_Return_Expected()
{
// arrange
var code = "test code";
// roslyn provider
var roslyn = new Mock <IRoslynCompletionsProvider>();
var completionItems = Enumerable
.Range(1, 3)
.Select(i => CompletionItem.Create($"displayText {i}"))
.ToImmutableArray();
var completionList = CompletionList.Create(TextSpan.FromBounds(0, 10), completionItems);
roslyn
.Setup(r => r.GetCompletions(code, It.IsAny <IEnumerable <string> >()))
.ReturnsAsync(completionList);
// parser
var parser = new Mock <ICompletionsParser>();
var lastToken = "test-incomplete-text";
parser
.Setup(p => p.ParseLastToken(code))
.Returns(lastToken);
// filter
var filter = new Mock <ICompletionsFilter>();
var filtered = Enumerable
.Range(1, 3)
.Select(i => $"filtered item {i}");
filter
.Setup(f => f.Apply(It.IsAny <IEnumerable <string> >(), lastToken))
.Returns(filtered);
var builder = new Mock <IScriptOptionsBuilder>();
builder
.Setup(b => b.Build())
.Returns(ScriptOptions.Default.AddImports("test.import"));
var provider = new CompletionsProvider(roslyn.Object, parser.Object, filter.Object, builder.Object);
// act
var completions = (await provider.GetCompletions(code)).ToArray();
// assert
Assert.That(completions, Is.Not.Null);
roslyn.VerifyAll();
parser.VerifyAll();
filter.VerifyAll();
}
public override async Task <CompletionList> Completion(CompletionParams @params, CancellationToken cancellationToken)
{
var uri = @params.textDocument.uri;
ProjectFiles.GetEntry(@params.textDocument, @params._version, out var entry, out var tree);
TraceMessage($"Completions in {uri} at {@params.position}");
tree = GetParseTree(entry, uri, cancellationToken, out var version) ?? tree;
var analysis = entry != null ? await entry.GetAnalysisAsync(50, cancellationToken) : null;
if (analysis == null)
{
TraceMessage($"No analysis found for {uri}");
return(new CompletionList());
}
var opts = GetOptions(@params.context);
var ctxt = new CompletionAnalysis(analysis, tree, @params.position, opts, Settings.completion, _displayTextBuilder, Logger, () => entry.ReadDocument(ProjectFiles.GetPart(uri), out _));
var members = string.IsNullOrEmpty(@params._expr)
? ctxt.GetCompletions()
: ctxt.GetCompletionsFromString(@params._expr);
if (members == null)
{
TraceMessage($"No completions at {@params.position} in {uri}");
return(new CompletionList());
}
if (!Settings.completion.showAdvancedMembers)
{
members = members.Where(m => !m.label.StartsWith("__"));
}
var filterKind = @params.context?._filterKind;
if (filterKind.HasValue && filterKind != CompletionItemKind.None)
{
TraceMessage($"Only returning {filterKind.Value} items");
members = members.Where(m => m.kind == filterKind.Value);
}
var res = new CompletionList {
items = members.ToArray(),
_expr = ctxt.ParentExpression?.ToCodeString(tree, CodeFormattingOptions.Traditional),
_commitByDefault = ctxt.ShouldCommitByDefault,
_allowSnippet = ctxt.ShouldAllowSnippets
};
res._applicableSpan = GetApplicableSpan(ctxt, @params, tree);
LogMessage(MessageType.Info, $"Found {res.items.Length} completions for {uri} at {@params.position} after filtering");
await InvokeExtensionsAsync((ext, token)
=> (ext as ICompletionExtension)?.HandleCompletionAsync(uri, analysis, tree, @params.position, res, cancellationToken), cancellationToken);
return(res);
}
private static byte[] GenerateBuffer(CompletionList completionList)
{
using var stream = new MemoryStream();
using var writer = new StreamWriter(stream, Encoding.UTF8, bufferSize: 4096);
Serializer.Instance.JsonSerializer.Serialize(writer, completionList);
var buffer = stream.GetBuffer();
return(buffer);
}
public static void ShouldContainLabel(this CompletionList list, params string[] expectedSuggestions)
{
foreach (var suggestion in expectedSuggestions)
{
if (!list.Any(x => x.Label.Equals(suggestion, StringComparison.OrdinalIgnoreCase)))
{
Assert.Fail($"CompletionList doesn't contain expected completion labeled '{suggestion}'");
}
}
}
protected void GetCompletions(string file, int line, int column)
{
Client.TextDocument.DidOpen(file, "dfy");
completions = Client.TextDocument.Completions(
filePath: file,
line: line - 1,
column: column - 1,
cancellationToken: CancellationSource.Token
).Result;
}
public static void ShouldNotContainLabel(this CompletionList list, params string[] expectedSuggestions)
{
foreach (var suggestion in expectedSuggestions)
{
if (list.Any(x => x.Label.Equals(suggestion, StringComparison.OrdinalIgnoreCase)))
{
Assert.Fail($"CompletionList contains completion labeled '{suggestion}' that should not be int the list.");
}
}
}
public RCompletionSet(ITextBuffer textBuffer, ITrackingSpan trackingSpan, List<RCompletion> completions) :
base("R Completion", "R Completion", trackingSpan, Enumerable.Empty<RCompletion>(), Enumerable.Empty<RCompletion>()) {
_textBuffer = textBuffer;
_completions = OrderList(completions);
_filteredCompletions = new FilteredObservableCollection<Completion>(_completions);
}
