public void PublishDiagnostics(PublishDiagnosticsParams @params)
{
_connection.SendNotification(new NotificationMessage <PublishDiagnosticsParams>
{
method = "textDocument/publishDiagnostics",
@params = @params
});
}
private void OnPublishDiagnostics(object sender, PublishDiagnosticsEventArgs e)
{
var parameters = new PublishDiagnosticsParams {
uri = e.uri.ToString(),
diagnostics = e.diagnostics.ToArray()
};
_rpc.NotifyWithParameterObjectAsync("textDocument/publishDiagnostics", parameters).DoNotWait();
}
private void OnPublishDiagnostics(object sender, PublishDiagnosticsEventArgs e)
{
var parameters = new PublishDiagnosticsParams {
uri = e.uri,
diagnostics = e.diagnostics.ToArray()
};
_rpc.InvokeAsync("textDocument/publishDiagnostics", parameters);
}
public void PublishDiagnostics(Uri uri, IEnumerable <Diagnostic> diags)
{
var parameters = new PublishDiagnosticsParams {
uri = uri,
diagnostics = diags.ToArray()
};
_rpc.NotifyWithParameterObjectAsync("textDocument/publishDiagnostics", parameters).DoNotWait();
}
public void OnTextDocumentPublishDiagnostics(PublishDiagnosticsParams param)
{
if ((param.diagnostics == null) || (param.diagnostics.Length == 0))
{
return;
}
lock (publishDiagnostics_)
{
publishDiagnostics_[makePublishDiagnosticsKey(param.uri)] = param;
}
}
public void Publish(DocumentUri document)
{
PublishDiagnosticsParams diagnosticsParams = new PublishDiagnosticsParams();
diagnosticsParams.Uri = document;
var documentErrors = diagnosticCategories[document];
var allErrors = documentErrors.Values.SelectMany(x => x);
diagnosticsParams.Diagnostics = new Container <Diagnostic>(allErrors);
server.PublishDiagnostics(diagnosticsParams);
}
public PublishDiagnosticsParams GetPublishableDiagnostics()
{
var rawDiagnosticElements = _fileRepository.Result.DiagnosticElements;
var diagnostics = ConvertToLSPDiagnostics(rawDiagnosticElements);
PublishDiagnosticsParams p = new PublishDiagnosticsParams
{
Uri = _fileRepository.PhysicalFile.Uri,
Diagnostics = new Container <Diagnostic>(diagnostics)
};
return(p);
}
/// <summary>
/// Updates file and sends diagnostics and error count to the client with the diagnostics service
/// </summary>
private void ProcessUpdateRequest <T>(Uri uri, T textOrChangeEvent)
{
try
{
var fileRepository = UpdateFile(uri, textOrChangeEvent);
PublishDiagnosticsParams diags = GetDiagnostics(uri, fileRepository);
PublishResults(diags);
_log.LogInformation(string.Format(Resources.LoggingMessages.request_success, _method));
}
catch (Exception e)
{
HandleError(string.Format(Resources.LoggingMessages.request_error, _method), e);
}
}
/// <summary>
/// Event Method triggered when diagnostics are detected.
/// </summary>
/// <param name="fileUri">File URI to be send to the client</param>
/// <param name="diagnostics">List of TypeCobol compiler diagnostics</param>
private void DiagnosticsDetected(object fileUri, DiagnosticEvent diagnosticEvent)
{
var diagParameter = new PublishDiagnosticsParams();
var diagList = new List <Diagnostic>();
foreach (var diag in diagnosticEvent.Diagnostics)
{
diagList.Add(new Diagnostic(new Range(diag.Line, diag.ColumnStart, diag.Line, diag.ColumnEnd),
diag.Message, (DiagnosticSeverity)diag.Info.Severity, diag.Info.Code.ToString(),
diag.Info.ReferenceText));
}
diagParameter.uri = fileUri.ToString();
diagParameter.diagnostics = diagList.ToArray();
SendDiagnostics(diagParameter);
}
/// <summary>
/// ‘textDocument/publishDiagnostics’通知を取得する
/// </summary>
/// <returns>対応するドキュメントURIが存在していればnull以外、存在しなければnull</returns>
public PublishDiagnosticsParams[] PullTextDocumentPublishDiagnostics()
{
PublishDiagnosticsParams[] result;
int index = 0;
lock (publishDiagnostics_)
{
result = new PublishDiagnosticsParams[publishDiagnostics_.Count];
foreach (var item in publishDiagnostics_)
{
result[index] = item.Value;
++index;
}
publishDiagnostics_.Clear();
}
return(result);
}
private void DocumentDiagnosticsChanged(object sender, ProjectHandler.DocumentDiagnosticsEventArgs e)
{
var diagnosticsParams = new PublishDiagnosticsParams()
{
Uri = new Uri(e.DocumentPath).AbsoluteUri,
Diagnostics = e.Diagnostics
.Select(diagnostic => new Protocol.Diagnostic()
{
Range = diagnostic.Location.AsRange(),
Severity = ConvertSeverity(diagnostic.Severity),
Code = diagnostic.Id,
Source = "PeachPie",
Message = diagnostic.GetMessage(),
}),
};
_messageWriter.WriteNotification("textDocument/publishDiagnostics", diagnosticsParams);
}
private void PublishPendingDiagnostics()
{
List <KeyValuePair <Uri, Diagnostic[]> > list;
lock (_lock) {
list = _pendingDiagnostic.ToList();
_pendingDiagnostic.Clear();
}
foreach (var kvp in list)
{
var parameters = new PublishDiagnosticsParams {
uri = kvp.Key,
diagnostics = kvp.Value
};
_rpc.NotifyWithParameterObjectAsync("textDocument/publishDiagnostics", parameters).DoNotWait();
}
}
public PublishDiagnosticsParamsImpl(PublishDiagnosticsParams param)
{
param_ = param;
if ((param_ == null) || (param_.diagnostics == null))
{
diagnostics_ = new DiagnosticImpl[0];
return;
}
diagnostics_ = new DiagnosticImpl[param_.diagnostics.Length];
int i = 0;
foreach (var item in param_.diagnostics)
{
diagnostics_[i] = new DiagnosticImpl(item);
++i;
}
}
private PublishDiagnosticsParams ParseInternal(Uri uri, string text, bool detailed, CancellationToken cancellation)
{
var newUri = new Uri(Uri.UnescapeDataString(uri.AbsoluteUri));
var localPath = newUri.LocalPath;
// Workaround: Skip externals. Too many wrong function definitions
if (localPath.Contains("AI_Intern", StringComparison.OrdinalIgnoreCase) && localPath.EndsWith("Externals.d", StringComparison.OrdinalIgnoreCase))
{
return(null);
}
ParseResult parserResult = null;
if (string.IsNullOrWhiteSpace(text))
{
parserResult = FastCompiler.Load(localPath, detailed, GetDocuments().Values);
}
else
{
parserResult = FastCompiler.Parse(text, newUri, detailed, GetDocuments().Values);
}
PublishDiagnosticsParams result = null;
if (parserResult.SyntaxErrors.Count > 0)
{
result = new PublishDiagnosticsParams
{
Uri = newUri,
Diagnostics = new Container <Diagnostic>(parserResult.SyntaxErrors
.Select(x => new Diagnostic
{
Message = x.ErrorCode.Description,
Code = x.ErrorCode.Code,
//Source = localPath,
Severity = DiagnosticSeverityFromSyntaxError(x),
Range = new OmniSharp.Extensions.LanguageServer.Protocol.Models.Range(new Position(x.Line - 1, x.Column), new Position(x.Line - 1, x.Column)),
}))
};
}
UpdateParseResult(uri, parserResult);
return(result);
}
public override Task <Unit> Handle(PublishDiagnosticsParams request,
CancellationToken cancellationToken)
{
_logger.LogInformation(
$"------------------------ {request.PrettyPrint()}");
_languageServer.Window.LogError(
$"--------------DIAGNOSTICS! {request.PrettyPrint()}");
var uri = request.Uri;
var errors = _bufferManager.GetAstFor(uri.ToString()).Errors;
var diagnostics = new List <Diagnostic>();
foreach (var error in errors)
{
diagnostics.Add(new Diagnostic()
{
Severity = DiagnosticSeverity.Error,
Message = $"Parser Error:\n{error.Message}",
Range = new Range(new Position(error.Line - 1, error.Column),
new Position(error.Line - 1, error.Column)),
});
}
diagnostics.Add(new Diagnostic()
{
Severity = DiagnosticSeverity.Error,
Message = $"Parser Error:\nTEST",
Range = new Range(new Position(3, 4),
new Position(3, 8))
});
request.Diagnostics = new Container <Diagnostic>(diagnostics);
_languageServer.SendNotification("textDocument/publishDiagnostics", request);
return(Unit.Task);
}
public void SimpleTest(string expected)
{
var model = new PublishDiagnosticsParams {
Uri = new Uri("file:///abc/123.cs"),
Diagnostics = new[] {
new Diagnostic {
Code = new DiagnosticCode("abcd"),
Message = "message",
Range = new Range(new Position(1, 1), new Position(2, 2)),
Severity = DiagnosticSeverity.Error,
Source = "csharp"
}
}
};
var result = Fixture.SerializeObject(model);
result.Should().Be(expected);
var deresult = new LspSerializer(ClientVersion.Lsp3).DeserializeObject <PublishDiagnosticsParams>(expected);
deresult.Should().BeEquivalentTo(model, x => x.UsingStructuralRecordEquality());
}
public void SimpleTest(string expected)
{
var model = new PublishDiagnosticsParams()
{
Uri = new Uri("file:///abc/123.cs"),
Diagnostics = new[] {
new Diagnostic()
{
Code = new DiagnosticCode("abcd"),
Message = "message",
Range = new Range(new Position(1, 1), new Position(2, 2)),
Severity = DiagnosticSeverity.Error,
Source = "csharp"
}
}
};
var result = Fixture.SerializeObject(model);
result.Should().Be(expected);
var deresult = JsonConvert.DeserializeObject <PublishDiagnosticsParams>(expected);
deresult.ShouldBeEquivalentTo(model);
}
/// <summary>
/// Diagnostics notification are sent from the server to the client to signal
/// results of validation runs.
/// </summary>
public virtual void SendDiagnostics(PublishDiagnosticsParams parameters)
{
}
public void DiagnosticReceived(PublishDiagnosticsParams request)
{
_diagnostics.Enqueue(request);
_availableDiagnostics.Release();
}
/// <summary>
/// Publishes the Diagnostics using the <c>_router</c>
/// </summary>
/// <param name="diags">The Diagnostics to publish.</param>
private void PublishResults(PublishDiagnosticsParams diags)
{
_router.Document.PublishDiagnostics(diags);
_mss.SendCountedErrors(diags.Diagnostics.Count());
}
public static void PublishDiagnostics(this IResponseRouter mediator, PublishDiagnosticsParams @params)
{
mediator.SendNotification(DocumentNames.PublishDiagnostics, @params);
}
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 static void PublishDiagnostics(this ILanguageServerDocument mediator, PublishDiagnosticsParams @params)
{
mediator.SendNotification(DocumentNames.PublishDiagnostics, @params);
}
public static void PublishDiagnostics(this ILanguageServer mediator, PublishDiagnosticsParams @params)
{
mediator.SendNotification("textDocument/publishDiagnostics", @params);
}
public override Task <Unit> Handle(PublishDiagnosticsParams request, CancellationToken cancellationToken) => _handler.Invoke(request);
public abstract Task <Unit> Handle(PublishDiagnosticsParams request, CancellationToken cancellationToken);
internal DiagnosticEventArgs(PublishDiagnosticsParams diagnosticParams)
{
this.diagnosticParams = diagnosticParams;
}
