· 补充遗漏的协议

LanguageServer.Framework/LSPCommunicationBase.cs

@@ -76,20 +76,20 @@ public LSPCommunicationBase AddHandler(IJsonHandler handler)
         return this;
     }
 
-    public Task SendNotification(NotificationMessage notification)
+    public virtual Task SendNotification(NotificationMessage notification)
     {
         Writer.WriteNotification(notification);
         return Task.CompletedTask;
     }
 
-    public async Task<JsonDocument?> SendRequest(string method, JsonDocument? @param, CancellationToken token)
+    public virtual async Task<JsonDocument?> SendRequest(string method, JsonDocument? @param, CancellationToken token)
     {
         var request = ServerRequestManager.MakeRequest(method, @param);
         Writer.WriteRequest(request);
         return await ServerRequestManager.WaitResponse(request.Id, token).ConfigureAwait(false);
     }
 
-    public Task SendRequestNoWait(string method, JsonDocument? @param)
+    public virtual Task SendRequestNoWait(string method, JsonDocument? @param)
     {
         var request = ServerRequestManager.MakeRequest(method, @param);
         Writer.WriteRequest(request);

LanguageServer.Framework/Protocol/JsonProtocolContext.cs

@@ -54,9 +54,12 @@
 using EmmyLua.LanguageServer.Framework.Protocol.Model.TextEdit;
 using EmmyLua.LanguageServer.Framework.Protocol.Model.Union;
 using EmmyLua.LanguageServer.Framework.Protocol.Model.WorkDoneProgress;
-using FileSystemWatcher = EmmyLua.LanguageServer.Framework.Protocol.Message.WorkspaceWatchedFile.Watch.FileSystemWatcher;
+using EmmyLua.LanguageServer.Framework.Protocol.Union;
+using EmmyLua.LanguageServer.Framework.Protocol.Supplement;
+using FileSystemWatcher =
+    EmmyLua.LanguageServer.Framework.Protocol.Message.WorkspaceWatchedFile.Watch.FileSystemWatcher;
 using FoldingRangeKind = EmmyLua.LanguageServer.Framework.Protocol.Message.FoldingRange.FoldingRangeKind;
-
+using MessageType = EmmyLua.LanguageServer.Framework.Protocol.Message.Client.ShowMessage.MessageType;
 
 namespace EmmyLua.LanguageServer.Framework.Protocol;
 
@@ -308,5 +311,31 @@ namespace EmmyLua.LanguageServer.Framework.Protocol;
 [JsonSerializable(typeof(ConfigurationItem))]
 [JsonSerializable(typeof(List<ConfigurationItem>))]
 [JsonSerializable(typeof(List<LSPAny>))]
+[JsonSerializable(typeof(ShowDocumentResult))]
+[JsonSerializable(typeof(MessageActionItem))]
+[JsonSerializable(typeof(Moniker))]
+[JsonSerializable(typeof(ShowDocumentParams))]
+[JsonSerializable(typeof(ShowMessageRequestParams))]
+[JsonSerializable(typeof(MonikerParams))]
+[JsonSerializable(typeof(MonikerKind))]
+[JsonSerializable(typeof(UniquenessLevel))]
+[JsonSerializable(typeof(ProgressToken))]
+[JsonSerializable(typeof(WorkDoneProgressCancelParams))]
+[JsonSerializable(typeof(WorkDoneProgressCreateParams))]
+[JsonSerializable(typeof(TextDocumentContentParams))]
+[JsonSerializable(typeof(TextDocumentContentResult))]
+[JsonSerializable(typeof(LogTraceParams))]
+[JsonSerializable(typeof(TextDocumentContentRefreshParams))]
+[JsonSerializable(typeof(Hover))]
+[JsonSerializable(typeof(MarkedString))]
+[JsonSerializable(typeof(List<MarkedString>))]
+[JsonSerializable(typeof(LogMessageParams))]
+[JsonSerializable(typeof(MessageType))]
+[JsonSerializable(typeof(DidChangeConfigurationParams))]
+[JsonSerializable(typeof(SymbolInformation))]
+[JsonSerializable(typeof(MarkedStringsOrMarkupContent.InternalMarkedStrings))]
+[JsonSerializable(typeof(MarkedStringsOrMarkupContent.InternalMarkupContent))]
+[JsonSerializable(typeof(List<SymbolTag>))]
+[JsonSerializable(typeof(PrepareRenameResult))]
 // ReSharper disable once ClassNeverInstantiated.Global
-public partial class JsonProtocolContext: JsonSerializerContext;
+public partial class JsonProtocolContext : JsonSerializerContext;

LanguageServer.Framework/Protocol/Model/Kind/MonikerKind.cs

@@ -0,0 +1,27 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace EmmyLua.LanguageServer.Framework.Protocol.Model.Kind;
+
+[JsonConverter(typeof(MonikerKindJsonConverter))]
+public readonly record struct MonikerKind(string Kind)
+{
+    public static readonly MonikerKind Import = new("import");
+    public static readonly MonikerKind Export = new("export");
+    public static readonly MonikerKind Local = new("local");
+    public string Kind { get; } = Kind;
+}
+
+public class MonikerKindJsonConverter : JsonConverter<MonikerKind>
+{
+    public override MonikerKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        var value = reader.GetString();
+        return new MonikerKind(value!);
+    }
+
+    public override void Write(Utf8JsonWriter writer, MonikerKind value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.Kind);
+    }
+}

LanguageServer.Framework/Protocol/Model/Kind/UniquenessLevel.cs

@@ -0,0 +1,29 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace EmmyLua.LanguageServer.Framework.Protocol.Model.Kind;
+
+[JsonConverter(typeof(UniquenessLevelJsonConverter))]
+public readonly record struct UniquenessLevel(string Level)
+{
+    public static readonly UniquenessLevel Document = new("document");
+    public static readonly UniquenessLevel Project = new("project");
+    public static readonly UniquenessLevel Group = new("group");
+    public static readonly UniquenessLevel Scheme = new("scheme");
+    public static readonly UniquenessLevel Global = new("global");
+    public string Level { get; } = Level;
+}
+
+public class UniquenessLevelJsonConverter : JsonConverter<UniquenessLevel>
+{
+    public override UniquenessLevel Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        var value = reader.GetString();
+        return new UniquenessLevel(value!);
+    }
+
+    public override void Write(Utf8JsonWriter writer, UniquenessLevel value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.Level);
+    }
+}

LanguageServer.Framework/Protocol/Model/Union/MarkedStringsOrMarkupContent.cs

@@ -0,0 +1,53 @@
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
+using EmmyLua.LanguageServer.Framework.Protocol.Model.Markup;
+using EmmyLua.LanguageServer.Framework.Protocol.Supplement;
+
+namespace EmmyLua.LanguageServer.Framework.Protocol.Union;
+
+[JsonConverter(typeof(MarkedStringsOrMarkupContentJsonConverter))]
+public abstract record MarkedStringsOrMarkupContent
+{
+    public sealed record InternalMarkedStrings(List<MarkedString>? MarkedStrings) : MarkedStringsOrMarkupContent;
+
+    public sealed record InternalMarkupContent(MarkupContent? Content) : MarkedStringsOrMarkupContent;
+}
+
+public class MarkedStringsOrMarkupContentJsonConverter : JsonConverter<MarkedStringsOrMarkupContent>
+{
+    public override MarkedStringsOrMarkupContent? Read(ref Utf8JsonReader reader, Type typeToConvert,
+        JsonSerializerOptions options)
+    {
+        var jsonNode = JsonNode.Parse(ref reader);
+        if (reader.TokenType == JsonTokenType.StartObject)
+        {
+            if (jsonNode?["language"] is not null && jsonNode.Deserialize<MarkedString>(options) is { } markedString)
+                return new MarkedStringsOrMarkupContent.InternalMarkedStrings([markedString]);
+
+            return new MarkedStringsOrMarkupContent.InternalMarkupContent(jsonNode.Deserialize<MarkupContent>(options));
+        }
+
+        if (reader.TokenType == JsonTokenType.StartArray)
+
+            return new MarkedStringsOrMarkupContent.InternalMarkedStrings(jsonNode.Deserialize<List<MarkedString>>(options));
+
+
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            return new MarkedStringsOrMarkupContent.InternalMarkedStrings([
+                new MarkedString() { Value = reader.GetString() ?? string.Empty }
+            ]);
+        }
+
+        return null;
+    }
+
+    public override void Write(Utf8JsonWriter writer, MarkedStringsOrMarkupContent value, JsonSerializerOptions options)
+    {
+        if (value is MarkedStringsOrMarkupContent.InternalMarkedStrings markedStrings)
+            writer.WriteRawValue(JsonSerializer.Serialize(markedStrings.MarkedStrings, options));
+        if (value is MarkedStringsOrMarkupContent.InternalMarkupContent markedContent)
+            writer.WriteRawValue(JsonSerializer.Serialize(markedContent.Content, options));
+    }
+}

LanguageServer.Framework/Protocol/Supplement/DidChangeConfigurationParams.cs

@@ -0,0 +1,15 @@
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
+using EmmyLua.LanguageServer.Framework.Protocol.Model;
+
+namespace EmmyLua.LanguageServer.Framework.Protocol.Supplement;
+
+public record DidChangeConfigurationParams
+{
+    /// <summary>
+    /// The actual changed settings
+    /// </summary>
+    ///
+    [JsonPropertyName("settings")]
+    public LSPAny? Settings { get; init; }
+}

LanguageServer.Framework/Protocol/Supplement/Hover.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using EmmyLua.LanguageServer.Framework.Protocol.Model;
+using EmmyLua.LanguageServer.Framework.Protocol.Model.Markup;
+using EmmyLua.LanguageServer.Framework.Protocol.Union;
+
+namespace EmmyLua.LanguageServer.Framework.Protocol.Supplement;
+
+public record Hover
+{
+    [JsonPropertyName("contents")] public required MarkedStringsOrMarkupContent Contents { get; init; }
+    [JsonPropertyName("range")] public DocumentRange? Range { get; init; }
+}

LanguageServer.Framework/Protocol/Supplement/LogMessageParams.cs

@@ -0,0 +1,19 @@
+using System.Text.Json.Serialization;
+using EmmyLua.LanguageServer.Framework.Protocol.Message.Client.ShowMessage;
+
+namespace EmmyLua.LanguageServer.Framework.Protocol.Supplement;
+
+public record LogMessageParams
+{
+    /// <summary>
+    /// The message type. See {@link MessageType}
+    /// </summary>
+    [JsonPropertyName("type")]
+    public MessageType Type { get; init; }
+
+    /// <summary>
+    /// The actual message
+    /// </summary>
+    [JsonPropertyName("message")]
+    public required string Message { get; init; }
+}

LanguageServer.Framework/Protocol/Supplement/LogTraceParams.cs

@@ -0,0 +1,9 @@
+using System.Text.Json.Serialization;
+
+namespace EmmyLua.LanguageServer.Framework.Protocol.Supplement;
+
+public class LogTraceParams
+{
+    [JsonPropertyName("message")] public required string Message { get; init; }
+    [JsonPropertyName("verbose")] public string? Verbose { get; init; }
+}

LanguageServer.Framework/Protocol/Supplement/MarkedString.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace EmmyLua.LanguageServer.Framework.Protocol.Supplement;
+
+[JsonConverter(typeof(MarkedStringJsonConverter))]
+public class MarkedString
+{
+    [JsonPropertyName("language")] public string? Language { get; init; }
+
+    [JsonPropertyName("value")] public required string Value { get; init; }
+}
+
+public class MarkedStringJsonConverter : JsonConverter<MarkedString>
+{
+    public override MarkedString? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        switch (reader.TokenType)
+        {
+            case JsonTokenType.String:
+                return new MarkedString { Value = reader.GetString() ?? string.Empty };
+
+            case JsonTokenType.StartObject:
+                string? language = null;
+                string? value = null;
+
+                while (reader.Read() && reader.TokenType != JsonTokenType.EndObject)
+                {
+                    if (reader.TokenType == JsonTokenType.PropertyName)
+                    {
+                        var propName = reader.GetString();
+                        reader.Read(); // Move to value
+
+                        switch (propName)
+                        {
+                            case "language":
+                                language = reader.GetString();
+                                break;
+                            case "value":
+                                value = reader.GetString();
+                                break;
+                        }
+                    }
+                }
+
+                return new MarkedString
+                {
+                    Language = language,
+                    Value = value ?? string.Empty
+                };
+
+            default:
+                return new MarkedString { Value = string.Empty };
+        }
+    }
+
+    public override void Write(Utf8JsonWriter writer, MarkedString value, JsonSerializerOptions options)
+    {
+        if (string.IsNullOrWhiteSpace(value.Language))
+        {
+            writer.WriteStringValue(value.Value);
+        }
+        else
+        {
+            writer.WriteStartObject();
+            writer.WriteString("language", value.Language);
+            writer.WriteString("value", value.Value);
+            writer.WriteEndObject();
+        }
+    }
+}

LanguageServer.Framework/Protocol/Supplement/MessageActionItem.cs

@@ -0,0 +1,8 @@
+using System.Text.Json.Serialization;
+
+namespace EmmyLua.LanguageServer.Framework.Protocol.Supplement;
+
+public record MessageActionItem
+{
+    [JsonPropertyName("title")] public required string Title { get; init; }
+}

LanguageServer.Framework/Protocol/Supplement/MessageType.cs

@@ -0,0 +1,24 @@
+namespace EmmyLua.LanguageServer.Framework.Protocol.Supplement;
+
+public enum MessageType
+{
+    /// <summary>
+    /// An error message.
+    /// </summary>
+    Error = 1,
+
+    /// <summary>
+    /// A warning message.
+    /// </summary>
+    Warning = 2,
+
+    /// <summary>
+    /// An information message.
+    /// </summary>
+    Info = 3,
+
+    /// <summary>
+    /// A log message.
+    /// </summary>
+    Log = 4,
+}

LanguageServer.Framework/Protocol/Supplement/Moniker.cs

@@ -0,0 +1,33 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using EmmyLua.LanguageServer.Framework.Protocol.Model.Kind;
+
+namespace EmmyLua.LanguageServer.Framework.Protocol.Supplement;
+
+public class Moniker
+{
+    /// <summary>
+    /// The scheme of the moniker. For example tsc or .Net
+    /// </summary>
+    [JsonPropertyName("scheme")]
+    public required string Scheme { get; init; }
+
+    /// <summary>
+    /// The identifier of the moniker. The value is opaque in LSIF however
+    /// schema owners are allowed to define the structure if they want.
+    /// </summary>
+    [JsonPropertyName("identifier")]
+    public required string Identifier { get; init; }
+
+    /// <summary>
+    /// The scope in which the moniker is unique
+    /// </summary>
+    [JsonPropertyName("unique")]
+    public required UniquenessLevel Unique { get; init; }
+
+    /// <summary>
+    /// The moniker kind if known.
+    /// </summary>
+    [JsonPropertyName("kind")]
+    public MonikerKind Kind { get; init; }
+}