public bool AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures, AstRoot ast, Action <object> triggerSession) { ITextSnapshot snapshot = _textBuffer.CurrentSnapshot; int position = session.GetTriggerPoint(_textBuffer).GetPosition(snapshot); // Retrieve parameter positions from the current text buffer snapshot ParameterInfo parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(ast, snapshot, position); if (parametersInfo != null) { position = Math.Min(parametersInfo.SignatureEnd, position); int start = Math.Min(position, snapshot.Length); int end = Math.Min(parametersInfo.SignatureEnd, snapshot.Length); ITrackingSpan applicableToSpan = snapshot.CreateTrackingSpan(Span.FromBounds(start, end), SpanTrackingMode.EdgeInclusive); // Get collection of function signatures from documentation (parsed RD file) IFunctionInfo functionInfo = FunctionIndex.GetFunctionInfo(parametersInfo.FunctionName, triggerSession, session.TextView); if (functionInfo != null && functionInfo.Signatures != null) { foreach (ISignatureInfo signatureInfo in functionInfo.Signatures) { ISignature signature = CreateSignature(session, functionInfo, signatureInfo, applicableToSpan, ast, position); signatures.Add(signature); } session.Properties["functionInfo"] = functionInfo; return(true); } } return(false); }
public async Task ParameterTest_ComputeCurrentParameter02() { await FunctionIndex.GetPackageNameAsync("legend"); _settings.PartialArgumentNameMatch.Returns(true); var textBuffer = new TextBufferMock("legend(bty=1, lt=3)", RContentTypeDefinition.ContentType); var eb = textBuffer.ToEditorBuffer(); var source = new RSignatureHelpSource(textBuffer, Services); var session = new SignatureHelpSessionMock(Services, textBuffer, 0); var textView = session.TextView as TextViewMock; var signatures = new List <ISignature>(); using (var tree = new EditorTree(eb, Services)) { tree.Build(); using (var document = new EditorDocumentMock(tree)) { session.TrackingPoint = new TrackingPointMock(textBuffer, 7, PointTrackingMode.Positive, TrackingFidelityMode.Forward); tree.TakeThreadOwnerShip(); await source.AugmentSignatureHelpSessionAsync(session, signatures, tree.AstRoot); signatures.Should().ContainSingle(); textView.Caret = new TextCaretMock(textView, 8); var sh = ((RSignatureHelp)signatures[0]).FunctionSignatureHelp; var index = sh.SignatureInfo.ComputeCurrentParameter(tree.BufferSnapshot, tree.AstRoot, 8, _settings); index.Should().Be(11); textView.Caret = new TextCaretMock(textView, 15); index = sh.SignatureInfo.ComputeCurrentParameter(tree.BufferSnapshot, tree.AstRoot, 15, _settings); index.Should().Be(6); } } }
public void RSignature() { using (var script = new TestScript("```{r}\r\n\r\n```", MdContentTypeDefinition.ContentType)) { FunctionRdDataProvider.HostStartTimeout = 10000; using (new RHostScript(EditorShell.Current.ExportProvider.GetExportedValue <IRSessionProvider>())) { FunctionIndex.Initialize(); FunctionIndex.BuildIndexAsync().Wait(); FunctionIndexUtility.GetFunctionInfoAsync("lm").Wait(3000); script.MoveDown(); script.Type("x <- lm("); script.DoIdle(2000); ISignatureHelpSession session = script.GetSignatureSession(); session.Should().NotBeNull(); IParameter parameter = session.SelectedSignature.CurrentParameter; parameter.Should().NotBeNull(); parameter.Name.Should().Be("formula"); script.Type("sub"); script.DoIdle(500); script.Type("{TAB}"); script.DoIdle(1000); parameter = session.SelectedSignature.CurrentParameter; parameter.Name.Should().Be("subset"); string actual = script.EditorText; actual.Should().Be("```{r}\r\nx <- lm(subset = )\r\n```"); session = script.GetSignatureSession(); parameter = session.SelectedSignature.CurrentParameter; } } }
public async Task InitializeAsync() { await Workflow.RSessions.TrySwitchBrokerAsync(GetType().Name); await PackageIndex.BuildIndexAsync(); await FunctionIndex.BuildIndexAsync(); }
public IReadOnlyCollection <RCompletion> GetEntries(RCompletionContext context) { List <RCompletion> completions = new List <RCompletion>(); ImageSource functionGlyph = GlyphService.GetGlyph(StandardGlyphGroup.GlyphGroupValueType, StandardGlyphItem.GlyphItemPublic); // Safety checks FunctionCall funcCall = context.AstRoot.GetNodeOfTypeFromPosition <FunctionCall>(context.Position); if (funcCall == null || funcCall.OpenBrace == null || funcCall.Arguments == null) { return(completions); } if (context.Position < funcCall.OpenBrace.End || context.Position >= funcCall.SignatureEnd) { return(completions); } // Retrieve parameter positions from the current text buffer snapshot ParameterInfo parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(context.AstRoot, context.TextBuffer.CurrentSnapshot, context.Position); if (parametersInfo == null) { return(completions); } // Get collection of function signatures from documentation (parsed RD file) IFunctionInfo functionInfo = FunctionIndex.GetFunctionInfo(parametersInfo.FunctionName, o => { }, context.Session.TextView); if (functionInfo == null) { return(completions); } // Collect parameter names from all signatures IEnumerable <KeyValuePair <string, IArgumentInfo> > arguments = new Dictionary <string, IArgumentInfo>(); foreach (ISignatureInfo signature in functionInfo.Signatures) { var args = signature.Arguments.ToDictionary(x => x.Name); arguments = arguments.Union(args); } // Add names of arguments that are not yet specified to the completion // list with '=' sign so user can tell them from function names. IEnumerable <string> declaredArguments = funcCall.Arguments.Where(x => x is NamedArgument).Select(x => ((NamedArgument)x).Name); IEnumerable <KeyValuePair <string, IArgumentInfo> > possibleArguments = arguments.Where(x => x.Key != "..." && !declaredArguments.Contains(x.Key)); foreach (KeyValuePair <string, IArgumentInfo> arg in possibleArguments) { string displayText = arg.Key + " ="; string insertionText = arg.Key + " = "; completions.Add(new RCompletion(displayText, insertionText, arg.Value.Description, functionGlyph)); } return(completions); }
public static async Task DisposeAsync() { IRSessionProvider sessionProvider = EditorShell.Current.ExportProvider.GetExportedValue <IRSessionProvider>(); if (sessionProvider != null) { await Task.WhenAll(sessionProvider.GetSessions().Select(s => s.StopHostAsync())); } FunctionIndex.Terminate(); }
public async Task BuildPackageIndexTest() { string[] packageNames = { "base", "boot", "class", "cluster", "codetools", "compiler", "datasets", "foreign", "graphics", "grDevices", "grid", "KernSmooth", "lattice", "MASS", "Matrix", "methods", "mgcv", "nlme", "nnet", "parallel", "rpart", "spatial", "splines", "stats", "stats4", "survival", "tcltk", "tools", "translations", "utils", }; IPackageIndex packageIndex; using (var host = new IntelliSenseRSession(_coreShell, _workflowProvider)) { await host.StartSessionAsync(); var functionIndex = new FunctionIndex(_coreShell, null, host); packageIndex = new PackageIndex(_workflowProvider, _coreShell, host, functionIndex); await packageIndex.BuildIndexAsync(); } foreach (var name in packageNames) { IPackageInfo pi = await packageIndex.GetPackageInfoAsync(name); pi.Should().NotBeNull(); pi.Name.Should().Be(name); } }
internal bool AugmentQuickInfoSession(AstRoot ast, int position, IQuickInfoSession session, IList <object> quickInfoContent, out ITrackingSpan applicableToSpan, Action <object> retriggerAction) { int signatureEnd = position; applicableToSpan = null; string functionName = SignatureHelp.GetFunctionNameFromBuffer(ast, ref position, out signatureEnd); if (!string.IsNullOrEmpty(functionName)) { ITextSnapshot snapshot = session.TextView.TextBuffer.CurrentSnapshot; position = Math.Min(signatureEnd, position); int start = Math.Min(position, snapshot.Length); int end = Math.Min(signatureEnd, snapshot.Length); applicableToSpan = snapshot.CreateTrackingSpan(Span.FromBounds(start, end), SpanTrackingMode.EdgeInclusive); IFunctionInfo functionInfo = FunctionIndex.GetFunctionInfo(functionName, retriggerAction, session); if (functionInfo != null && functionInfo.Signatures != null) { foreach (ISignatureInfo sig in functionInfo.Signatures) { string signatureString = sig.GetSignatureString(); int wrapLength = Math.Min(SignatureInfo.MaxSignatureLength, signatureString.Length); string text; if (string.IsNullOrWhiteSpace(functionInfo.Description)) { text = string.Empty; } else { /// VS may end showing very long tooltip so we need to keep /// description reasonably short: typically about /// same length as the function signature. text = signatureString + "\r\n" + functionInfo.Description.Wrap(wrapLength); } if (text.Length > 0) { quickInfoContent.Add(text); return(true); } } } } return(false); }
public async Task PackageDescriptionTest() { PackageIndex packageIndex; using (var host = new IntelliSenseRSession(_coreShell, _workflowProvider)) { await host.StartSessionAsync(); var functionIndex = new FunctionIndex(_coreShell, null, host); packageIndex = new PackageIndex(_workflowProvider, _coreShell, host, functionIndex); await packageIndex.BuildIndexAsync(); } IPackageInfo pi = await packageIndex.GetPackageInfoAsync("base"); pi.Description.Should().Be("Base R functions."); }
private static IPackageInfo TryFindPackageNew(string packageName) { foreach (Lazy <IPackageCollection> collection in _collections) { IPackageInfo package = collection.Value.Packages.FirstOrDefault((p) => p.Name.EqualsIgnoreCase(packageName)); if (package != null) { _packages[package.Name.ToLowerInvariant()] = package; FunctionIndex.BuildIndexForPackage(package); return(package); } } return(null); }
public async Task PackageDescriptionTest() { RToolsSettings.Current = new TestRToolsSettings(); PackageIndex packageIndex; using (var host = new IntelliSenseRSession(_shell, _sessionProvider, _workflowProvider)) { await host.CreateSessionAsync(); var functionIndex = new FunctionIndex(_shell, null, host); packageIndex = new PackageIndex(_shell, host, functionIndex); await packageIndex.BuildIndexAsync(); } IPackageInfo pi = await packageIndex.GetPackageInfoAsync("base"); pi.Description.Should().Be("Base R functions."); }
public async Task InternalExternal(string content, int position, string expectedEntry, string notExpectedEntry) { var packageName = await FunctionIndex.GetPackageNameAsync(expectedEntry); packageName.Should().NotBeNull(); var completionSets = new List <CompletionSet>(); RCompletionTestUtilities.GetCompletions(Services, content, position, completionSets); completionSets.Should().ContainSingle(); var entries = completionSets[0].Completions.Select(c => c.DisplayText).ToList(); entries.Should().Contain(expectedEntry); entries.Should().NotContain(notExpectedEntry); }
public static Task <IFunctionInfo> GetFunctionInfoAsync(string functionName) { FunctionRdDataProvider.HostStartTimeout = 10000; var tcs = new TaskCompletionSource <IFunctionInfo>(); var result = FunctionIndex.GetFunctionInfo(functionName, o => { var r = FunctionIndex.GetFunctionInfo(functionName); tcs.TrySetResult(r); }); if (result != null) { tcs.TrySetResult(result); } return(tcs.Task); }
private void InterpretWordImp() { while (input.Length > 0) { functionIndex = FunctionIndex.GetArray(input); HandleConstants(); HandleParameters(); // jesli wszystko zadzaialalo to w tym momencie funkcja powinna zaczyac sie na indexie 0 if (functionIndex != null) { AddNecessaryMultiplications(); interpretedWord.Add(new Function(functionIndex[0].functionType, additionalPriority)); lastAddedElement = ElementType.Function; input = input.Remove(0, Function.FunctionTypeToString((FunctionType)functionIndex[0].functionType).Length); } } }
/// <summary> /// Extracts information on the current function in the completion context, if any. /// </summary> /// <returns></returns> private static IFunctionInfo GetFunctionInfo(RCompletionContext context) { // Retrieve parameter positions from the current text buffer snapshot IFunctionInfo functionInfo = null; ParameterInfo parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(context.AstRoot, context.TextBuffer.CurrentSnapshot, context.Position); if (parametersInfo != null) { // User-declared functions take priority functionInfo = context.AstRoot.GetUserFunctionInfo(parametersInfo.FunctionName, context.Position); if (functionInfo == null) { // Get collection of function signatures from documentation (parsed RD file) functionInfo = FunctionIndex.GetFunctionInfo(parametersInfo.FunctionName, o => { }, context.Session.TextView); } } return(functionInfo); }
public async Task ParameterTest_ComputeCurrentParameter01() { var textBuffer = new TextBufferMock("aov(", RContentTypeDefinition.ContentType); var editorBuffer = textBuffer.ToEditorBuffer(); var source = new RSignatureHelpSource(textBuffer, Services); var session = new SignatureHelpSessionMock(Services, textBuffer, 0); var textView = session.TextView as TextViewMock; var signatures = new List <ISignature>(); using (var tree = new EditorTree(editorBuffer, Services)) { tree.Build(); using (var document = new EditorDocumentMock(tree)) { session.TrackingPoint = new TrackingPointMock(textBuffer, 4, PointTrackingMode.Positive, TrackingFidelityMode.Forward); await FunctionIndex.GetPackageNameAsync("aov"); tree.TakeThreadOwnerShip(); await source.AugmentSignatureHelpSessionAsync(session, signatures, tree.AstRoot); signatures.Should().ContainSingle(); var index = GetCurrentParameterIndex(signatures[0], signatures[0].CurrentParameter); index.Should().Be(0); textView.Caret = new TextCaretMock(textView, 5); TextBufferUtility.ApplyTextChange(textBuffer, 4, 0, 1, "a"); index = GetCurrentParameterIndex(signatures[0], signatures[0].CurrentParameter); index.Should().Be(0); textView.Caret = new TextCaretMock(textView, 6); TextBufferUtility.ApplyTextChange(textBuffer, 5, 0, 1, ","); tree.EnsureTreeReady(); index = GetCurrentParameterIndex(signatures[0], signatures[0].CurrentParameter); index.Should().Be(1); textView.Caret = new TextCaretMock(textView, 7); TextBufferUtility.ApplyTextChange(textBuffer, 6, 0, 1, ","); tree.EnsureTreeReady(); index = GetCurrentParameterIndex(signatures[0], signatures[0].CurrentParameter); index.Should().Be(2); } } }
public async Task SpecificPackage(string content, int position, string expectedEntry, string expectedDescription, bool realHost) { var hostScript = realHost ? new RHostScript(Workflow.RSessions) : null; try { var info = await FunctionIndex.GetFunctionInfoAsync(expectedEntry); info.Should().NotBeNull(); var completionSets = new List <CompletionSet>(); RCompletionTestUtilities.GetCompletions(EditorShell, content, position, completionSets); completionSets.Should().ContainSingle(); var entry = completionSets[0].Completions.FirstOrDefault(c => c.DisplayText == expectedEntry); entry.Should().NotBeNull(); var description = entry.Description; description.Should().Contain(expectedDescription); } finally { hostScript?.Dispose(); } }
protected override void Initialize() { Current = this; // Force app shell creation before everything else var shell = VsAppShell.Current; if (IsCommandLineMode()) { return; } VsWpfOverrides.Apply(); CranMirrorList.Download(); RtvsTelemetry.Initialize(); using (var p = Current.GetDialogPage(typeof(RToolsOptionsPage)) as RToolsOptionsPage) { p.LoadSettings(); } MicrosoftRClient.CheckInstall(VsAppShell.Current); base.Initialize(); ProjectIconProvider.LoadProjectImages(); LogCleanup.DeleteLogsAsync(DiagnosticLogs.DaysToRetain); _indexBuildingTask = FunctionIndex.BuildIndexAsync(); AdviseExportedWindowFrameEvents <ActiveWpfTextViewTracker>(); AdviseExportedWindowFrameEvents <VsActiveRInteractiveWindowTracker>(); AdviseExportedDebuggerEvents <VsDebuggerModeTracker>(); System.Threading.Tasks.Task.Run(() => RtvsTelemetry.Current.ReportConfiguration()); IdleTimeAction.Create(ExpansionsCache.Load, 200, typeof(ExpansionsCache)); }
public override int GetHashCode() { return((BlockId.GetHashCode()) ^ (ClassScope.GetHashCode()) ^ (FunctionIndex.GetHashCode())); }
private void PrepareFunctionIndex() { FunctionIndex.Initialize(); FunctionIndex.BuildIndexAsync().Wait(); }
public static Task InitializeAsync() { RToolsSettings.Current = new TestRToolsSettings(); FunctionIndex.Initialize(); return(FunctionIndex.BuildIndexAsync()); }
public static void Initialize() { FunctionIndex.Initialize(); }
public object ExecuteCommand(object input, FunctionIndex index) { ICommonFunc func = FuncTable[(int)index]; return(func.ExecuteCommand(input)); }