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 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);
}
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 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);
}
/// <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);
}
