language_server-protocol 3.16.0.1 → 3.17.0.0

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

@@ -2,38 +2,31 @@ module LanguageServer
   module Protocol
     module Interface
       class InitializeParams
-        def initialize(work_done_token: nil, process_id:, client_info: nil, locale: nil, root_path: nil, root_uri:, initialization_options: nil, capabilities:, trace: nil, workspace_folders: nil)
+        def initialize(process_id:, client_info: nil, locale: nil, root_path: nil, root_uri:, capabilities:, initialization_options: nil, trace: nil, work_done_token: nil, workspace_folders: nil)
           @attributes = {}
 
-          @attributes[:workDoneToken] = work_done_token if work_done_token
           @attributes[:processId] = process_id
           @attributes[:clientInfo] = client_info if client_info
           @attributes[:locale] = locale if locale
           @attributes[:rootPath] = root_path if root_path
           @attributes[:rootUri] = root_uri
-          @attributes[:initializationOptions] = initialization_options if initialization_options
           @attributes[:capabilities] = capabilities
+          @attributes[:initializationOptions] = initialization_options if initialization_options
           @attributes[:trace] = trace if trace
+          @attributes[:workDoneToken] = work_done_token if work_done_token
           @attributes[:workspaceFolders] = workspace_folders if workspace_folders
 
           @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
-
+        # The process Id of the parent process that started
+        # the server.
         #
-        # The process Id of the parent process that started the server. Is null if
-        # the process has not been started by another process. If the parent
-        # process is not alive then the server should exit (see exit notification)
-        # its process.
+        # Is `null` if the process has not been started by another process.
+        # If the parent process is not alive then the server should exit.
         #
-        # @return [number]
+        # @return [integer | null]
         def process_id
           attributes.fetch(:processId)
         end
@@ -41,7 +34,9 @@ module LanguageServer
         #
         # Information about the client
         #
-        # @return [{ name: string; version?: string; }]
+        # @since 3.15.0
+        #
+        # @return [{ name:string, version:string } | nil]
         def client_info
           attributes.fetch(:clientInfo)
         end
@@ -54,7 +49,9 @@ module LanguageServer
         # Uses IETF language tags as the value's syntax
         # (See https://en.wikipedia.org/wiki/IETF_language_tag)
         #
-        # @return [string]
+        # @since 3.16.0
+        #
+        # @return [string | nil]
         def locale
           attributes.fetch(:locale)
         end
@@ -63,7 +60,9 @@ module LanguageServer
         # The rootPath of the workspace. Is null
         # if no folder is open.
         #
-        # @return [string]
+        # @deprecated in favour of rootUri.
+        #
+        # @return [string | null]
         def root_path
           attributes.fetch(:rootPath)
         end
@@ -73,19 +72,13 @@ module LanguageServer
         # folder is open. If both `rootPath` and `rootUri` are set
         # `rootUri` wins.
         #
-        # @return [string]
+        # @deprecated in favour of workspaceFolders.
+        #
+        # @return [DocumentUri | null]
         def root_uri
           attributes.fetch(:rootUri)
         end
 
-        #
-        # User provided initialization options.
-        #
-        # @return [any]
-        def initialization_options
-          attributes.fetch(:initializationOptions)
-        end
-
         #
         # The capabilities provided by the client (editor or tool)
         #
@@ -94,21 +87,40 @@ module LanguageServer
           attributes.fetch(:capabilities)
         end
 
+        #
+        # User provided initialization options.
+        #
+        # @return [LSPAny | nil]
+        def initialization_options
+          attributes.fetch(:initializationOptions)
+        end
+
         #
         # The initial trace setting. If omitted trace is disabled ('off').
         #
-        # @return [TraceValue]
+        # @return ["off" | "messages" | "compact" | "verbose" | nil]
         def trace
           attributes.fetch(:trace)
         end
 
+        #
+        # An optional token that a server can use to report work done progress.
+        #
+        # @return [ProgressToken | nil]
+        def work_done_token
+          attributes.fetch(:workDoneToken)
+        end
+
         #
         # The workspace folders configured in the client when the server starts.
+        #
         # This property is only available if the client supports workspace folders.
         # It can be `null` if the client supports workspace folders but none are
         # configured.
         #
-        # @return [WorkspaceFolder[]]
+        # @since 3.6.0
+        #
+        # @return [WorkspaceFolder[] | null]
         def workspace_folders
           attributes.fetch(:workspaceFolders)
         end

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

@@ -1,6 +1,9 @@
 module LanguageServer
   module Protocol
     module Interface
+      #
+      # The result returned from an initialize request.
+      #
       class InitializeResult
         def initialize(capabilities:, server_info: nil)
           @attributes = {}
@@ -22,7 +25,9 @@ module LanguageServer
         #
         # Information about the server.
         #
-        # @return [{ name: string; version?: string; }]
+        # @since 3.15.0
+        #
+        # @return [{ name:string, version:string } | nil]
         def server_info
           attributes.fetch(:serverInfo)
         end

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

@@ -0,0 +1,118 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Inlay hint information.
+      #
+      # @since 3.17.0
+      #
+      class InlayHint
+        def initialize(position:, label:, kind: nil, text_edits: nil, tooltip: nil, padding_left: nil, padding_right: nil, data: nil)
+          @attributes = {}
+
+          @attributes[:position] = position
+          @attributes[:label] = label
+          @attributes[:kind] = kind if kind
+          @attributes[:textEdits] = text_edits if text_edits
+          @attributes[:tooltip] = tooltip if tooltip
+          @attributes[:paddingLeft] = padding_left if padding_left
+          @attributes[:paddingRight] = padding_right if padding_right
+          @attributes[:data] = data if data
+
+          @attributes.freeze
+        end
+
+        #
+        # The position of this hint.
+        #
+        # @return [Position]
+        def position
+          attributes.fetch(:position)
+        end
+
+        #
+        # The label of this hint. A human readable string or an array of
+        # InlayHintLabelPart label parts.
+        #
+        # *Note* that neither the string nor the label part can be empty.
+        #
+        # @return [string | InlayHintLabelPart[]]
+        def label
+          attributes.fetch(:label)
+        end
+
+        #
+        # The kind of this hint. Can be omitted in which case the client
+        # should fall back to a reasonable default.
+        #
+        # @return [InlayHintKind | nil]
+        def kind
+          attributes.fetch(:kind)
+        end
+
+        #
+        # Optional text edits that are performed when accepting this inlay hint.
+        #
+        # *Note* that edits are expected to change the document so that the inlay
+        # hint (or its nearest variant) is now part of the document and the inlay
+        # hint itself is now obsolete.
+        #
+        # @return [TextEdit[] | nil]
+        def text_edits
+          attributes.fetch(:textEdits)
+        end
+
+        #
+        # The tooltip text when you hover over this item.
+        #
+        # @return [string | MarkupContent | nil]
+        def tooltip
+          attributes.fetch(:tooltip)
+        end
+
+        #
+        # Render padding before the hint.
+        #
+        # Note: Padding should use the editor's background color, not the
+        # background color of the hint itself. That means padding can be used
+        # to visually align/separate an inlay hint.
+        #
+        # @return [boolean | nil]
+        def padding_left
+          attributes.fetch(:paddingLeft)
+        end
+
+        #
+        # Render padding after the hint.
+        #
+        # Note: Padding should use the editor's background color, not the
+        # background color of the hint itself. That means padding can be used
+        # to visually align/separate an inlay hint.
+        #
+        # @return [boolean | nil]
+        def padding_right
+          attributes.fetch(:paddingRight)
+        end
+
+        #
+        # A data entry field that is preserved on an inlay hint between
+        # a `textDocument/inlayHint` and a `inlayHint/resolve` request.
+        #
+        # @return [LSPAny | nil]
+        def data
+          attributes.fetch(:data)
+        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/inlay_hint_client_capabilities.rb

@@ -0,0 +1,48 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Inlay hint client capabilities.
+      #
+      # @since 3.17.0
+      #
+      class InlayHintClientCapabilities
+        def initialize(dynamic_registration: nil, resolve_support: nil)
+          @attributes = {}
+
+          @attributes[:dynamicRegistration] = dynamic_registration if dynamic_registration
+          @attributes[:resolveSupport] = resolve_support if resolve_support
+
+          @attributes.freeze
+        end
+
+        #
+        # Whether inlay hints support dynamic registration.
+        #
+        # @return [boolean | nil]
+        def dynamic_registration
+          attributes.fetch(:dynamicRegistration)
+        end
+
+        #
+        # Indicates which properties a client can resolve lazily on an inlay
+        # hint.
+        #
+        # @return [{ properties:string[] } | nil]
+        def resolve_support
+          attributes.fetch(:resolveSupport)
+        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/inlay_hint_label_part.rb

@@ -0,0 +1,81 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # An inlay hint label part allows for interactive and composite labels
+      # of inlay hints.
+      #
+      # @since 3.17.0
+      #
+      class InlayHintLabelPart
+        def initialize(value:, tooltip: nil, location: nil, command: nil)
+          @attributes = {}
+
+          @attributes[:value] = value
+          @attributes[:tooltip] = tooltip if tooltip
+          @attributes[:location] = location if location
+          @attributes[:command] = command if command
+
+          @attributes.freeze
+        end
+
+        #
+        # The value of this label part.
+        #
+        # @return [string]
+        def value
+          attributes.fetch(:value)
+        end
+
+        #
+        # The tooltip text when you hover over this label part. Depending on
+        # the client capability `inlayHint.resolveSupport` clients might resolve
+        # this property late using the resolve request.
+        #
+        # @return [string | MarkupContent | nil]
+        def tooltip
+          attributes.fetch(:tooltip)
+        end
+
+        #
+        # An optional source code location that represents this
+        # label part.
+        #
+        # The editor will use this location for the hover and for code navigation
+        # features: This part will become a clickable link that resolves to the
+        # definition of the symbol at the given location (not necessarily the
+        # location itself), it shows the hover that shows at the given location,
+        # and it shows a context menu with further code navigation commands.
+        #
+        # Depending on the client capability `inlayHint.resolveSupport` clients
+        # might resolve this property late using the resolve request.
+        #
+        # @return [Location | nil]
+        def location
+          attributes.fetch(:location)
+        end
+
+        #
+        # An optional command for this label part.
+        #
+        # Depending on the client capability `inlayHint.resolveSupport` clients
+        # might resolve this property late using the resolve request.
+        #
+        # @return [Command | nil]
+        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/inlay_hint_options.rb

@@ -0,0 +1,45 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Inlay hint options used during static registration.
+      #
+      # @since 3.17.0
+      #
+      class InlayHintOptions
+        def initialize(resolve_provider: nil, work_done_progress: nil)
+          @attributes = {}
+
+          @attributes[:resolveProvider] = resolve_provider if resolve_provider
+          @attributes[:workDoneProgress] = work_done_progress if work_done_progress
+
+          @attributes.freeze
+        end
+
+        #
+        # The server provides support to resolve additional
+        # information for an inlay hint item.
+        #
+        # @return [boolean | nil]
+        def resolve_provider
+          attributes.fetch(:resolveProvider)
+        end
+
+        # @return [boolean | nil]
+        def work_done_progress
+          attributes.fetch(:workDoneProgress)
+        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/inlay_hint_params.rb

@@ -0,0 +1,56 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # A parameter literal used in inlay hint requests.
+      #
+      # @since 3.17.0
+      #
+      class InlayHintParams
+        def initialize(text_document:, range:, work_done_token: nil)
+          @attributes = {}
+
+          @attributes[:textDocument] = text_document
+          @attributes[:range] = range
+          @attributes[:workDoneToken] = work_done_token if work_done_token
+
+          @attributes.freeze
+        end
+
+        #
+        # The text document.
+        #
+        # @return [TextDocumentIdentifier]
+        def text_document
+          attributes.fetch(:textDocument)
+        end
+
+        #
+        # The document range for which inlay hints should be computed.
+        #
+        # @return [Range]
+        def range
+          attributes.fetch(:range)
+        end
+
+        #
+        # An optional token that a server can use to report work done progress.
+        #
+        # @return [ProgressToken | nil]
+        def work_done_token
+          attributes.fetch(:workDoneToken)
+        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/inlay_hint_registration_options.rb

@@ -0,0 +1,65 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Inlay hint options used during static or dynamic registration.
+      #
+      # @since 3.17.0
+      #
+      class InlayHintRegistrationOptions
+        def initialize(resolve_provider: nil, work_done_progress: nil, document_selector:, id: nil)
+          @attributes = {}
+
+          @attributes[:resolveProvider] = resolve_provider if resolve_provider
+          @attributes[:workDoneProgress] = work_done_progress if work_done_progress
+          @attributes[:documentSelector] = document_selector
+          @attributes[:id] = id if id
+
+          @attributes.freeze
+        end
+
+        #
+        # The server provides support to resolve additional
+        # information for an inlay hint item.
+        #
+        # @return [boolean | nil]
+        def resolve_provider
+          attributes.fetch(:resolveProvider)
+        end
+
+        # @return [boolean | nil]
+        def work_done_progress
+          attributes.fetch(:workDoneProgress)
+        end
+
+        #
+        # A document selector to identify the scope of the registration. If set to null
+        # the document selector provided on the client side will be used.
+        #
+        # @return [DocumentSelector | null]
+        def document_selector
+          attributes.fetch(:documentSelector)
+        end
+
+        #
+        # The id used to register the request. The id can be used to deregister
+        # the request again. See also Registration#id.
+        #
+        # @return [string | nil]
+        def id
+          attributes.fetch(:id)
+        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/inlay_hint_workspace_client_capabilities.rb

@@ -0,0 +1,44 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Client workspace capabilities specific to inlay hints.
+      #
+      # @since 3.17.0
+      #
+      class InlayHintWorkspaceClientCapabilities
+        def initialize(refresh_support: nil)
+          @attributes = {}
+
+          @attributes[:refreshSupport] = refresh_support if refresh_support
+
+          @attributes.freeze
+        end
+
+        #
+        # Whether the client implementation supports a refresh request sent from
+        # the server to the client.
+        #
+        # Note that this event is global and will force the client to refresh all
+        # inlay hints currently shown. It should be used with absolute care and
+        # is useful for situation where a server for example detects a project wide
+        # change that requires such a calculation.
+        #
+        # @return [boolean | nil]
+        def refresh_support
+          attributes.fetch(:refreshSupport)
+        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/inline_value.rb

@@ -0,0 +1,78 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Inline value information can be provided by different means:
+      # - directly as a text value (class InlineValueText).
+      # - as a name to use for a variable lookup (class InlineValueVariableLookup)
+      # - as an evaluatable expression (class InlineValueEvaluatableExpression)
+      # The InlineValue types combines all inline value types into one type.
+      #
+      # @since 3.17.0
+      #
+      class InlineValue
+        def initialize(range:, text:, variable_name: nil, case_sensitive_lookup:, expression: nil)
+          @attributes = {}
+
+          @attributes[:range] = range
+          @attributes[:text] = text
+          @attributes[:variableName] = variable_name if variable_name
+          @attributes[:caseSensitiveLookup] = case_sensitive_lookup
+          @attributes[:expression] = expression if expression
+
+          @attributes.freeze
+        end
+
+        #
+        # The document range for which the inline value applies.
+        #
+        # @return [Range]
+        def range
+          attributes.fetch(:range)
+        end
+
+        #
+        # The text of the inline value.
+        #
+        # @return [string]
+        def text
+          attributes.fetch(:text)
+        end
+
+        #
+        # If specified the name of the variable to look up.
+        #
+        # @return [string | nil]
+        def variable_name
+          attributes.fetch(:variableName)
+        end
+
+        #
+        # How to perform the lookup.
+        #
+        # @return [boolean]
+        def case_sensitive_lookup
+          attributes.fetch(:caseSensitiveLookup)
+        end
+
+        #
+        # If specified the expression overrides the extracted expression.
+        #
+        # @return [string | nil]
+        def expression
+          attributes.fetch(:expression)
+        end
+
+        attr_reader :attributes
+
+        def to_hash
+          attributes
+        end
+
+        def to_json(*args)
+          to_hash.to_json(*args)
+        end
+      end
+    end
+  end
+end