textDocument/codeLens vs textDocument/inlayHints

[aspeddro]

I was using rust_analyzer, an LSP implementation for rust. The codelens feature in it differs from ocaml.

The rust_analyzer codelens feature provides commands to run build, debug and test, there may be more.
The resource providing type hint is inlayHints which is still in proposal, see microsoft/vscode-languageserver-node#772.

Doesn't it make more sense for codelens in ocaml to run build via dune, for example, and move codelens to inlayHints?

PR: microsoft/language-server-protocol#1249

Issue: microsoft/language-server-protocol#956

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

[rgrinberg]

The rust_analyzer codelens feature provides commands to run build, debug and test, there may be more.

Could you describe this a bit more? I thought code lenses are supposed to be specific to excerpts from the document? Things like build, debug, test are buffer specific on the other hand.

[aspeddro]

In rust_analyzer codelens provides commands that are resolved on the client side. I saw in the specification that a codelens represents a command that should be shown along with source text, like the number of references, a way to run tests, etc. See https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_codeLens.

Example:

When I make a request textDocument/codeLens to rust_analyzer the server returns a CodeLens structure as a response, which contains commands.

The docs say:

Commands are identified by a string identifier. The recommended way to handle commands is to implement their execution on the server side if the client and server provides the corresponding capabilities. Alternatively the tool extension code could handle the command. The protocol currently doesn’t specify a set of well-known commands.

{ {
    command = {
      arguments = { {
          args = {
            cargoArgs = { "run", "--package", "variables", "--bin", "variables" },
            cargoExtraArgs = {},
            executableArgs = {},
            workspaceRoot = "/home/pedro/Desktop/learning-rust/variables"
          },
          kind = "cargo",
          label = "run variables",
          location = {
            targetRange = {
              end = {
                character = 1,
                line = 16
              },
              start = {
                character = 0,
                line = 0
              }
            },
            targetSelectionRange = {
              end = {
                character = 7,
                line = 0
              },
              start = {
                character = 3,
                line = 0
              }
            },
            targetUri = "file:///home/pedro/Desktop/learning-rust/variables/src/main.rs"
          }
        } },
      command = "rust-analyzer.runSingle",
      title = "▶︎ Run "
    },
    range = {
      end = {
        character = 7,
        line = 0
      },
      start = {
        character = 3,
        line = 0
      }
    }
  },
  {
    command = {
      arguments = { {
          args = {
            cargoArgs = { "run", "--package", "variables", "--bin", "variables" },
            cargoExtraArgs = {},
            executableArgs = {},
            workspaceRoot = "/home/pedro/Desktop/learning-rust/variables"
          },
          kind = "cargo",
          label = "run variables",
          location = {
            targetRange = {
              end = {
                character = 1,
                line = 16
              },
              start = {
                character = 0,
                line = 0
              }
            },
            targetSelectionRange = {
              end = {
                character = 7,
                line = 0
              },
              start = {
                character = 3,
                line = 0
              }
            },
            targetUri = "file:///home/pedro/Desktop/learning-rust/variables/src/main.rs"
          }
        } },
      command = "rust-analyzer.debugSingle",
      title = "Debug"
    },
    range = {
      end = {
        character = 7,
        line = 0
      },
      start = {
        character = 3,
        line = 0
      }
    }
  } }

NOTE: I'm not familiar with the ocaml ecosystem, I started this thread because I was configuring the editor for ocaml and saw that the feature is the same as rust_analyzer, but they are implemented differently.

[rgrinberg]

Okay well so it sounds like there's two separate issues here:

• Convert our current code lens hints to inlay hints. This one I agree with. Feel free to send a PR
• Use code lenses to offer actions to run/debug/build things. This one needs more discussion. For example, why shouldn't we use code actions for these things?

[aspeddro]

Why shouldn't we use code actions for these things?

code actions according to the specification are usually code fixes to fix problems or to beautify/refactor the code. Code Action Request

Another important point: To ensure that a server is useful in many clients the commands specified in a code actions should be handled by the server and not by the client.

[ulugbekna]

Convert our current code lens hints to inlay hints. This one I agree with. Feel free to send a PR

I'm also interested in inlay hints. @aspeddro if you'd like, we can collaborate.

Use code lenses to offer actions to run/debug/build things. This one needs more discussion. For example, why shouldn't we use code actions for these things?

Using code lens for run/debug/build things would be confusing given it'd be attached to a single line of code.

We could have a treeview in vscode that includes buildable and/or runnable entries. This looks like this:

[aspeddro]

I'm also interested in inlay hints. @aspeddro if you'd like, we can collaborate.

@ulugbekna, I'm not familiar with ocaml. You can take that PR if you want.

Using code lens for run/debug/build things would be confusing given it'd be attached to a single line of code.

As in rust_analyzer the server can return a codelens containing several commands for the same line. The client (eg: vscode, neovim) chooses how this is presented to the user, it can be a floating menu or a treeview