Step into LSP 3.x.

Author: CXuesong

LanguageServer.VsCode/Contracts/InitializationRequest.cs

@@ -136,13 +136,13 @@ public class TextDocumentCapability
         /// The server provides hover support.
         /// </summary>
         [JsonProperty]
-        public DynamicClientCapability Hover { get; set; }
+        public TextDocumentHoverCapability Hover { get; set; }
 
         /// <summary>
         /// The server provides signature help support.
         /// </summary>
         [JsonProperty]
-        public DynamicClientCapability SignatureHelp { get; set; }
+        public TextDocumentSignatureHelpCapability SignatureHelp { get; set; }
 
         /// <summary>
         /// The server provides goto definition support.
@@ -237,12 +237,26 @@ public class TextDocumentSynchronizationCapability : DynamicClientCapability
 
     public class TextDocumentCompletionCapability : DynamicClientCapability
     {
+
+        /// <summary>
+        /// The client supports the following <see cref="Contracts.CompletionItem"/> specific capabilities.
+        /// </summary>
         [JsonProperty]
-        public TextDocumentCompletionCapabilityItem CompletionItem { get; set; }
+        public TextDocumentCompletionItemCapability CompletionItem { get; set; }
+
+        [JsonProperty]
+        public TextDocumentCompletionItemKindCapability CompletionItemKind { get; set; }
+
+        /// <summary>
+        /// The client supports to send additional context information for a
+        /// <c>textDocument/completion</c> request.
+        /// </summary>
+        [JsonProperty]
+        public bool ContextSupport { get; set; }
     }
 
     [JsonObject(MemberSerialization.OptIn)]
-    public class TextDocumentCompletionCapabilityItem
+    public class TextDocumentCompletionItemCapability
     {
         /// <summary>
         /// Client supports snippets as insert text.
@@ -255,5 +269,74 @@ public class TextDocumentCompletionCapabilityItem
         /// </remarks>
         [JsonProperty]
         public bool SnippetSupport { get; set; }
+
+        /// <summary>Client supports commit <see cref="CompletionItem.CommitCharacters"/> on a completion item.</summary>
+        [JsonProperty]
+        public bool CommitCharactersSupport { get; set; }
+
+        /// <summary>
+        /// Client supports the follow content formats for the documentation
+        /// property.The order describes the preferred format of the client.
+        /// </summary>
+        [JsonProperty]
+        public IList<MarkupKind> DocumentationFormat { get; set; }
+    }
+
+    [JsonObject(MemberSerialization.OptIn)]
+    public class TextDocumentCompletionItemKindCapability
+    {
+        /// <summary>
+        /// The completion item kind values the client supports. When this
+        /// property exists the client also guarantees that it will
+        /// handle values outside its set gracefully and falls back
+        /// to a default value when unknown.
+        /// </summary>
+        /// <remarks>
+        /// If this property is not present, the client only supports
+        /// the completion items kinds from `Text` to `Reference` as defined in
+        /// the initial version of the protocol.
+        /// </remarks>
+        [JsonProperty]
+        public IEnumerable<CompletionItemKind> ValueSet { get; set; }
+
     }
+
+    /// <summary>
+    /// Capabilities specific to the `textDocument/hover`.
+    /// </summary>
+    [JsonObject(MemberSerialization.OptIn)]
+    public class TextDocumentHoverCapability : DynamicClientCapability
+    {
+        /// <summary>
+        /// Client supports the follow content formats for the content property.
+        /// The order describes the preferred format of the client.
+        /// </summary>
+        [JsonProperty]
+        public IList<MarkupKind> ContentFormat { get; set; }
+    }
+
+    /// <summary>
+    /// Capabilities specific to the `textDocument/signatureHelp`.
+    /// </summary>
+    [JsonObject(MemberSerialization.OptIn)]
+    public class TextDocumentSignatureHelpCapability : DynamicClientCapability
+    {
+        /// <summary>
+        /// The client supports the following <see cref="SignatureInformation"/> specific properties.
+        /// </summary>
+        [JsonProperty]
+        public TextDocumentSignatureInformationCapability SignatureInformation { get; set; }
+    }
+    
+    [JsonObject(MemberSerialization.OptIn)]
+    public class TextDocumentSignatureInformationCapability
+    {
+        /// <summary>
+        /// Client supports the follow content formats for the documentation
+        /// property. The order describes the preferred format of the client.
+        /// </summary>
+        [JsonProperty]
+        public IList<MarkupKind> DocumentationFormat { get; set; }
+    }
+
 }

LanguageServer.VsCode/Contracts/MarkupContent.cs

@@ -0,0 +1,136 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Newtonsoft.Json;
+
+namespace LanguageServer.VsCode.Contracts
+{
+    /// <summary>
+    ///  A `MarkupContent` literal represents a string value which content is interpreted base on its
+    ///  kind flag. Currently the protocol supports <c>plaintext</c> and <c>markdown</c> as markup kinds.
+    ///  If the kind is `markdown` then the value can contain fenced code blocks like in GitHub issues.
+    ///  See <a href="https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting">https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting</a>.
+    /// </summary>
+    [JsonObject]
+    public class MarkupContent
+    {
+
+        /// <exception cref="ArgumentNullException"><paramref name="kind"/> is <c>null</c>.</exception>
+        public MarkupContent(MarkupKind kind, string value)
+        {
+            Kind = kind ?? throw new ArgumentNullException(nameof(kind));
+            Value = value;
+        }
+
+        /// <summary>The type of the Markup.</summary>
+        [JsonProperty]
+        public MarkupKind Kind { get; }
+
+        /// <summary>The content itself.</summary>
+        [JsonProperty]
+        public string Value { get; }
+
+    }
+
+    /// <summary>
+    /// Describes the content type that a client supports in various
+    /// result literals like <see cref="Hover"/>, <see cref="ParameterInformation"/> or <see cref="CompletionItem"/>.
+    /// </summary>
+    /// <remarks>
+    /// Please note that <see cref="MarkupKind"/> must not start with a `$`. This kinds
+    /// are reserved for internal usage.
+    /// </remarks>
+    [JsonConverter(typeof(MarkupKindJsonConverter))]
+    public sealed class MarkupKind : IEquatable<MarkupKind>
+    {
+
+        /// <summary>
+        /// Plain text is supported as a content format.
+        /// </summary>
+        public static MarkupKind PlainText{ get; } = new MarkupKind("plaintext");
+
+        /// <summary>
+        /// Markdown is supported as a content format.
+        /// </summary>
+        public static MarkupKind Markdown { get; } = new MarkupKind("markdown");
+
+        public MarkupKind(string value)
+        {
+            Value = value;
+        }
+
+        /// <summary>
+        /// Gets the string representation of the markup kind.
+        /// </summary>
+        public string Value { get; }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return Value;
+        }
+
+        /// <inheritdoc />
+        public bool Equals(MarkupKind other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return string.Equals(Value, other.Value);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            return obj is MarkupKind && Equals((MarkupKind)obj);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return Value.GetHashCode();
+        }
+
+        public static bool operator ==(MarkupKind left, MarkupKind right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(MarkupKind left, MarkupKind right)
+        {
+            return !Equals(left, right);
+        }
+    }
+
+    /// <summary>
+    /// Used to convert <see cref="MarkupKind"/> into JSON.
+    /// </summary>
+    public class MarkupKindJsonConverter : JsonConverter
+    {
+
+        /// <inheritdoc />
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            var v = (MarkupKind)value;
+            writer.WriteValue(v);
+        }
+
+        /// <inheritdoc />
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            var v = reader.ReadAsString();
+            if (v == null) return null;
+            if (v == "plaintext") return MarkupKind.PlainText;
+            if (v == "markdown") return MarkupKind.Markdown;
+            return new MarkupKind(v);
+        }
+
+        /// <inheritdoc />
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType == typeof(MarkupKind);
+        }
+    }
+
+}