Local variable type inference doesn't seem to work.

[ParsaJR]

Hello everyone. I'm new to ruby and im trying to setup my editor (emacs + eglot) to use ruby-lsp in my ruby projects.

Now, the setup seem to work fine, but i'm not sure its working as intended or not. Here is my situation:

    # The language server cant infer that this variable is an string? I get absolutely no hover info for the variable "sentence":
    sentence = "hello"
    # No completion? It does not offer me any methods over this string(split,slice,upcase...)
    sentence.
     
     
    # The completion only works for variables and classes .e.g:
    sentence
    String
    Object

I just wanna know to if its by design? or i have misconfigured something.

[MentalOfCrow]

This is currently expected behavior, not an Eglot misconfiguration.

Ruby LSP can complete calls when it can resolve the receiver directly, but it does not carry a full inferred type through local-variable assignments. The maintainers described the same case in issue #3407: direct calls such as SomeClass.new.some_method can be resolved, while carrying the type through x = SomeClass.new; x.some_method would require type-flow analysis and at least part of a type system. Their exploration in #2421 concluded that the accuracy gain without annotations would be too small, so they did not implement it.

Your string example crosses that same boundary:

"hello".upcase       # direct literal receiver: Ruby LSP can know it is a String

sentence = "hello"
sentence.upcase      # local-variable type is not flowed from the assignment

So there are two useful checks:

1. Try completion immediately after a literal, e.g. type "hello".. If that works, Eglot and completion are configured correctly and you are only seeing the known inference limitation.
2. If direct-literal completion also fails, update the ruby-lsp gem, run ruby-lsp-check, and reconnect Eglot; that would be a separate indexing/client-capability problem.

For accurate completion after assignments, the Ruby LSP design documentation recommends adopting a type system/type checker such as Sorbet or Steep. Ruby LSP itself deliberately falls back to syntax/index-based heuristics rather than shipping a complete type system.

If this explains what you are seeing, please mark it as the accepted answer so other Emacs/Eglot users can distinguish the inference limitation from a broken setup.

[ParsaJR]

Thanks for the informative answer.
Yes. The completion of methods over the literal works as expected.

You're right. I've also tested the language server in the vscode environment and i can confirm that the behavior is the same.

This issue was mostly about my gut feeling around this situation(As someone who is familiar with TS/Go/Python tooling)