Negotiate position encoding in LSP Initialize (LSP 3.17)

Implements `general.positionEncodings` negotiation per LSP 3.17 spec.
The server picks the first encoding from the client's preference list
that it supports (`utf-8` / `utf-16` / `utf-32`) and reports it back via
`capabilities.positionEncoding`. Falls back to UTF-16 (mandatory per
spec) if the client doesn't propose any supported encoding.

The negotiated value flows into per-workspace Services through
`core_options.merge(position_encoding: ...)`, so each Service computes
column positions in the agreed encoding.

See: https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocuments

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 2 people

lib/typeprof/lsp/messages.rb

@@ -56,6 +56,10 @@ def run
   class Message::Initialize < Message
     METHOD = "initialize" # request (required)
     def run
+      # Must negotiate encoding before add_workspaces so newly created Services honor it.
+      client_encodings = @params.dig(:capabilities, :general, :positionEncodings)
+      @server.negotiate_position_encoding(client_encodings)
+
       folders = @params[:workspaceFolders].map do |folder|
         folder => { uri:, }
         @server.uri_to_path(uri)
@@ -65,6 +69,7 @@ def run
 
       respond(
         capabilities: {
+          positionEncoding: @server.lsp_position_encoding,
           textDocumentSync: {
             openClose: true,
             change: 2, # Incremental

lib/typeprof/lsp/server.rb

@@ -47,6 +47,15 @@ def self.start_socket(core_options, port = 0)
       end
     end
 
+    # see: https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocuments
+    LSP_POSITION_ENCODINGS = {
+      Encoding::UTF_8 => "utf-8",
+      Encoding::UTF_16LE => "utf-16",
+      Encoding::UTF_32LE => "utf-32",
+    }.freeze
+
+    private_constant :LSP_POSITION_ENCODINGS
+
     def initialize(core_options, reader, writer, url_schema: nil)
       @core_options = core_options
       @cores = {}
@@ -62,9 +71,29 @@ def initialize(core_options, reader, writer, url_schema: nil)
       @diagnostic_severity = :error
     end
 
-    attr_reader :open_texts
+    attr_reader :open_texts, :position_encoding
     attr_accessor :signature_enabled
 
+    # Pick the first mutually-supported encoding from the client's preference-ordered list
+    # and store it. Falls back to UTF-16LE (mandatory per LSP 3.17 spec).
+    def negotiate_position_encoding(client_encodings)
+      @position_encoding = pick_position_encoding(client_encodings)
+    end
+
+    def lsp_position_encoding
+      LSP_POSITION_ENCODINGS.fetch(@position_encoding)
+    end
+
+    def pick_position_encoding(client_encodings)
+      return Encoding::UTF_16LE unless client_encodings.is_a?(Array)
+      client_encodings.each do |enc|
+        encoding = LSP_POSITION_ENCODINGS.key(enc)
+        return encoding if encoding
+      end
+      Encoding::UTF_16LE
+    end
+    private :pick_position_encoding
+
     #: (String) -> String
     def path_to_uri(path)
       @url_schema + File.expand_path(path).split("/").map {|s| CGI.escapeURIComponent(s) }.join("/")
@@ -105,9 +134,10 @@ def add_workspaces(folders)
               end
             end
             @core_options[:exclude_patterns] = conf[:exclude] if conf[:exclude]
+            service_options = @core_options.merge(position_encoding: @position_encoding)
             conf[:analysis_unit_dirs].each do |dir|
               dir = File.expand_path(dir, path)
-              core = @cores[dir] = TypeProf::Core::Service.new(@core_options)
+              core = @cores[dir] = TypeProf::Core::Service.new(service_options)
               core.add_workspace(dir, @rbs_dir)
             end
           else

test/lsp/lsp_test.rb

@@ -28,11 +28,14 @@ def setup
       @id = 0
     end
 
-    def init(fixture)
+    def init(fixture, position_encodings: nil, expected_position_encoding: "utf-16")
       @folder = @lsp.path_to_uri(File.expand_path(File.join(__dir__, "..", "fixtures", fixture))) + "/"
-      id = request("initialize", workspaceFolders: [{ uri: @folder }])
+      params = { workspaceFolders: [{ uri: @folder }] }
+      params[:capabilities] = { general: { positionEncodings: position_encodings } } if position_encodings
+      id = request("initialize", **params)
       expect_response(id) do |recv|
         assert_equal({ name: "typeprof", version: TypeProf::VERSION }, recv[:serverInfo])
+        assert_equal(expected_position_encoding, recv[:capabilities][:positionEncoding])
       end
       notify("initialized")
     end
@@ -405,6 +408,36 @@ class Foo
       end
     end
 
+    def test_position_encoding_default
+      init("basic")
+      assert_equal(Encoding::UTF_16LE, @lsp.position_encoding)
+    end
+
+    def test_position_encoding_utf8_preferred
+      init("basic", position_encodings: ["utf-8", "utf-16"], expected_position_encoding: "utf-8")
+      assert_equal(Encoding::UTF_8, @lsp.position_encoding)
+    end
+
+    def test_position_encoding_empty_array
+      init("basic", position_encodings: [], expected_position_encoding: "utf-16")
+      assert_equal(Encoding::UTF_16LE, @lsp.position_encoding)
+    end
+
+    def test_position_encoding_unsupported_only
+      init("basic", position_encodings: ["ascii"], expected_position_encoding: "utf-16")
+      assert_equal(Encoding::UTF_16LE, @lsp.position_encoding)
+    end
+
+    def test_position_encoding_prefers_first_supported
+      init("basic", position_encodings: ["ascii", "utf-16", "utf-8"], expected_position_encoding: "utf-16")
+      assert_equal(Encoding::UTF_16LE, @lsp.position_encoding)
+    end
+
+    def test_position_encoding_utf32_preferred
+      init("basic", position_encodings: ["utf-32", "utf-16"], expected_position_encoding: "utf-32")
+      assert_equal(Encoding::UTF_32LE, @lsp.position_encoding)
+    end
+
     def test_type_definition_for_local_variable
       init("type_definition")