Add inlay hints support to the `ruby-lsp` about ruby-lsp HOT 4 OPEN

There's no built-in way by checking the method definition straight. We'd need to keep track of which section we're currently inside. Something like this in pseudo code

class InlayHint < BaseRequest
  def initialize(...)
    @current_visibility = :public # Maybe use a Sorbet enum?
  end

  def visit_call(node) # not sure if it's call, command, fcall...
    if this_thing_is_private_public_or_protected
      @current_visibility = the_new_visibility
    end
  end

  def visit_def(node)
    add_hint_using_current_visibility
  end
end

Two thoughts:

• I think we shouldn't add anything for public methods, since that's the default
• If it's possible, I think this inlay hint would look better on top of the method name (not on the left or right)

from ruby-lsp.

Ooo neat, thanks for the pointers!

I think we shouldn't add anything for public methods, since that's the default

Completely agree. That would be really messy.

If it's possible, I think this inlay hint would look better on top of the method name (not on the left or right)

Should be entirely possible. This hint in particular really runs the risk of looking messy, I agree that above is a good place to start. If I get a chance to hack on it, I'll be sure to propose a few options with screenshots for easy evaluation.

from ruby-lsp.

@vinistock I want to give this a try. I'll start by listing common cases that can use the hint.

But without type information, there aren't too many features we can implement with high accuracy.

• Implicit self

• Implicit type information, like

  • rescue => e (Exception)
  • raise "error" (RuntimeError)

• Method visibility

  private
  
  # 100 lines
  
  (private) def foo
  end

• Expanded namespace

  • Not sure how practical it is without code evaluation

  module Foo
    module Rails; end
  
    (Foo::)Rails

For new developers

These may be too intrusive and distracting for experienced developers. But they could help new devs understand Ruby.

• Expand syntactical sugar like &= or |=

  a |= b # (a = a | b)

• Operator precedence

  1 + 2 * 5 # (1 + (2 * 5))

• Explain % literals

  %q(foobarbaz) # String "foobarbaz"

Things that'll be helpful if possible

• Possible super source

  class A
    def foo; end
  end
  
  class B < A
    def foo
      super # hint A
    end
  end

from ruby-lsp.

I dug into adding a hint for indicating method visibility but I kept hitting a wall in figuring out whether or not a def node was private/protected/public.

Would that require enhancing syntax_tree a bit or is there some elegant way to determine a node's visibility that I've missed? Maybe I'm looking at it from the wrong perspective.

from ruby-lsp.