language_server-protocol 3.17.0.5 → 3.18.0.0.pre.1

data/lib/language_server/protocol/interface/client_symbol_resolve_options.rb

@@ -0,0 +1,37 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # @since 3.18.0
+      #
+      class ClientSymbolResolveOptions
+        def initialize(properties:)
+          @attributes = {}
+
+          @attributes[:properties] = properties
+
+          @attributes.freeze
+        end
+
+        #
+        # The properties that a client can resolve lazily. Usually
+        # `location.range`
+        #
+        # @return [string[]]
+        def properties
+          attributes.fetch(:properties)
+        end
+
+        attr_reader :attributes
+
+        def to_hash
+          attributes
+        end
+
+        def to_json(*args)
+          to_hash.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interface/client_symbol_tag_options.rb

@@ -0,0 +1,36 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # @since 3.18.0
+      #
+      class ClientSymbolTagOptions
+        def initialize(value_set:)
+          @attributes = {}
+
+          @attributes[:valueSet] = value_set
+
+          @attributes.freeze
+        end
+
+        #
+        # The tags supported by the client.
+        #
+        # @return [SymbolTag[]]
+        def value_set
+          attributes.fetch(:valueSet)
+        end
+
+        attr_reader :attributes
+
+        def to_hash
+          attributes
+        end
+
+        def to_json(*args)
+          to_hash.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interface/code_action.rb

@@ -2,24 +2,24 @@ module LanguageServer
   module Protocol
     module Interface
       #
-      # A code action represents a change that can be performed in code, e.g. to fix
-      # a problem or to refactor code.
+      # A code action represents a change that can be performed in code, e.g. to fix a problem or
+      # to refactor code.
       #
-      # A CodeAction must set either `edit` and/or a `command`. If both are supplied,
-      # the `edit` is applied first, then the `command` is executed.
+      # A CodeAction must set either `edit` and/or a `command`. If both are supplied, the `edit` is applied first, then the `command` is executed.
       #
       class CodeAction
-        def initialize(title:, kind: nil, diagnostics: nil, is_preferred: nil, disabled: nil, edit: nil, command: nil, data: nil)
+        def initialize(title:, kind: nil, diagnostics: nil, is_preferred: nil, disabled: nil, edit: nil, command: nil, data: nil, tags: nil)
           @attributes = {}
 
           @attributes[:title] = title
-          @attributes[:kind] = kind if kind
-          @attributes[:diagnostics] = diagnostics if diagnostics
-          @attributes[:isPreferred] = is_preferred if is_preferred
-          @attributes[:disabled] = disabled if disabled
-          @attributes[:edit] = edit if edit
-          @attributes[:command] = command if command
-          @attributes[:data] = data if data
+          @attributes[:kind] = kind unless kind.nil?
+          @attributes[:diagnostics] = diagnostics unless diagnostics.nil?
+          @attributes[:isPreferred] = is_preferred unless is_preferred.nil?
+          @attributes[:disabled] = disabled unless disabled.nil?
+          @attributes[:edit] = edit unless edit.nil?
+          @attributes[:command] = command unless command.nil?
+          @attributes[:data] = data unless data.nil?
+          @attributes[:tags] = tags unless tags.nil?
 
           @attributes.freeze
         end
@@ -37,7 +37,7 @@ module LanguageServer
         #
         # Used to filter code actions.
         #
-        # @return [string]
+        # @return [CodeActionKind]
         def kind
           attributes.fetch(:kind)
         end
@@ -51,12 +51,13 @@ module LanguageServer
         end
 
         #
-        # Marks this as a preferred action. Preferred actions are used by the
-        # `auto fix` command and can be targeted by keybindings.
+        # Marks this as a preferred action. Preferred actions are used by the `auto fix` command and can be targeted
+        # by keybindings.
+        #
+        # A quick fix should be marked preferred if it properly addresses the underlying error.
+        # A refactoring should be marked preferred if it is the most reasonable choice of actions to take.
         #
-        # A quick fix should be marked preferred if it properly addresses the
-        # underlying error. A refactoring should be marked preferred if it is the
-        # most reasonable choice of actions to take.
+        # @since 3.15.0
         #
         # @return [boolean]
         def is_preferred
@@ -66,21 +67,21 @@ module LanguageServer
         #
         # Marks that the code action cannot currently be applied.
         #
-        # Clients should follow the following guidelines regarding disabled code
-        # actions:
+        # Clients should follow the following guidelines regarding disabled code actions:
+        #
+        #   - Disabled code actions are not shown in automatic [lightbulbs](https://code.visualstudio.com/docs/editor/editingevolved#_code-action)
+        #     code action menus.
         #
-        # - Disabled code actions are not shown in automatic lightbulbs code
-        # action menus.
+        #   - Disabled actions are shown as faded out in the code action menu when the user requests a more specific type
+        #     of code action, such as refactorings.
         #
-        # - Disabled actions are shown as faded out in the code action menu when
-        # the user request a more specific type of code action, such as
-        # refactorings.
+        #   - If the user has a [keybinding](https://code.visualstudio.com/docs/editor/refactoring#_keybindings-for-code-actions)
+        #     that auto applies a code action and only disabled code actions are returned, the client should show the user an
+        #     error message with `reason` in the editor.
         #
-        # - If the user has a keybinding that auto applies a code action and only
-        # a disabled code actions are returned, the client should show the user
-        # an error message with `reason` in the editor.
+        # @since 3.16.0
         #
-        # @return [{ reason: string; }]
+        # @return [CodeActionDisabled]
         def disabled
           attributes.fetch(:disabled)
         end
@@ -107,11 +108,23 @@ module LanguageServer
         # A data entry field that is preserved on a code action between
         # a `textDocument/codeAction` and a `codeAction/resolve` request.
         #
+        # @since 3.16.0
+        #
         # @return [LSPAny]
         def data
           attributes.fetch(:data)
         end
 
+        #
+        # Tags for this code action.
+        #
+        # @since 3.18.0
+        #
+        # @return [CodeActionTag[]]
+        def tags
+          attributes.fetch(:tags)
+        end
+
         attr_reader :attributes
 
         def to_hash

data/lib/language_server/protocol/interface/code_action_client_capabilities.rb

@@ -1,17 +1,22 @@
 module LanguageServer
   module Protocol
     module Interface
+      #
+      # The Client Capabilities of a {@link CodeActionRequest}.
+      #
       class CodeActionClientCapabilities
-        def initialize(dynamic_registration: nil, code_action_literal_support: nil, is_preferred_support: nil, disabled_support: nil, data_support: nil, resolve_support: nil, honors_change_annotations: nil)
+        def initialize(dynamic_registration: nil, code_action_literal_support: nil, is_preferred_support: nil, disabled_support: nil, data_support: nil, resolve_support: nil, honors_change_annotations: nil, documentation_support: nil, tag_support: nil)
           @attributes = {}
 
-          @attributes[:dynamicRegistration] = dynamic_registration if dynamic_registration
-          @attributes[:codeActionLiteralSupport] = code_action_literal_support if code_action_literal_support
-          @attributes[:isPreferredSupport] = is_preferred_support if is_preferred_support
-          @attributes[:disabledSupport] = disabled_support if disabled_support
-          @attributes[:dataSupport] = data_support if data_support
-          @attributes[:resolveSupport] = resolve_support if resolve_support
-          @attributes[:honorsChangeAnnotations] = honors_change_annotations if honors_change_annotations
+          @attributes[:dynamicRegistration] = dynamic_registration unless dynamic_registration.nil?
+          @attributes[:codeActionLiteralSupport] = code_action_literal_support unless code_action_literal_support.nil?
+          @attributes[:isPreferredSupport] = is_preferred_support unless is_preferred_support.nil?
+          @attributes[:disabledSupport] = disabled_support unless disabled_support.nil?
+          @attributes[:dataSupport] = data_support unless data_support.nil?
+          @attributes[:resolveSupport] = resolve_support unless resolve_support.nil?
+          @attributes[:honorsChangeAnnotations] = honors_change_annotations unless honors_change_annotations.nil?
+          @attributes[:documentationSupport] = documentation_support unless documentation_support.nil?
+          @attributes[:tagSupport] = tag_support unless tag_support.nil?
 
           @attributes.freeze
         end
@@ -25,10 +30,13 @@ module LanguageServer
         end
 
         #
-        # The client supports code action literals as a valid
-        # response of the `textDocument/codeAction` request.
+        # The client support code action literals of type `CodeAction` as a valid
+        # response of the `textDocument/codeAction` request. If the property is not
+        # set the request can only return `Command` literals.
         #
-        # @return [{ codeActionKind: { valueSet: string[]; }; }]
+        # @since 3.8.0
+        #
+        # @return [ClientCodeActionLiteralOptions]
         def code_action_literal_support
           attributes.fetch(:codeActionLiteralSupport)
         end
@@ -36,6 +44,8 @@ module LanguageServer
         #
         # Whether code action supports the `isPreferred` property.
         #
+        # @since 3.15.0
+        #
         # @return [boolean]
         def is_preferred_support
           attributes.fetch(:isPreferredSupport)
@@ -44,6 +54,8 @@ module LanguageServer
         #
         # Whether code action supports the `disabled` property.
         #
+        # @since 3.16.0
+        #
         # @return [boolean]
         def disabled_support
           attributes.fetch(:disabledSupport)
@@ -54,6 +66,8 @@ module LanguageServer
         # preserved between a `textDocument/codeAction` and a
         # `codeAction/resolve` request.
         #
+        # @since 3.16.0
+        #
         # @return [boolean]
         def data_support
           attributes.fetch(:dataSupport)
@@ -63,7 +77,9 @@ module LanguageServer
         # Whether the client supports resolving additional code action
         # properties via a separate `codeAction/resolve` request.
         #
-        # @return [{ properties: string[]; }]
+        # @since 3.16.0
+        #
+        # @return [ClientCodeActionResolveOptions]
         def resolve_support
           attributes.fetch(:resolveSupport)
         end
@@ -75,11 +91,35 @@ module LanguageServer
         # the workspace edit in the user interface and asking
         # for confirmation.
         #
+        # @since 3.16.0
+        #
         # @return [boolean]
         def honors_change_annotations
           attributes.fetch(:honorsChangeAnnotations)
         end
 
+        #
+        # Whether the client supports documentation for a class of
+        # code actions.
+        #
+        # @since 3.18.0
+        #
+        # @return [boolean]
+        def documentation_support
+          attributes.fetch(:documentationSupport)
+        end
+
+        #
+        # Client supports the tag property on a code action. Clients
+        # supporting tags have to handle unknown tags gracefully.
+        #
+        # @since 3.18.0
+        #
+        # @return [CodeActionTagOptions]
+        def tag_support
+          attributes.fetch(:tagSupport)
+        end
+
         attr_reader :attributes
 
         def to_hash

data/lib/language_server/protocol/interface/code_action_context.rb

@@ -3,25 +3,24 @@ module LanguageServer
     module Interface
       #
       # Contains additional diagnostic information about the context in which
-      # a code action is run.
+      # a {@link CodeActionProvider.provideCodeActions code action} is run.
       #
       class CodeActionContext
         def initialize(diagnostics:, only: nil, trigger_kind: nil)
           @attributes = {}
 
           @attributes[:diagnostics] = diagnostics
-          @attributes[:only] = only if only
-          @attributes[:triggerKind] = trigger_kind if trigger_kind
+          @attributes[:only] = only unless only.nil?
+          @attributes[:triggerKind] = trigger_kind unless trigger_kind.nil?
 
           @attributes.freeze
         end
 
         #
-        # An array of diagnostics known on the client side overlapping the range
-        # provided to the `textDocument/codeAction` request. They are provided so
-        # that the server knows which errors are currently presented to the user
-        # for the given range. There is no guarantee that these accurately reflect
-        # the error state of the resource. The primary parameter
+        # An array of diagnostics known on the client side overlapping the range provided to the
+        # `textDocument/codeAction` request. They are provided so that the server knows which
+        # errors are currently presented to the user for the given range. There is no guarantee
+        # that these accurately reflect the error state of the resource. The primary parameter
         # to compute code actions is the provided range.
         #
         # @return [Diagnostic[]]
@@ -32,10 +31,10 @@ module LanguageServer
         #
         # Requested kind of actions to return.
         #
-        # Actions not of this kind are filtered out by the client before being
-        # shown. So servers can omit computing them.
+        # Actions not of this kind are filtered out by the client before being shown. So servers
+        # can omit computing them.
         #
-        # @return [string[]]
+        # @return [CodeActionKind[]]
         def only
           attributes.fetch(:only)
         end
@@ -43,6 +42,8 @@ module LanguageServer
         #
         # The reason why code actions were requested.
         #
+        # @since 3.17.0
+        #
         # @return [CodeActionTriggerKind]
         def trigger_kind
           attributes.fetch(:triggerKind)

data/lib/language_server/protocol/interface/code_action_disabled.rb

@@ -0,0 +1,40 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Captures why the code action is currently disabled.
+      #
+      # @since 3.18.0
+      #
+      class CodeActionDisabled
+        def initialize(reason:)
+          @attributes = {}
+
+          @attributes[:reason] = reason
+
+          @attributes.freeze
+        end
+
+        #
+        # Human readable description of why the code action is currently disabled.
+        #
+        # This is displayed in the code actions UI.
+        #
+        # @return [string]
+        def reason
+          attributes.fetch(:reason)
+        end
+
+        attr_reader :attributes
+
+        def to_hash
+          attributes
+        end
+
+        def to_json(*args)
+          to_hash.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interface/code_action_kind_documentation.rb

@@ -0,0 +1,53 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Documentation for a class of code actions.
+      #
+      # @since 3.18.0
+      #
+      class CodeActionKindDocumentation
+        def initialize(kind:, command:)
+          @attributes = {}
+
+          @attributes[:kind] = kind
+          @attributes[:command] = command
+
+          @attributes.freeze
+        end
+
+        #
+        # The kind of the code action being documented.
+        #
+        # If the kind is generic, such as `CodeActionKind.Refactor`, the documentation will be shown whenever any
+        # refactorings are returned. If the kind if more specific, such as `CodeActionKind.RefactorExtract`, the
+        # documentation will only be shown when extract refactoring code actions are returned.
+        #
+        # @return [CodeActionKind]
+        def kind
+          attributes.fetch(:kind)
+        end
+
+        #
+        # Command that is ued to display the documentation to the user.
+        #
+        # The title of this documentation code action is taken from {@linkcode Command.title}
+        #
+        # @return [Command]
+        def command
+          attributes.fetch(:command)
+        end
+
+        attr_reader :attributes
+
+        def to_hash
+          attributes
+        end
+
+        def to_json(*args)
+          to_hash.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interface/code_action_options.rb

@@ -1,42 +1,69 @@
 module LanguageServer
   module Protocol
     module Interface
+      #
+      # Provider options for a {@link CodeActionRequest}.
+      #
       class CodeActionOptions
-        def initialize(work_done_progress: nil, code_action_kinds: nil, resolve_provider: nil)
+        def initialize(code_action_kinds: nil, documentation: nil, resolve_provider: nil, work_done_progress: nil)
           @attributes = {}
 
-          @attributes[:workDoneProgress] = work_done_progress if work_done_progress
-          @attributes[:codeActionKinds] = code_action_kinds if code_action_kinds
-          @attributes[:resolveProvider] = resolve_provider if resolve_provider
+          @attributes[:codeActionKinds] = code_action_kinds unless code_action_kinds.nil?
+          @attributes[:documentation] = documentation unless documentation.nil?
+          @attributes[:resolveProvider] = resolve_provider unless resolve_provider.nil?
+          @attributes[:workDoneProgress] = work_done_progress unless work_done_progress.nil?
 
           @attributes.freeze
         end
 
-        # @return [boolean]
-        def work_done_progress
-          attributes.fetch(:workDoneProgress)
-        end
-
         #
         # CodeActionKinds that this server may return.
         #
-        # The list of kinds may be generic, such as `CodeActionKind.Refactor`,
-        # or the server may list out every specific kind they provide.
+        # The list of kinds may be generic, such as `CodeActionKind.Refactor`, or the server
+        # may list out every specific kind they provide.
         #
-        # @return [string[]]
+        # @return [CodeActionKind[]]
         def code_action_kinds
           attributes.fetch(:codeActionKinds)
         end
 
+        #
+        # Static documentation for a class of code actions.
+        #
+        # Documentation from the provider should be shown in the code actions menu if either:
+        #
+        # - Code actions of `kind` are requested by the editor. In this case, the editor will show the documentation that
+        #   most closely matches the requested code action kind. For example, if a provider has documentation for
+        #   both `Refactor` and `RefactorExtract`, when the user requests code actions for `RefactorExtract`,
+        #   the editor will use the documentation for `RefactorExtract` instead of the documentation for `Refactor`.
+        #
+        # - Any code actions of `kind` are returned by the provider.
+        #
+        # At most one documentation entry should be shown per provider.
+        #
+        # @since 3.18.0
+        #
+        # @return [CodeActionKindDocumentation[]]
+        def documentation
+          attributes.fetch(:documentation)
+        end
+
         #
         # The server provides support to resolve additional
         # information for a code action.
         #
+        # @since 3.16.0
+        #
         # @return [boolean]
         def resolve_provider
           attributes.fetch(:resolveProvider)
         end
 
+        # @return [boolean]
+        def work_done_progress
+          attributes.fetch(:workDoneProgress)
+        end
+
         attr_reader :attributes
 
         def to_hash

data/lib/language_server/protocol/interface/code_action_params.rb

@@ -2,38 +2,21 @@ module LanguageServer
   module Protocol
     module Interface
       #
-      # Params for the CodeActionRequest
+      # The parameters of a {@link CodeActionRequest}.
       #
       class CodeActionParams
-        def initialize(work_done_token: nil, partial_result_token: nil, text_document:, range:, context:)
+        def initialize(text_document:, range:, context:, work_done_token: nil, partial_result_token: nil)
           @attributes = {}
 
-          @attributes[:workDoneToken] = work_done_token if work_done_token
-          @attributes[:partialResultToken] = partial_result_token if partial_result_token
           @attributes[:textDocument] = text_document
           @attributes[:range] = range
           @attributes[:context] = context
+          @attributes[:workDoneToken] = work_done_token unless work_done_token.nil?
+          @attributes[:partialResultToken] = partial_result_token unless partial_result_token.nil?
 
           @attributes.freeze
         end
 
-        #
-        # An optional token that a server can use to report work done progress.
-        #
-        # @return [ProgressToken]
-        def work_done_token
-          attributes.fetch(:workDoneToken)
-        end
-
-        #
-        # An optional token that a server can use to report partial results (e.g.
-        # streaming) to the client.
-        #
-        # @return [ProgressToken]
-        def partial_result_token
-          attributes.fetch(:partialResultToken)
-        end
-
         #
         # The document in which the command was invoked.
         #
@@ -58,6 +41,23 @@ module LanguageServer
           attributes.fetch(:context)
         end
 
+        #
+        # An optional token that a server can use to report work done progress.
+        #
+        # @return [ProgressToken]
+        def work_done_token
+          attributes.fetch(:workDoneToken)
+        end
+
+        #
+        # An optional token that a server can use to report partial results (e.g. streaming) to
+        # the client.
+        #
+        # @return [ProgressToken]
+        def partial_result_token
+          attributes.fetch(:partialResultToken)
+        end
+
         attr_reader :attributes
 
         def to_hash