/// <summary>
/// Checks if cert is from a trusted CA with a valid certificate chain.
/// </summary>
/// <param name="online">Check certificate chain online or off-line.</param>
/// <returns>True of cert chain is valid and from a trusted CA.</returns>
public bool IsValidCertChain(bool online)
{
if (!IsSigned)
return false;
return SignatureInformation.IsValidCertChain(PKCS7, online);
}
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()
});
}
/// <summary>
/// Checks if cert is from a trusted CA with a valid certificate chain.
/// </summary>
/// <param name="online">Check certificate chain online or off-line.</param>
/// <returns>True of cert chain is valid and from a trusted CA.</returns>
public bool IsValidCertChain(bool online)
{
if (!IsSigned)
{
return(false);
}
return(SignatureInformation.IsValidCertChain(PKCS7, online));
}
private static SignatureInformation GetSignatureFromDoc(string doc)
{
var si = new SignatureInformation();
var firstLineBreak = doc.IndexOfAny(new[] { '\r', '\n' });
si.label = firstLineBreak > 0 ? doc.Substring(0, firstLineBreak) : doc;
si.documentation = doc.Substring(si.label.Length).TrimStart();
si.parameters = GetParametersFromDoc(si.label);
return(si);
}
SignatureInformation GetFuncSignInfo(bhlParser.FuncDeclContext funcDecl)
{
SignatureInformation funcSignature = new SignatureInformation();
string label = funcDecl.NAME().GetText() + "(";
List <ParameterInformation> funcParameters = BHLSPUtil.GetInfoParams(funcDecl);
if (funcParameters.Count > 0)
{
for (int k = 0; k < funcParameters.Count; k++)
{
var funcParameter = funcParameters[k];
label += funcParameter.label.Value;
if (k != funcParameters.Count - 1)
{
label += ", ";
}
}
}
else
{
label += "<no parameters>";
}
label += ")";
if (funcDecl.retType() is bhlParser.RetTypeContext retType)
{
label += ":";
var types = retType.type();
for (int n = 0; n < types.Length; n++)
{
var t = types[n];
if (t.exception != null)
{
continue;
}
label += t.NAME().GetText() + " ";
}
}
else
{
label += ":void";
}
funcSignature.label = label;
funcSignature.parameters = funcParameters.ToArray();
return(funcSignature);
}
protected async Task HandleSignatureHelpRequest(
TextDocumentPosition textDocumentPosition,
EditorSession editorSession,
RequestContext <SignatureHelp, object> requestContext)
{
ScriptFile scriptFile =
editorSession.Workspace.GetFile(
textDocumentPosition.Uri);
ParameterSetSignatures parameterSets =
await editorSession.LanguageService.FindParameterSetsInFile(
scriptFile,
textDocumentPosition.Position.Line + 1,
textDocumentPosition.Position.Character + 1);
SignatureInformation[] signatures = null;
int?activeParameter = null;
int?activeSignature = 0;
if (parameterSets != null)
{
signatures =
parameterSets
.Signatures
.Select(s =>
{
return(new SignatureInformation
{
Label = parameterSets.CommandName + " " + s.SignatureText,
Documentation = null,
Parameters =
s.Parameters
.Select(CreateParameterInfo)
.ToArray()
});
})
.ToArray();
}
else
{
signatures = new SignatureInformation[0];
}
await requestContext.SendResult(
new SignatureHelp
{
Signatures = signatures,
ActiveParameter = activeParameter,
ActiveSignature = activeSignature
});
}
private static SignatureInformation BuildSignature(IMethodSymbol symbol)
{
var parameters = symbol.Parameters
.Select(parameter =>
new ParameterInformation(
label: parameter.Name,
documentation: new FormattedValue("text/markdown", DocumentationConverter.ConvertDocumentation(parameter.GetDocumentationCommentXml(expandIncludes: true)))));
var signatureInformation = new SignatureInformation(
label: symbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
documentation: new FormattedValue("text/markdown", DocumentationConverter.ConvertDocumentation(symbol.GetDocumentationCommentXml(expandIncludes: true))),
parameters: parameters.ToList());
return(signatureInformation);
}
private SignatureHelpItem CreateSignatureHelpItem(SignatureInformation signatureInformation)
{
var signatureText = signatureInformation.Label;
var emptyText = ToTaggedText(string.Empty);
var parameters = signatureInformation.Parameters.Select(parameter =>
{
Func <CancellationToken, IEnumerable <TaggedText> > paramDocumentationFactory = (ct) => ToTaggedText(parameter.Documentation?.Value);
return(new SignatureHelpParameter((string)parameter.Label, false, paramDocumentationFactory, emptyText));
});
return(new SignatureHelpItem(false, DocumentationFactory, ToTaggedText(signatureInformation.Label), emptyText, emptyText, parameters, emptyText));
// local functions
IEnumerable <TaggedText> DocumentationFactory(CancellationToken ct) => ToTaggedText(signatureInformation.Documentation?.Value);
}
public async Task <SignatureHelp> Handle(SignatureHelpParams request, CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
_logger.LogDebug("SignatureHelp request canceled for file: {0}", request.TextDocument.Uri);
return(new SignatureHelp());
}
ScriptFile scriptFile = _workspaceService.GetFile(request.TextDocument.Uri);
ParameterSetSignatures parameterSets =
await _symbolsService.FindParameterSetsInFileAsync(
scriptFile,
(int)request.Position.Line + 1,
(int)request.Position.Character + 1,
_powerShellContextService).ConfigureAwait(false);
if (parameterSets == null)
{
return(new SignatureHelp());
}
var signatures = new SignatureInformation[parameterSets.Signatures.Length];
for (int i = 0; i < signatures.Length; i++)
{
var parameters = new List <ParameterInformation>();
foreach (ParameterInfo param in parameterSets.Signatures[i].Parameters)
{
parameters.Add(CreateParameterInfo(param));
}
signatures[i] = new SignatureInformation
{
Label = parameterSets.CommandName + " " + parameterSets.Signatures[i].SignatureText,
Documentation = null,
Parameters = parameters,
};
}
return(new SignatureHelp
{
Signatures = signatures,
ActiveParameter = null,
ActiveSignature = 0
});
}
static SignatureHelp CreateMethodGroupSignatureHelp(
ExpressionSyntax expression,
ArgumentListSyntax argumentList,
int position,
SemanticModel semanticModel)
{
var signatureHelp = new SignatureHelp();
// Happens for object initializers with no preceding parens, as soon as user types comma
if (argumentList == null)
{
return(signatureHelp);
}
int currentArg;
if (TryGetCurrentArgumentIndex(argumentList, position, out currentArg))
{
signatureHelp.ActiveParameter = currentArg;
}
var symbolInfo = semanticModel.GetSymbolInfo(expression);
var bestGuessMethod = symbolInfo.Symbol as IMethodSymbol;
var methods = semanticModel
.GetMemberGroup(expression)
.OfType <IMethodSymbol> ()
.ToArray();
var signatures = new List <SignatureInformation> ();
for (var i = 0; i < methods.Length; i++)
{
if (methods [i] == bestGuessMethod)
{
signatureHelp.ActiveSignature = i;
}
var signatureInfo = new SignatureInformation(methods [i]);
signatures.Add(signatureInfo);
}
signatureHelp.Signatures = signatures.ToArray();
return(signatureHelp);
}
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
});
}
private SignatureInformation ToSignatureInformation(IOverloadResult overload)
{
var si = new SignatureInformation {
parameters = overload.Parameters.MaybeEnumerate().Select(p => new ParameterInformation {
label = p.Name,
documentation = string.IsNullOrEmpty(p.Documentation) ? null : p.Documentation,
_type = p.Type,
_defaultValue = p.DefaultValue
}).ToArray(),
_returnTypes = overload.ReturnType.OrderBy(k => k).ToArray()
};
if (_clientCaps?.textDocument?.signatureHelp?.signatureInformation?._shortLabel ?? false)
{
si.label = overload.Name;
}
else
{
var doc = overload.Documentation;
// Some function contain signature in the documentation. Example: print.
// We want to use that signature in VS Code since it contains all arguments.
if (si.parameters.Length == 0 && !string.IsNullOrEmpty(doc) && doc.StartsWithOrdinal($"{overload.Name}("))
{
return(GetSignatureFromDoc(doc));
}
si.label = "{0}({1})".FormatInvariant(
overload.Name,
string.Join(", ", overload.Parameters.Select(FormatParameter))
);
}
si.documentation = string.IsNullOrEmpty(overload.Documentation) ? null : overload.Documentation;
var formatSetting = _clientCaps?.textDocument?.signatureHelp?.signatureInformation?.documentationFormat;
si.documentation = GetMarkupContent(si.documentation.value, formatSetting);
foreach (var p in si.parameters)
{
p.documentation = GetMarkupContent(p.documentation.value, formatSetting);
}
return(si);
}
/// <summary>Main method for validating a signature</summary>
/// <param name="signature"></param>
/// <param name="referenceTime"></param>
/// <returns>the report part pertaining to the signature</returns>
protected internal virtual SignatureInformation ValidateSignature(AdvancedSignature
signature, DateTime referenceTime)
{
if (signature.GetSigningCertificate() == null)
{
LOG.Error("There is no signing certificate");
return(null);
}
QCStatementInformation qcStatementInformation = VerifyQStatement(signature.GetSigningCertificate
());
SignatureVerification signatureVerification = new SignatureVerification(new Result
(signature.CheckIntegrity(this.ExternalContent)), signature.GetSignatureAlgorithm
());
try
{
ValidationContext ctx = CertificateVerifier.ValidateCertificate(signature.GetSigningCertificate
(), referenceTime, signature.GetCertificateSource(), signature.GetCRLSource(), signature
.GetOCSPSource());
TrustedListInformation info = new TrustedListInformation(ctx.GetRelevantServiceInfo
());
CertPathRevocationAnalysis path = new CertPathRevocationAnalysis(ctx, info);
SignatureLevelXL signatureLevelXL = VerifyLevelXL(signature, referenceTime, ctx);
SignatureLevelC signatureLevelC = VerifyLevelC(signature, referenceTime, ctx, signatureLevelXL
!= null ? signatureLevelXL.GetLevelReached().IsValid() : false);
SignatureLevelAnalysis signatureLevelAnalysis = new SignatureLevelAnalysis(signature
, VerifyLevelBES(signature, referenceTime, ctx), VerifyLevelEPES(signature, referenceTime
, ctx), VerifyLevelT(signature, referenceTime, ctx), signatureLevelC, VerifyLevelX
(signature, referenceTime, ctx), signatureLevelXL, VerifyLevelA(signature, referenceTime
, ctx), VerifyLevelLTV(signature, referenceTime, ctx));
QualificationsVerification qualificationsVerification = VerifyQualificationsElement
(signature, referenceTime, ctx);
SignatureInformation signatureInformation = new SignatureInformation(signatureVerification
, path, signatureLevelAnalysis, qualificationsVerification, qcStatementInformation
);
return(signatureInformation);
}
catch (IOException e)
{
throw new RuntimeException("Cannot read signature file", e);
}
}
/// <summary>
/// Opens temporary PDF and appends signature and ocsp and crl information (if available)
/// </summary>
/// <param name="signatureInformation">Information required for finding the temporary PDF</param>
public void SignIntermediatePdf(SignatureInformation signatureInformation)
{
var document = new PdfDocument(new PdfReader(signatureInformation.PathToIntermediaryPdf));
using var writer = new FileStream(signatureInformation.pathToSignedPdf, FileMode.Create);
var crlBytesList = GetCrlByteList();
var ocspBytesList = GetOcspBytesList();
var container = new InjectAmaSignatureContainer(signatureInformation.Signature,
_userCertificateChain,
signatureInformation.NakedHashFromIntermediaryPdf,
crlBytesList,
ocspBytesList,
_tsaClient);
PdfSigner.SignDeferred(document, _signatureFieldname, writer, container);
}
public void SimpleTest(string expected)
{
var model = new SignatureInformation {
Documentation = "ab",
Label = "ab",
Parameters = new[] {
new ParameterInformation {
Documentation = "param",
Label = "param"
}
}
};
var result = Fixture.SerializeObject(model);
result.Should().Be(expected);
var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject <SignatureInformation>(expected);
deresult.Should().BeEquivalentTo(model);
}
/// <summary>
/// To Template signature information.
/// </summary>
public static SignatureInformation ToSignatureInformation(this PageInfo pageInfo, PageInfo redirectSource)
{
if (pageInfo == null)
{
throw new ArgumentNullException(nameof(pageInfo));
}
var labelBuilder = new StringBuilder("{{");
labelBuilder.Append(pageInfo.TransclusionName);
var sig = new SignatureInformation();
if (pageInfo.Arguments.Count > 0)
{
sig.Parameters = pageInfo.Arguments.Select(a => a.ToParameterInformation(pageInfo.Type))
.ToImmutableArray();
foreach (var a in pageInfo.Arguments)
{
if (pageInfo.Type == PageType.MagicWord)
{
labelBuilder.AppendFormat(" |<{0}>", a.Name);
}
else
{
labelBuilder.AppendFormat(" |{0}=…", a.Name);
}
}
}
labelBuilder.Append("}}");
sig.Label = labelBuilder.ToString();
sig.Documentation = pageInfo.Summary;
if (redirectSource != null)
{
sig.Documentation = string.Format("{0}{1} -> {2}\r\n", Prompts.RedirectColon, redirectSource, pageInfo)
+ sig.Documentation;
}
return(sig);
}
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 void MarkupContentTest(string expected)
{
var model = new SignatureInformation()
{
Documentation = "ab",
Label = "ab",
Parameters = new[] { new ParameterInformation()
{
Documentation = new MarkupContent()
{
Kind = MarkupKind.Markdown,
Value = "### Value"
},
Label = "param"
} }
};
var result = Fixture.SerializeObject(model);
result.Should().Be(expected);
var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject <SignatureInformation>(expected);
deresult.ShouldBeEquivalentTo(model);
}
public void GeneratesKey()
{
_signatureInfo = Generator.Generate();
}
internal IntellisenseResult(IIntellisenseData data, List <IntellisenseSuggestion> suggestions, Exception exception = null)
{
Contracts.AssertValue(suggestions);
_script = data.Script;
Contracts.CheckValue(_script, "script");
ReplacementStartIndex = data.ReplacementStartIndex;
Contracts.CheckParam(0 <= data.ReplacementStartIndex, "replacementStartIndex");
ReplacementLength = data.ReplacementLength;
Contracts.CheckParam(0 <= data.ReplacementLength, "replacementLength");
var argIndex = data.ArgIndex;
var argCount = data.ArgCount;
Contracts.CheckParam(0 <= argIndex, "argIndex");
Contracts.CheckParam(0 <= argCount, "argCount");
Contracts.Check(argIndex <= argCount, "argIndex out of bounds.");
var func = data.CurFunc;
Contracts.CheckValueOrNull(func);
_suggestions = suggestions;
_functionSignatures = new List <SignatureInformation>();
_functionOverloads = new List <IntellisenseSuggestion>();
CurrentFunctionOverloadIndex = -1;
_currentArgumentIndex = argIndex;
Exception = exception;
if (func == null)
{
IsFunctionScope = false;
}
else
{
IsFunctionScope = true;
int highlightStart = -1;
int highlightEnd = -1;
int minMatchingArgCount = int.MaxValue;
foreach (var signature in func.GetSignatures(argCount))
{
int signatureIndex = 0;
string argumentSeparator = string.Empty;
string highlightedFuncParamDescription = string.Empty;
string listSep = TexlLexer.LocalizedInstance.LocalizedPunctuatorListSeparator + " ";
StringBuilder funcDisplayString = new StringBuilder(func.Name);
funcDisplayString.Append('(');
var parameters = new List <ParameterInformation>();
while (signatureIndex < signature.Count())
{
Contracts.AssertValue(signature[signatureIndex]);
funcDisplayString.Append(argumentSeparator);
// We need to change the highlight information if the argument should be highlighted, but
// otherwise we still want to collect parameter information
var unalteredParamName = signature[signatureIndex]();
var invariantParamName = signature[signatureIndex]("en-US");
(var paramName, var parameterHighlightStart, var parameterHighlightEnd, var funcParamDescription) = GetParameterHighlightAndDescription(data, unalteredParamName, invariantParamName, funcDisplayString);
parameters.Add(new ParameterInformation()
{
Documentation = funcParamDescription,
Label = paramName
});
if (ArgNeedsHighlight(func, argCount, argIndex, signature.Count(), signatureIndex))
{
(highlightStart, highlightEnd, highlightedFuncParamDescription) = (parameterHighlightStart, parameterHighlightEnd, funcParamDescription);
}
// For variadic function, we want to generate FuncName(arg1,arg1,...,arg1,...) as description.
if (func.SignatureConstraint != null && argCount > func.SignatureConstraint.RepeatTopLength && canParamOmit(func, argCount, argIndex, signature.Count(), signatureIndex))
{
funcDisplayString.Append("...");
signatureIndex += func.SignatureConstraint.RepeatSpan;
}
else
{
funcDisplayString.Append(signature[signatureIndex]());
signatureIndex++;
}
argumentSeparator = listSep;
}
if (func.MaxArity > func.MinArity && func.MaxArity > argCount)
{
funcDisplayString.Append(argumentSeparator + "...");
}
funcDisplayString.Append(')');
var signatureInformation = new SignatureInformation()
{
Documentation = func.Description,
Label = CreateFunctionSignature(func.Name, parameters),
Parameters = parameters.ToArray()
};
_functionSignatures.Add(signatureInformation);
_functionOverloads.Add(new IntellisenseSuggestion(new UIString(funcDisplayString.ToString(), highlightStart, highlightEnd), SuggestionKind.Function, SuggestionIconKind.Function, func.ReturnType, signatureIndex, func.Description, func.Name, highlightedFuncParamDescription));
if ((signatureIndex >= argCount || (func.SignatureConstraint != null && argCount > func.SignatureConstraint.RepeatTopLength)) && minMatchingArgCount > signatureIndex)
{
// _functionOverloads has at least one item at this point.
CurrentFunctionOverloadIndex = _functionOverloads.Count - 1;
minMatchingArgCount = signatureIndex;
}
}
// Handling of case where the function does not take any arguments.
if (_functionOverloads.Count == 0 && func.MinArity == 0)
{
var signatureInformation = new SignatureInformation()
{
Documentation = func.Description,
Label = CreateFunctionSignature(func.Name),
Parameters = new ParameterInformation[0]
};
_functionSignatures.Add(signatureInformation);
_functionOverloads.Add(new IntellisenseSuggestion(new UIString(func.Name + "()", 0, func.Name.Length + 1), SuggestionKind.Function, SuggestionIconKind.Function, func.ReturnType, string.Empty, 0, func.Description, func.Name));
CurrentFunctionOverloadIndex = 0;
}
}
Contracts.Assert(_functionSignatures.Count == _functionOverloads.Count);
}
public static SignatureInformationAssertions Should(this SignatureInformation signatureInformation) => new SignatureInformationAssertions(signatureInformation);
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));
}
static SignatureHelp CreateMethodGroupSignatureHelp(
ExpressionSyntax expression,
ArgumentListSyntax argumentList,
int position,
SemanticModel semanticModel)
{
var signatureHelp = new SignatureHelp();
// Happens for object initializers with no preceding parens, as soon as user types comma
if (argumentList == null)
{
return(signatureHelp);
}
int currentArg;
if (TryGetCurrentArgumentIndex(argumentList, position, out currentArg))
{
signatureHelp.ActiveParameter = currentArg;
}
var symbolInfo = semanticModel.GetSymbolInfo(expression);
var bestGuessMethod = symbolInfo.Symbol as IMethodSymbol;
// Include everything by default (global eval context)
var includeInstance = true;
var includeStatic = true;
ITypeSymbol throughType = null;
// When accessing method via some member, only show static methods in static context and vice versa for instance methods.
// This block based on https://github.com/dotnet/roslyn/blob/3b6536f4a616e5f3b8ede940c63663a828e68b5d/src/Features/CSharp/Portable/SignatureHelp/InvocationExpressionSignatureHelpProvider_MethodGroup.cs#L44-L50
if (expression is MemberAccessExpressionSyntax memberAccessExpression)
{
var throughExpression = (memberAccessExpression).Expression;
if (!(throughExpression is BaseExpressionSyntax))
{
throughType = semanticModel.GetTypeInfo(throughExpression).Type;
}
var throughSymbolInfo = semanticModel.GetSymbolInfo(throughExpression);
var throughSymbol = throughSymbolInfo.Symbol ?? throughSymbolInfo.CandidateSymbols.FirstOrDefault();
includeInstance = !throughExpression.IsKind(SyntaxKind.IdentifierName) ||
semanticModel.LookupSymbols(throughExpression.SpanStart, name: throughSymbol.Name).Any(s => !(s is INamedTypeSymbol)) ||
(!(throughSymbol is INamespaceOrTypeSymbol) && semanticModel.LookupSymbols(throughExpression.SpanStart, throughSymbol.ContainingType).Any(s => !(s is INamedTypeSymbol)));
includeStatic = throughSymbol is INamedTypeSymbol ||
(throughExpression.IsKind(SyntaxKind.IdentifierName) &&
semanticModel.LookupNamespacesAndTypes(throughExpression.SpanStart, name: throughSymbol.Name).Any(t => t.GetSymbolType() == throughType));
}
// TODO: Start taking CT in here? Most calls in this method have optional CT arg. Could make this async.
var within = semanticModel.GetEnclosingNamedTypeOrAssembly(position, CancellationToken.None);
var methods = semanticModel
.GetMemberGroup(expression)
.OfType <IMethodSymbol> ()
.Where(m => (m.IsStatic && includeStatic) || (!m.IsStatic && includeInstance))
.Where(m => m.IsAccessibleWithin(within, throughTypeOpt: throughType))
.ToArray();
var signatures = new List <SignatureInformation> ();
for (var i = 0; i < methods.Length; i++)
{
if (methods [i] == bestGuessMethod)
{
signatureHelp.ActiveSignature = i;
}
var signatureInfo = new SignatureInformation(methods [i]);
signatures.Add(signatureInfo);
}
signatureHelp.Signatures = signatures.ToArray();
return(signatureHelp);
}
/// <summary>
/// Checks if cert is from a trusted CA with a valid certificate chain.
/// </summary>
/// <param name="online">Check certificate chain online or off-line.</param>
/// <returns>True of cert chain is valid and from a trusted CA.</returns>
public bool IsValidCertChain(bool online)
{
return(IsSigned && SignatureInformation.IsValidCertChain(PKCS7, online));
}
/// <summary>
/// Returns the signature help information for a call expression if there is such an expression at the specified position.
/// Returns null if some parameters are unspecified (null),
/// or if the specified position is not a valid position within the currently processed file content,
/// or if no call expression exists at the specified position at this time,
/// or if no signature help information can be provided for the call expression at the specified position.
/// </summary>
public static SignatureHelp?SignatureHelp(
this FileContentManager file,
CompilationUnit compilation,
Position?position,
MarkupKind format = MarkupKind.PlainText)
{
// getting the relevant token (if any)
var fragment = file?.TryGetFragmentAt(position, out var _, includeEnd: true);
if (file is null || position is null || fragment?.Kind == null || compilation == null)
{
return(null);
}
var fragmentStart = fragment.Range.Start;
// getting the overlapping call expressions (if any), and determine the header of the called callable
bool OverlapsWithPosition(Range symRange) => (fragmentStart + symRange).ContainsEnd(position);
var overlappingEx = fragment.Kind.CallExpressions().Where(ex => ex.Range.IsValue && OverlapsWithPosition(ex.Range.Item)).ToList();
if (!overlappingEx.Any())
{
return(null);
}
overlappingEx.Sort((ex1, ex2) => // for nested call expressions, the last expressions (by range) is always the closest one
{
var(x, y) = (ex1.Range.Item, ex2.Range.Item);
int result = x.Start.CompareTo(y.Start);
return(result == 0 ? x.End.CompareTo(y.End) : result);
});
var nsName = file.TryGetNamespaceAt(position);
var(method, args) = overlappingEx.Last().Expression is QsExpressionKind <QsExpression, QsSymbol, QsType> .CallLikeExpression c ? (c.Item1, c.Item2) : (null, null);
if (nsName == null || method == null || args == null)
{
return(null);
}
// getting the called identifier as well as what functors have been applied to it
List <QsFunctor> FunctorApplications(ref QsExpression ex)
{
var(next, inner) =
ex.Expression is QsExpressionKind <QsExpression, QsSymbol, QsType> .AdjointApplication adj ? (QsFunctor.Adjoint, adj.Item) :
ex.Expression is QsExpressionKind <QsExpression, QsSymbol, QsType> .ControlledApplication ctl ? (QsFunctor.Controlled, ctl.Item) :
(null, null);
var fs = inner == null ? new List <QsFunctor>() : FunctorApplications(ref inner);
if (next != null)
{
fs.Add(next);
}
ex = inner ?? ex;
return(fs);
}
var functors = FunctorApplications(ref method);
var id = method.Expression as QsExpressionKind <QsExpression, QsSymbol, QsType> .Identifier;
if (id == null)
{
return(null);
}
// extracting and adapting the relevant information for the called callable
ResolutionResult <CallableDeclarationHeader> .Found?methodDecl = null;
if (id.Item1.Symbol is QsSymbolKind <QsSymbol> .Symbol sym)
{
methodDecl =
compilation.GlobalSymbols.TryResolveAndGetCallable(
sym.Item,
nsName,
file.FileName)
as ResolutionResult <CallableDeclarationHeader> .Found;
}
else if (id.Item1.Symbol is QsSymbolKind <QsSymbol> .QualifiedSymbol qualSym)
{
methodDecl =
compilation.GlobalSymbols.TryGetCallable(
new QsQualifiedName(qualSym.Item1, qualSym.Item2),
nsName,
file.FileName)
as ResolutionResult <CallableDeclarationHeader> .Found;
}
if (methodDecl == null)
{
return(null);
}
var(documentation, argTuple) = (methodDecl.Item.Documentation, methodDecl.Item.ArgumentTuple);
var nrCtlApplications = functors.Where(f => f.Equals(QsFunctor.Controlled)).Count();
while (nrCtlApplications-- > 0)
{
var ctlQsName = QsLocalSymbol.NewValidName(nrCtlApplications == 0 ? "cs" : $"cs{nrCtlApplications}");
argTuple = SyntaxGenerator.WithControlQubits(argTuple, QsNullable <Position> .Null, ctlQsName, QsNullable <Range> .Null);
}
// now that we now what callable is called we need to check which argument should come next
bool BeforePosition(Range symRange) => fragmentStart + symRange.End < position;
IEnumerable <(Range?, string?)> ExtractParameterRanges(
QsExpression?ex, QsTuple <LocalVariableDeclaration <QsLocalSymbol> > decl)
{
var @null = ((Range?)null, (string?)null);
IEnumerable <(Range?, string?)> SingleItem(string paramName)
{
var arg = ex?.Range == null ? ((Range?)null, paramName)
: ex.Range.IsValue ? (ex.Range.Item, paramName)
: @null; // no signature help if there are invalid expressions
return(new[] { arg });
}
if (decl is QsTuple <LocalVariableDeclaration <QsLocalSymbol> > .QsTupleItem dItem)
{
return(SingleItem(dItem.Item.VariableName is QsLocalSymbol.ValidName n ? n.Item : "__argName__"));
}
var declItems = decl as QsTuple <LocalVariableDeclaration <QsLocalSymbol> > .QsTuple;
var exItems = ex?.Expression as QsExpressionKind <QsExpression, QsSymbol, QsType> .ValueTuple;
if (declItems == null)
{
return(new[] { @null });
}
if (exItems == null && declItems.Item.Length > 1)
{
return(SingleItem(decl.PrintArgumentTuple()));
}
var argItems = exItems != null
? exItems.Item.ToImmutableArray <QsExpression?>()
: ex == null
? ImmutableArray <QsExpression?> .Empty
: ImmutableArray.Create <QsExpression?>(ex);
return(argItems.AddRange(Enumerable.Repeat <QsExpression?>(null, declItems.Item.Length - argItems.Length))
.Zip(declItems.Item, (e, d) => (e, d))
.SelectMany(arg => ExtractParameterRanges(arg.Item1, arg.Item2)));
}
var callArgs = ExtractParameterRanges(args, argTuple).ToArray();
if (id == null || callArgs == null || callArgs.Any(item => item.Item2 == null))
{
return(null); // no signature help if there are invalid expressions
}
// finally we can build the signature help information
MarkupContent AsMarkupContent(string str) => new MarkupContent
{
Kind = format, Value = str
};
ParameterInformation AsParameterInfo(string?paramName) => new ParameterInformation
{
Label = paramName,
Documentation = AsMarkupContent(documentation.ParameterDescription(paramName))
};
var signatureLabel = $"{methodDecl.Item.QualifiedName.Name} {argTuple.PrintArgumentTuple()}";
foreach (var f in functors)
{
if (f.IsAdjoint)
{
signatureLabel = $"{Keywords.qsAdjointFunctor.id} {signatureLabel}";
}
if (f.IsControlled)
{
signatureLabel = $"{Keywords.qsControlledFunctor.id} {signatureLabel}";
}
}
var doc = documentation.PrintSummary(format == MarkupKind.Markdown).Trim();
var info = new SignatureInformation
{
Documentation = AsMarkupContent(doc),
Label = signatureLabel, // Note: the label needs to be expressed in a way that the active parameter is detectable
Parameters = callArgs.Select(d => d.Item2).Select(AsParameterInfo).ToArray()
};
var precedingArgs = callArgs
.TakeWhile(item => item.Item1 == null || BeforePosition(item.Item1)) // skip args that have already been typed or - in the case of inner items - are missing
.Reverse().SkipWhile(item => item.Item1 == null); // don't count missing, i.e. not yet typed items, of the relevant inner argument tuple
return(new SignatureHelp
{
Signatures = new[] { info }, // since we don't support overloading there is just one signature here
ActiveSignature = 0,
ActiveParameter = precedingArgs.Count()
});
}
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
});
}
static void Main(string[] args)
{
string pathToSign = Path.Combine("Resources", "test.pdf");
string pathCertificate = Path.Combine("Resources", "test.p12");
string pathSigned = "test.pdf.p7m";
Document toBeSigned = new FileDocument(pathToSign);
Pkcs12SignatureToken token = new Pkcs12SignatureToken("password", pathCertificate);
IDssPrivateKeyEntry privateKey = token.GetKeys()[0];
SignatureParameters parameters = new SignatureParameters();
parameters.SignaturePackaging = SignaturePackaging.ENVELOPING;
parameters.SigningCertificate = privateKey.GetCertificate();
parameters.CertificateChain = privateKey.GetCertificateChain();
parameters.SigningDate = DateTime.Now;
parameters.DigestAlgorithm = DigestAlgorithm.SHA256;
CAdESService service = new CAdESService();
parameters.SignatureFormat = EU.Europa.EC.Markt.Dss.Signature.SignatureFormat.CAdES_BES;
/* CERTIFIED TIMESTAMP
* var ocspSource1 = new OnlineOcspSource();
* var crlSource1 = new FileCacheCrlSource();
* var crlOnline1 = new OnlineCrlSource();
* crlOnline1.IntermediateAcUrl = @"http://www.eci.bce.ec/CRL/cacrl.crl";
* crlSource1.CachedSource = crlOnline1;
* var verifier1 = new OCSPAndCRLCertificateVerifier(crlSource1, ocspSource1);
* var estado = verifier1.Check(privateKey.GetCertificate(), privateKey.GetCertificateChain()[1], DateTime.Now);
*/
/*
* //parameters.SignatureFormat = SignatureFormat.CAdES_T; //Se añade TSA.
* parameters.SignatureFormat = EU.Europa.EC.Markt.Dss.Signature.SignatureFormat.CAdES_C; //Se añade CRL y OCSP.
* //parameters.SignatureFormat = SignatureFormat.CAdES_X; //No se añade nada más al código.
* //parameters.SignatureFormat = EU.Europa.EC.Markt.Dss.Signature.SignatureFormat.CAdES_XL; //No se añade nada más al código.
*
* string urlTss = @"http://tsp.iaik.tugraz.at/tsp/TspRequest";
* string username = "";
* string password = "";
*
*
* OnlineTspSource tspSource = new OnlineTspSource(urlTss, username, password);
* service.TspSource = tspSource;
*
* OnlineOcspSource ocspSource = new OnlineOcspSource();
* TrustedListCertificateVerifier verifier = new TrustedListCertificateVerifier();
* FileCacheCrlSource crlSource = new FileCacheCrlSource();
* OnlineCrlSource crlOnline = new OnlineCrlSource();
* crlOnline.IntermediateAcUrl = @"http://www.eci.bce.ec/CRL/cacrl.crl";
* //@"http://www.eci.bce.ec/CRL/pruebas/cacrl.crl"
*
* crlSource.CachedSource = crlOnline;
* verifier.CrlSource = crlSource;
* verifier.OcspSource = ocspSource;
*
* ValidationContext validationContext = verifier.ValidateCertificate(parameters.SigningCertificate, DateTime.Now,
* new EU.Europa.EC.Markt.Dss.Validation.Certificate.CompositeCertificateSource(
* new EU.Europa.EC.Markt.Dss.Validation.Certificate.ListCertificateSource(parameters.CertificateChain)), null, null);
*
* service.Verifier = verifier;
*/
/* DOUBLE-SIGN
* Document contentInCMS = null;
*
* try
* {
* CmsSignedData cmsData = new CmsSignedData(toBeSigned.OpenStream());
* if (cmsData != null && cmsData.SignedContent != null
* && cmsData.SignedContent.GetContent() != null)
* {
* Stream buf = new MemoryStream();
* cmsData.SignedContent.Write(buf);
* buf.Seek(0, SeekOrigin.Begin);
* contentInCMS = new InMemoryDocument(Streams.ReadAll(buf));
* }
* }
* catch (CmsException)
* {
* }
*
* Stream iStream = service.ToBeSigned(contentInCMS ?? toBeSigned, parameters);
* byte[] signatureValue = token.Sign(iStream, parameters.DigestAlgorithm, privateKey);
*
* // We invoke the service to sign the document with the signature value obtained in the previous step.
* Document signedDocument = contentInCMS != null
* ? service.AddASignatureToDocument(toBeSigned, parameters, signatureValue)
* : service.SignDocument(toBeSigned, parameters, signatureValue);
*
* FileStream fs = new FileStream(pathParaFirmado, FileMode.OpenOrCreate);
* Streams.PipeAll(signedDocument.OpenStream(), fs);
* fs.Close();
* return;
*/
Document signedDocument = service.SignDocument(toBeSigned, parameters,
(hashbytes) => privateKey.Encrypt(hashbytes));
FileStream fs = new FileStream(pathSigned, FileMode.OpenOrCreate);
Streams.PipeAll(signedDocument.OpenStream(), fs);
fs.Close();
return;
// Already signed document
Document document = new FileDocument(pathSigned);
SignedDocumentValidator validator;
validator = SignedDocumentValidator.FromDocument(document);
//validator.CertificateVerifier = verifier;
validator.ExternalContent = document;
ValidationReport report = validator.ValidateDocument();
SignatureInformation info = report.SignatureInformationList[0];
Console.WriteLine("--> Final_Conclusion: ");
Console.WriteLine(info.FinalConclusion); // --> AdES
Console.ReadKey();
}
public void SetDigSignature(PeFile peFile)
{
// Clear all fields.
cbCertIsSigned.IsChecked = false;
cbCertIsValid.IsChecked = false;
cbCertIsValidChain.IsChecked = false;
tbCertLength.Text = string.Empty;
tbCertRevision.Text = string.Empty;
tbCertType.Text = string.Empty;
cbX509Archived.IsChecked = false;
cbX509HasPrivateKey.IsChecked = false;
tbX509FriendlyName.Text = string.Empty;
tbX509Issuer.Text = string.Empty;
tbX509Thumbprint.Text = string.Empty;
tbX509Version.Text = string.Empty;
tbX509NotAfter.Text = string.Empty;
tbX509NotBefore.Text = string.Empty;
tbX509SerialNumber.Text = string.Empty;
tbX509SignatureAlgorithm.Text = string.Empty;
tbX509Subject.Text = string.Empty;
tbX509PrivateKey.Text = string.Empty;
tbX509PublicKey.Text = string.Empty;
tbX509Extensions.Text = string.Empty;
tbX509CrlUrls.Text = string.Empty;
if (!peFile.IsSigned)
{
return;
}
cbCertIsValid.IsChecked = SignatureInformation.IsSignatureValid(peFile.FileLocation);
cbCertIsSigned.IsChecked = peFile.IsSigned;
cbCertIsValidChain.IsChecked = peFile.IsValidCertChain(true);
tbCertLength.Text = peFile.WinCertificate.dwLength.ToHexString();
tbCertRevision.Text = peFile.WinCertificate.wRevision.ToHexString();
tbCertType.Text = peFile.WinCertificate.wCertificateType.ToHexString();
cbX509Archived.IsChecked = peFile.PKCS7.Archived;
cbX509HasPrivateKey.IsChecked = peFile.PKCS7.HasPrivateKey;
tbX509FriendlyName.Text = peFile.PKCS7.FriendlyName;
tbX509Issuer.Text = peFile.PKCS7.Issuer.Replace(", ", "\n");
tbX509Thumbprint.Text = peFile.PKCS7.Thumbprint;
tbX509Version.Text = peFile.PKCS7.Version.ToString();
tbX509NotBefore.Text = peFile.PKCS7.NotBefore.ToLongDateString();
tbX509NotAfter.Text = peFile.PKCS7.NotAfter.ToLongDateString();
tbX509SerialNumber.Text = peFile.PKCS7.SerialNumber;
tbX509SignatureAlgorithm.Text = peFile.PKCS7.SignatureAlgorithm.FriendlyName;
tbX509Subject.Text = peFile.PKCS7.Subject.Replace(", ", "\n");
tbX509PublicKey.Text = peFile.PKCS7.PublicKey.EncodedKeyValue.Format(true);
tbX509PrivateKey.Text = peFile.PKCS7.PrivateKey?.ToXmlString(false);
foreach (var x509Extension in peFile.PKCS7.Extensions)
{
tbX509Extensions.Text += $"{x509Extension.Format(true)}\n";
}
foreach (var url in peFile.GetCrlUrlList().Urls)
{
tbX509CrlUrls.Text += $"{url}\n";
}
}
public async Task <SignatureHelp> Handle(SignatureHelpParams request, CancellationToken cancellationToken)
{
var documentPath = DocumentUri.GetFileSystemPath(request.TextDocument.Uri);
if (string.IsNullOrEmpty(documentPath))
{
return(new SignatureHelp());
}
var(rootScope, tc) = buffers.GetScope(documentPath);
if (rootScope == null)
{
return(new SignatureHelp());
}
var scope = GetCurrentScope(rootScope, (int)request.Position.Character, (int)request.Position.Line, documentPath);
var text = buffers.GetBuffer(documentPath);
var charIdx = (int)request.Position.Character;
var lineIdx = (int)request.Position.Line;
var lines = text.Split(System.Environment.NewLine);
var line = default(string);
if (lineIdx >= 0 && lineIdx < lines.Length)
{
line = lines[lineIdx];
}
if (line == null)
{
return(new SignatureHelp());
}
charIdx = System.Math.Clamp(charIdx, 0, line.Length - 1);
int activeParam = 0;
while (charIdx >= 0 && line[charIdx] != '(')
{
if (line[charIdx] == ',')
{
activeParam++;
}
charIdx--;
}
if (charIdx >= 0 && charIdx < line.Length)
{
if (line[charIdx] == '(')
{
charIdx--;
}
}
List <string> query = new List <string>();
while (true)
{
var current = "";
while (charIdx >= 0 && Token.isIdentifierChar(line[charIdx]))
{
current = line[charIdx] + current;
charIdx--;
}
if (string.IsNullOrWhiteSpace(current))
{
break;
}
else
{
query.Add(current);
}
while (charIdx >= 0 && char.IsWhiteSpace(line[charIdx]))
{
charIdx--;
}
if (charIdx <= 0 || line[charIdx] != '.')
{
break;
}
charIdx--;
}
List <string> modPath = new List <string>();
if (line.ElementAtOrDefault(charIdx) == ':' && line.ElementAtOrDefault(charIdx - 1) == ':')
{
charIdx -= 2;
while (true)
{
var current = "";
while (charIdx >= 0 && Token.isIdentifierChar(line[charIdx]))
{
current = line[charIdx] + current;
charIdx--;
}
if (string.IsNullOrWhiteSpace(current))
{
break;
}
else
{
modPath.Add(current);
}
while (charIdx >= 0 && char.IsWhiteSpace(line[charIdx]))
{
charIdx--;
}
if (charIdx <= 1 || line[charIdx] != ':' || line[charIdx - 1] != ':')
{
break;
}
charIdx -= 2;
}
}
if (query.Count > 0)
{
Scope.OverloadedVariableDefinition vd = null;
FrontendStructType st = null;
for (int i = query.Count - 1; i >= 0; --i)
{
var current = query[i];
FrontendType vt;
if (i == query.Count - 1)
{
if (modPath.Count > 0)
{
scope = scope.GetModule(modPath)?.scope;
if (scope == null)
{
break;
}
}
if (i == 0)
{
vd = scope.GetVar(current, Token.Undefined);
}
else
{
var v = scope.GetVar(current, Token.Undefined)?.First;
if (v == null)
{
st = null;
break;
}
if (v.node == null)
{
vt = v.type;
}
else
{
vt = tc.GetNodeType(v.node);
}
st = vt as FrontendStructType;
if (st == null && vt is FrontendPointerType pt)
{
st = pt.elementType as FrontendStructType;
}
if (st == null)
{
break;
}
}
}
else
{
if (i == 0)
{
vd = scope.GetVar(current, Token.Undefined);
}
else
{
var f = st.fields.Where(f => f.name == current).FirstOrDefault();
if (f == null)
{
st = null;
break;
}
vt = f.type;
st = vt as FrontendStructType;
if (st == null && vt is FrontendPointerType pt)
{
st = pt.elementType as FrontendStructType;
}
if (st == null)
{
break;
}
}
}
}
if (vd != null)
{
var infos = new List <SignatureInformation>();
foreach (var v in vd.variables)
{
FrontendFunctionType ft;
if (v.node == null)
{
ft = v.type as FrontendFunctionType;
}
else
{
ft = tc.GetNodeType(v.node) as FrontendFunctionType;
}
if (ft != null)
{
var info = new SignatureInformation();
var parameInfos = new List <ParameterInformation>();
var funName = ft.funName;
if (string.IsNullOrEmpty(funName))
{
funName = v.name;
}
var funString = $"{funName}(";
for (int i = 0; i < ft.parameters.Count; ++i)
{
var p = ft.parameters[i];
var paramString = $"{p.name}: {p.type}";
parameInfos.Add(
new ParameterInformation()
{
Label = paramString,
}
);
funString += paramString;
if (i < ft.parameters.Count - 1)
{
funString += "; ";
}
}
funString += $") => {ft.returnType}";
info.Label = funString;
info.Parameters = parameInfos;
infos.Add(info);
}
}
var result = new SignatureHelp
{
ActiveParameter = activeParam,
Signatures = new Container <SignatureInformation>(infos)
};
return(result);
}
}
return(new SignatureHelp());
}
public override RpcResult SignatureHelp(SignatureHelpParams args)
{
BHLSPWorkspace.self.TryAddDocument(args.textDocument.uri);
if (BHLSPWorkspace.self.FindDocument(args.textDocument.uri) is BHLTextDocument document)
{
int line = (int)args.position.line;
int character = (int)args.position.character;
int start = document.GetIndex(line);
int stop = document.GetIndex(line, character);
var text = document.text;
var txtLine = text.Substring(start, stop - start);
string funcName = string.Empty;
uint activeParameter = 0;
if (txtLine.IndexOf("func", StringComparison.Ordinal) == -1)
{
string pattern = @"[a-zA-Z_][a-zA-Z_0-9]*\({1}.*?";
MatchCollection matches = Regex.Matches(txtLine, pattern, RegexOptions.Multiline);
for (int i = matches.Count - 1; i >= 0; i--)
{
var m = matches[i];
if (m.Index < character)
{
string v = m.Value;
int len = v.Length - 1;
if (len > 0)
{
funcName = txtLine.Substring(m.Index, len);
var funcDeclStr = txtLine.Substring(m.Index, Math.Max(0, character - m.Index));
activeParameter = (uint)Math.Max(0, funcDeclStr.Split(',').Length - 1);
break;
}
}
}
}
bhlParser.FuncDeclContext funcDecl = null;
if (!string.IsNullOrEmpty(funcName))
{
foreach (var doc in BHLSPWorkspace.self.ForEachBhlImports(document))
{
if (doc.FuncDecls.ContainsKey(funcName))
{
funcDecl = doc.FuncDecls[funcName];
break;
}
}
}
if (funcDecl != null)
{
SignatureInformation signInfo = GetFuncSignInfo(funcDecl);
signInfo.activeParameter = activeParameter;
var result = new SignatureHelp();
result.activeSignature = 0;
result.signatures = new[] { signInfo };
result.activeParameter = signInfo.activeParameter;
return(RpcResult.Success(result));
}
}
return(RpcResult.Success());
}
