/// <summary>
/// This method will format the label of the SignatureInformation with procedure's name and all the expected arguments
/// </summary>
/// <param name="procedure">The selected procedure</param>
/// <returns></returns>
public static SignatureInformation SignatureHelperSignatureFormatter(FunctionDeclaration procedure)
{
var parametersInfo = new ParameterInformation[procedure.Profile.Parameters.Count];
int i = 0; bool firstPass = true;
foreach (var parameter in procedure.Profile.InputParameters)
{
var label = string.Format("{0}{1}({2})", firstPass ? "INPUT " : null, parameter.DataName, parameter.DataType.Name);
parametersInfo[i] = new ParameterInformation(label, null); //Replace null with commented documentation linked to parameter
i++; firstPass = false;
}
firstPass = true;
foreach (var parameter in procedure.Profile.InoutParameters)
{
var label = string.Format("{0}{1}({2})", firstPass ? "IN-OUT " : null, parameter.DataName, parameter.DataType.Name);
parametersInfo[i] = new ParameterInformation(label, null);
i++; firstPass = false;
}
firstPass = true;
foreach (var parameter in procedure.Profile.OutputParameters)
{
var label = string.Format("{0}{1}({2})", firstPass ? "OUTPUT " : null, parameter.DataName, parameter.DataType.Name);
parametersInfo[i] = new ParameterInformation(label, null);
i++; firstPass = false;
}
return(new SignatureInformation(procedure.Name, null, parametersInfo)); //Replace null with commented documentation linked to procedure declaration
}
public SignatureHelp OnTextDocumentSignaureHelp(JToken arg)
{
Log("textDocument/signatureHelp", arg);
var signatures = new List <SignatureInformation>();
for (int i = 0; i < 2; ++i)
{
var signature = new SignatureInformation
{
Documentation = "Signature documentation " + i,
Label = "Signature " + i
};
var parameters = new List <ParameterInformation>();
for (int j = 0; j < 3; ++j)
{
var parameter = new ParameterInformation
{
Documentation = "Parameter documentation " + i,
Label = "Parameter " + i
};
}
signature.Parameters = parameters.ToArray();
signatures.Add(signature);
}
return(new SignatureHelp
{
Signatures = signatures.ToArray()
});
}
public void SimpleTest(string expected)
{
var model = new ParameterInformation {
Documentation = "docs",
Label = "label"
};
var result = Fixture.SerializeObject(model);
result.Should().Be(expected);
var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject <ParameterInformation>(expected);
deresult.Should().BeEquivalentTo(model);
}
public async Task <SignatureHelp> Handle(SignatureHelpParams request, CancellationToken cancellationToken)
{
ScriptFile scriptFile =
_workspaceService.GetFile(
request.TextDocument.Uri.ToString());
ParameterSetSignatures parameterSets =
await _symbolsService.FindParameterSetsInFileAsync(
scriptFile,
(int)request.Position.Line + 1,
(int)request.Position.Character + 1,
_powerShellContextService);
SignatureInformation[] signatures = s_emptySignatureResult;
if (parameterSets != null)
{
signatures = new SignatureInformation[parameterSets.Signatures.Length];
for (int i = 0; i < signatures.Length; i++)
{
var parameters = new ParameterInformation[parameterSets.Signatures[i].Parameters.Count()];
int j = 0;
foreach (ParameterInfo param in parameterSets.Signatures[i].Parameters)
{
parameters[j] = CreateParameterInfo(param);
j++;
}
signatures[i] = new SignatureInformation
{
Label = parameterSets.CommandName + " " + parameterSets.Signatures[i].SignatureText,
Documentation = null,
Parameters = parameters,
};
}
}
return(new SignatureHelp
{
Signatures = signatures,
ActiveParameter = null,
ActiveSignature = 0
});
}
public SignatureHelp OnTextDocumentSignaureHelp(JToken arg)
{
Log(Methods.TextDocumentSignatureHelpName, arg);
var signatures = new List <SignatureInformation>();
for (int i = 0; i < 2; ++i)
{
var signature = new SignatureInformation
{
Documentation = CreateMarkupContent("Signature documentation " + i),
Label = "Signature " + i,
};
var parameters = new List <ParameterInformation>();
for (int j = 0; j < 3; ++j)
{
var parameter = new ParameterInformation
{
Documentation = CreateMarkupContent("Parameter documentation " + i),
Label = "Parameter " + i
};
parameters.Add(parameter);
}
signature.Parameters = parameters.ToArray();
signatures.Add(signature);
}
return(new SignatureHelp
{
Signatures = signatures.ToArray()
});
}
public override ParameterInformation CustomizeParameterInformation(ParameterInformation p)
{
p.TargetDatabaseType = ConvertGenericTypeToCustomType(p.Type);
return p;
}
public IEnumerable <TypeInformation> GetTypeInformation(byte[] rawAssembly)
{
if (rawAssembly == null || rawAssembly.Length == 0)
{
return(Enumerable.Empty <TypeInformation>());
}
List <TypeInformation> results = new List <TypeInformation>();
Assembly assembly = Assembly.Load(rawAssembly);
foreach (TypeInfo typeInfo in assembly.DefinedTypes)
{
if (typeInfo != null)
{
if (typeInfo.IsNotPublic)
{
continue;
}
TypeInformation typeInformationModel = new TypeInformation()
{
Name = typeInfo.Name,
Description = GetAttributeProperty(typeInfo.CustomAttributes, "Description", "Description"),
Type = ConvertTypeName(typeInfo.FullName),
};
List <string> filteredMethodNames = new List <string>()
{
"MainCalc",
"ToString",
"GetHashCode",
"Equals",
"GetType"
};
List <MethodInformation> methods = new List <MethodInformation>();
foreach (MethodInfo methodInfo in typeInfo.GetMethods())
{
if (IsAggregateFunction(methodInfo.Name))
{
methods.Add(ConfigureAggregateFunctionMetadata(methodInfo));
}
else if (filteredMethodNames.Any(f => string.Equals(methodInfo.Name, f, StringComparison.InvariantCultureIgnoreCase)))
{
continue;
}
else
{
if (!methodInfo.IsSpecialName)
{
List <ParameterInformation> parameters = new List <ParameterInformation>();
foreach (ParameterInfo parameter in methodInfo.GetParameters())
{
ParameterInformation parameterInformation = new ParameterInformation()
{
Name = parameter.Name,
Description = parameter.Name,
Type = ConvertTypeName(parameter.ParameterType),
};
parameters.Add(parameterInformation);
}
string entityId = null;
bool isCustom = false;
var calculationAttribute = methodInfo.CustomAttributes.Where(c => c.AttributeType.Name == "CalculationAttribute").FirstOrDefault();
if (calculationAttribute != null)
{
entityId = calculationAttribute.NamedArguments.Where(a => a.MemberName == "Id").FirstOrDefault().TypedValue.Value?.ToString();
isCustom = true;
}
MethodInformation methodInformation = new MethodInformation()
{
Name = methodInfo.Name,
ReturnType = ConvertTypeName(methodInfo.ReturnType),
Parameters = parameters,
EntityId = entityId,
IsCustom = isCustom
};
if (string.IsNullOrWhiteSpace(methodInformation.FriendlyName))
{
methodInformation.FriendlyName = GetAttributeProperty(methodInfo.CustomAttributes, "Calculation", "Name");
}
if (string.IsNullOrWhiteSpace(methodInformation.Description))
{
methodInformation.Description = GetAttributeProperty(methodInfo.CustomAttributes, "Description", "Description");
}
methods.Add(methodInformation);
}
}
}
List <MethodInformation> fields = new List <MethodInformation>();
FieldInfo[] fieldInfos = typeInfo.DeclaredFields.ToArray();
foreach (FieldInfo fieldInfo in fieldInfos.Where(m => m.FieldType == typeof(Func <decimal?>)).ToList())
{
if (!fieldInfo.IsSpecialName)
{
string entityId = null;
bool isCustom = false;
var calculationAttribute = fieldInfo.CustomAttributes.Where(c => c.AttributeType.Name == "CalculationAttribute").FirstOrDefault();
if (calculationAttribute != null)
{
entityId = calculationAttribute.NamedArguments.Where(a => a.MemberName == "Id").FirstOrDefault().TypedValue.Value?.ToString();
isCustom = true;
}
MethodInformation methodInformation = new MethodInformation()
{
Name = fieldInfo.Name,
ReturnType = ConvertTypeName(fieldInfo.ReflectedType),
EntityId = entityId,
IsCustom = isCustom
};
if (string.IsNullOrWhiteSpace(methodInformation.FriendlyName))
{
methodInformation.FriendlyName = GetAttributeProperty(fieldInfo.CustomAttributes, "Calculation", "Name");
}
if (string.IsNullOrWhiteSpace(methodInformation.Description))
{
methodInformation.Description = GetAttributeProperty(fieldInfo.CustomAttributes, "Description", "Description");
}
methods.Add(methodInformation);
}
}
List <PropertyInformation> properties = new List <PropertyInformation>();
foreach (PropertyInfo property in typeInfo.GetProperties())
{
if (!property.IsSpecialName && property.MemberType == MemberTypes.Property)
{
PropertyInformation propertyInformation = new PropertyInformation()
{
Name = property.Name,
Type = ConvertTypeName(property.PropertyType),
};
if (string.IsNullOrWhiteSpace(propertyInformation.FriendlyName))
{
propertyInformation.FriendlyName = GetAttributeProperty(property.CustomAttributes, "DatasetRelationship", "Name");
}
if (string.IsNullOrWhiteSpace(propertyInformation.FriendlyName))
{
propertyInformation.FriendlyName = GetAttributeProperty(property.CustomAttributes, "Field", "Name");
}
if (string.IsNullOrWhiteSpace(propertyInformation.FriendlyName))
{
propertyInformation.FriendlyName = GetAttributeProperty(property.CustomAttributes, "Calculation", "Name");
}
if (string.IsNullOrWhiteSpace(propertyInformation.Description))
{
propertyInformation.Description = GetAttributeProperty(property.CustomAttributes, "Description", "Description");
}
if (string.IsNullOrWhiteSpace(propertyInformation.IsAggregable))
{
propertyInformation.IsAggregable = GetAttributeProperty(property.CustomAttributes, "IsAggregable", "IsAggregable");
}
properties.Add(propertyInformation);
}
}
typeInformationModel.Methods = methods;
typeInformationModel.Properties = properties;
results.Add(typeInformationModel);
}
}
IEnumerable <TypeInformation> dataTypes = GetDefaultTypes();
foreach (TypeInformation typeInformation in dataTypes)
{
results.Add(typeInformation);
}
IEnumerable <TypeInformation> keywords = GetKeywords();
foreach (TypeInformation typeInformation in keywords)
{
results.Add(typeInformation);
}
return(results);
}
public override Task <SignatureHelp> Handle(SignatureHelpParams request, CancellationToken cancellationToken)
{
var currentHash = Hash.StringHash(request.TextDocument.Uri.GetFileSystemPath());
var pos = request.Position;
TreeSitter.GetSignature(currentHash, pos.Line, pos.Character, out var signatureArrayPtr, out var parameterCount, out var activeParameter, out var errorCount, out var errorRanges);
if (signatureArrayPtr.ToInt64() == 0)
{
return(Task.FromResult(new SignatureHelp()));
}
var signaturePtr = System.Runtime.InteropServices.Marshal.ReadIntPtr(signatureArrayPtr);
var signature = System.Runtime.InteropServices.Marshal.PtrToStringAnsi(signaturePtr);
SignatureInformation info = new SignatureInformation();
info.Label = signature;
var paramList = new List <ParameterInformation>();
if (parameterCount > 0)
{
for (int i = 0; i < parameterCount; i++)
{
var paramInfo = new ParameterInformation();
var paramPtr = System.Runtime.InteropServices.Marshal.ReadIntPtr(signatureArrayPtr + 8 * (i + 1));;
paramInfo.Label = System.Runtime.InteropServices.Marshal.PtrToStringAnsi(paramPtr);
paramList.Add(paramInfo);
}
}
info.Parameters = new Container <ParameterInformation>(paramList);
SignatureHelp help = new SignatureHelp();
help.Signatures = new Container <SignatureInformation>(info);
help.ActiveParameter = activeParameter;
help.ActiveSignature = 0;
if (errorCount > 0)
{
List <Diagnostic> diagnostics = new List <Diagnostic>();
PublishDiagnosticsParams diagnosticsParams = new PublishDiagnosticsParams();
diagnosticsParams.Uri = request.TextDocument.Uri;
unsafe
{
for (int i = 0; i < errorCount; i++)
{
Range * errors = (Range *)errorRanges;
var error = errors[i];
Diagnostic diagnostic = new Diagnostic();
diagnostic.Message = "Extra argument";
diagnostic.Range = new OmniSharp.Extensions.LanguageServer.Protocol.Models.Range(
new Position(error.startLine, error.startCol),
new Position(error.endLine, error.endCol));
diagnostics.Add(diagnostic);
}
}
diagnoser.Add(request.TextDocument.Uri, 1, diagnostics);
}
else
{
diagnoser.Add(request.TextDocument.Uri, 1, new List <Diagnostic>());
}
return(Task.FromResult(help));
}
public SignatureHelp GetSignature(IDocumentAnalysis analysis, SourceLocation location)
{
if (analysis is EmptyAnalysis)
{
return(null);
}
ExpressionLocator.FindExpression(analysis.Ast, location,
FindExpressionOptions.Hover, out var node, out var statement, out var scope);
IMember value = null;
IPythonType selfType = null;
string name = null;
var call = node as CallExpression;
if (call != null)
{
using (analysis.ExpressionEvaluator.OpenScope(analysis.Document, scope)) {
switch (call.Target)
{
case MemberExpression mex:
var v = analysis.ExpressionEvaluator.GetValueFromExpression(mex.Target);
selfType = v?.GetPythonType();
name = mex.Name;
break;
case NameExpression ne:
name = ne.Name;
break;
}
value = analysis.ExpressionEvaluator.GetValueFromExpression(call.Target);
}
}
var ft = value.TryGetFunctionType();
if (ft == null)
{
return(null);
}
var signatures = new SignatureInformation[ft.Overloads.Count];
for (var i = 0; i < ft.Overloads.Count; i++)
{
var o = ft.Overloads[i];
var signatureLabel = _docSource.GetSignatureString(ft, selfType, out var parameterSpans, i, name);
var parameterInfo = new ParameterInformation[parameterSpans.Length];
for (var j = 0; j < parameterSpans.Length; j++)
{
var(ps, p) = parameterSpans[j];
parameterInfo[j] = new ParameterInformation {
label = _labelOffsetSupport ? new[] { ps.Start, ps.End } : (object)p.Name,
documentation = _docSource.FormatParameterDocumentation(p)
};
}
signatures[i] = new SignatureInformation {
label = signatureLabel,
documentation = _docSource.FormatDocumentation(ft.Documentation),
parameters = parameterInfo
};
}
var index = location.ToIndex(analysis.Ast);
if (call.GetArgumentAtIndex(analysis.Ast, index, out var activeParameter) && activeParameter < 0)
{
// Returned 'true' and activeParameter == -1 means that we are after
// the trailing comma, so assume partially typed expression such as 'pow(x, y, |)
activeParameter = call.Args.Count;
}
var activeSignature = -1;
if (activeParameter >= 0)
{
// TODO: Better selection of active signature by argument set
activeSignature = signatures
.Select((s, i) => Tuple.Create(s, i))
.OrderBy(t => t.Item1.parameters.Length)
.FirstOrDefault(t => t.Item1.parameters.Length > activeParameter)
?.Item2 ?? -1;
}
activeSignature = activeSignature >= 0
? activeSignature
: (signatures.Length > 0 ? 0 : -1);
return(new SignatureHelp {
signatures = signatures.ToArray(),
activeSignature = activeSignature,
activeParameter = activeParameter
});
}
public IEnumerable <TypeInformation> GetTypeInformation(byte[] rawAssembly)
{
if (rawAssembly == null || rawAssembly.Length == 0)
{
return(Enumerable.Empty <TypeInformation>());
}
List <TypeInformation> results = new List <TypeInformation>();
Assembly assembly = Assembly.Load(rawAssembly);
List <string> propertyNamesToFilterFromCalculationContexts = GeneratePropertyNameToFilterForCalculationContexts(assembly);
TypeInfo[] assemblyDefinedTypes = assembly.DefinedTypes.ToArray();
foreach (TypeInfo typeInfo in assemblyDefinedTypes)
{
if (typeInfo != null)
{
if (typeInfo.IsNotPublic)
{
continue;
}
TypeInformation typeInformationModel = new TypeInformation()
{
Name = typeInfo.Name,
Description = GetAttributeProperty(typeInfo.CustomAttributes, "Description", "Description"),
Type = ConvertTypeName(typeInfo.FullName),
};
if (typeInfo.Name.EndsWith("Exception", StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
if (typeInfo.Name.StartsWith("_Closure$", StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
if (typeInfo.Name.Equals("ProjectData", StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
bool isTemplateCalculationContainerClass = IsTemplateCalculationContextClass(typeInfo);
List <MethodInformation> methods = new List <MethodInformation>();
foreach (MethodInfo methodInfo in typeInfo.GetMethods())
{
if (isTemplateCalculationContainerClass && filteredTemplateCalcMethods.Contains(methodInfo.Name))
{
continue;
}
if (IsAggregateFunction(methodInfo.Name))
{
methods.Add(ConfigureAggregateFunctionMetadata(methodInfo));
}
else if (filteredMethodNames.Any(f => string.Equals(methodInfo.Name, f, StringComparison.InvariantCultureIgnoreCase)))
{
continue;
}
else
{
if (!methodInfo.IsSpecialName)
{
List <ParameterInformation> parameters = new List <ParameterInformation>();
foreach (ParameterInfo parameter in methodInfo.GetParameters())
{
var parameterReturnDetails = ConvertTypeName(parameter.ParameterType);
ParameterInformation parameterInformation = new ParameterInformation()
{
Name = parameter.Name,
Description = parameter.Name,
Type = parameterReturnDetails.fullReturnType,
TypeClass = parameterReturnDetails.directType,
};
parameters.Add(parameterInformation);
}
string entityId = null;
bool isCustom = false;
var calculationAttribute = methodInfo.CustomAttributes.Where(c => c.AttributeType.Name == "CalculationAttribute").FirstOrDefault();
if (calculationAttribute != null)
{
entityId = calculationAttribute.NamedArguments.Where(a => a.MemberName == "Id").FirstOrDefault().TypedValue.Value?.ToString();
isCustom = true;
}
var(fullReturnType, directType, isNullable) = ConvertTypeName(methodInfo.ReturnType);
MethodInformation methodInformation = new MethodInformation()
{
Name = methodInfo.Name,
ReturnType = fullReturnType,
ReturnTypeClass = directType,
ReturnTypeIsNullable = isNullable,
Parameters = parameters,
EntityId = entityId,
IsCustom = isCustom
};
if (string.IsNullOrWhiteSpace(methodInformation.FriendlyName))
{
methodInformation.FriendlyName = GetAttributeProperty(methodInfo.CustomAttributes, "Calculation", "Name");
}
if (string.IsNullOrWhiteSpace(methodInformation.Description))
{
methodInformation.Description = GetAttributeProperty(methodInfo.CustomAttributes, "Description", "Description");
}
if (methodInfo.GetCustomAttribute <System.ComponentModel.EditorBrowsableAttribute>()?.State != System.ComponentModel.EditorBrowsableState.Never)
{
methods.Add(methodInformation);
}
}
}
}
FieldInfo[] fieldInfos = typeInfo.DeclaredFields.ToArray();
List <string> enumValues = new List <string>();
AddMethodsForClass(methods, fieldInfos, enumValues);
List <PropertyInformation> properties = new List <PropertyInformation>();
AddClassProperties(propertyNamesToFilterFromCalculationContexts, typeInfo, isTemplateCalculationContainerClass, properties);
typeInformationModel.Methods = methods;
typeInformationModel.Properties = properties;
typeInformationModel.EnumValues = enumValues;
results.Add(typeInformationModel);
}
}
IEnumerable <TypeInformation> dataTypes = GetDefaultTypes();
foreach (TypeInformation typeInformation in dataTypes)
{
results.Add(typeInformation);
}
IEnumerable <TypeInformation> keywords = GetKeywords();
foreach (TypeInformation typeInformation in keywords)
{
results.Add(typeInformation);
}
return(results);
}
