Class: RubyLsp::Listeners::Definition

Inherits:
Object
  • Object
show all
Includes:
Requests::Support::Common
Defined in:
lib/ruby_lsp/listeners/definition.rb

Constant Summary collapse

MAX_NUMBER_OF_DEFINITION_CANDIDATES_WITHOUT_RECEIVER = 
10

Instance Method Summary collapse

Methods included from Requests::Support::Common

#categorized_markdown_from_index_entries, #constant_name, #create_code_lens, #each_constant_path_part, #kind_for_entry, #markdown_from_index_entries, #namespace_constant_name, #not_in_dependencies?, #range_from_location, #range_from_node, #self_receiver?

Constructor Details

#initialize(response_builder, global_state, language_id, uri, node_context, dispatcher, sorbet_level) ⇒ Definition

: (ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)] response_builder, GlobalState global_state, Symbol language_id, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher, SorbetLevel sorbet_level) -> void



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 12

def initialize(response_builder, global_state, language_id, uri, node_context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
  @response_builder = response_builder
  @global_state = global_state
  @index = global_state.index #: RubyIndexer::Index
  @type_inferrer = global_state.type_inferrer #: TypeInferrer
  @language_id = language_id
  @uri = uri
  @node_context = node_context
  @sorbet_level = sorbet_level

  dispatcher.register(
    self,
    :on_call_node_enter,
    :on_block_argument_node_enter,
    :on_constant_read_node_enter,
    :on_constant_path_node_enter,
    :on_global_variable_and_write_node_enter,
    :on_global_variable_operator_write_node_enter,
    :on_global_variable_or_write_node_enter,
    :on_global_variable_read_node_enter,
    :on_global_variable_target_node_enter,
    :on_global_variable_write_node_enter,
    :on_instance_variable_read_node_enter,
    :on_instance_variable_write_node_enter,
    :on_instance_variable_and_write_node_enter,
    :on_instance_variable_operator_write_node_enter,
    :on_instance_variable_or_write_node_enter,
    :on_instance_variable_target_node_enter,
    :on_string_node_enter,
    :on_symbol_node_enter,
    :on_super_node_enter,
    :on_forwarding_super_node_enter,
    :on_class_variable_and_write_node_enter,
    :on_class_variable_operator_write_node_enter,
    :on_class_variable_or_write_node_enter,
    :on_class_variable_read_node_enter,
    :on_class_variable_target_node_enter,
    :on_class_variable_write_node_enter,
  )
end

Instance Method Details

#on_block_argument_node_enter(node) ⇒ Object

: (Prism::BlockArgumentNode node) -> void



97
98
99
100
101
102
103
104
105
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 97

def on_block_argument_node_enter(node)
  expression = node.expression
  return unless expression.is_a?(Prism::SymbolNode)

  value = expression.value
  return unless value

  handle_method_definition(value, nil)
end

#on_call_node_enter(node) ⇒ Object

: (Prism::CallNode node) -> void



54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 54

def on_call_node_enter(node)
  # Sorbet can handle go to definition for methods invoked on self on typed true or higher
  return if @sorbet_level.true_or_higher? && self_receiver?(node)

  message = node.message
  return unless message

  inferrer_receiver_type = @type_inferrer.infer_receiver_type(@node_context)

  # Until we can properly infer the receiver type in erb files (maybe with ruby-lsp-rails),
  # treating method calls' type as `nil` will allow users to get some completion support first
  if @language_id == :erb && inferrer_receiver_type&.name == "Object"
    inferrer_receiver_type = nil
  end

  handle_method_definition(message, inferrer_receiver_type)
end

#on_class_variable_and_write_node_enter(node) ⇒ Object

: (Prism::ClassVariableAndWriteNode node) -> void



194
195
196
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 194

def on_class_variable_and_write_node_enter(node)
  handle_class_variable_definition(node.name.to_s)
end

#on_class_variable_operator_write_node_enter(node) ⇒ Object

: (Prism::ClassVariableOperatorWriteNode node) -> void



199
200
201
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 199

def on_class_variable_operator_write_node_enter(node)
  handle_class_variable_definition(node.name.to_s)
end

#on_class_variable_or_write_node_enter(node) ⇒ Object

: (Prism::ClassVariableOrWriteNode node) -> void



204
205
206
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 204

def on_class_variable_or_write_node_enter(node)
  handle_class_variable_definition(node.name.to_s)
end

#on_class_variable_read_node_enter(node) ⇒ Object

: (Prism::ClassVariableReadNode node) -> void



214
215
216
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 214

def on_class_variable_read_node_enter(node)
  handle_class_variable_definition(node.name.to_s)
end

#on_class_variable_target_node_enter(node) ⇒ Object

: (Prism::ClassVariableTargetNode node) -> void



209
210
211
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 209

def on_class_variable_target_node_enter(node)
  handle_class_variable_definition(node.name.to_s)
end

#on_class_variable_write_node_enter(node) ⇒ Object

: (Prism::ClassVariableWriteNode node) -> void



219
220
221
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 219

def on_class_variable_write_node_enter(node)
  handle_class_variable_definition(node.name.to_s)
end

#on_constant_path_node_enter(node) ⇒ Object

: (Prism::ConstantPathNode node) -> void



108
109
110
111
112
113
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 108

def on_constant_path_node_enter(node)
  name = RubyIndexer::Index.constant_name(node)
  return if name.nil?

  find_in_index(name)
end

#on_constant_read_node_enter(node) ⇒ Object

: (Prism::ConstantReadNode node) -> void



116
117
118
119
120
121
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 116

def on_constant_read_node_enter(node)
  name = RubyIndexer::Index.constant_name(node)
  return if name.nil?

  find_in_index(name)
end

#on_forwarding_super_node_enter(node) ⇒ Object

: (Prism::ForwardingSuperNode node) -> void



189
190
191
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 189

def on_forwarding_super_node_enter(node)
  handle_super_node_definition
end

#on_global_variable_and_write_node_enter(node) ⇒ Object

: (Prism::GlobalVariableAndWriteNode node) -> void



124
125
126
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 124

def on_global_variable_and_write_node_enter(node)
  handle_global_variable_definition(node.name.to_s)
end

#on_global_variable_operator_write_node_enter(node) ⇒ Object

: (Prism::GlobalVariableOperatorWriteNode node) -> void



129
130
131
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 129

def on_global_variable_operator_write_node_enter(node)
  handle_global_variable_definition(node.name.to_s)
end

#on_global_variable_or_write_node_enter(node) ⇒ Object

: (Prism::GlobalVariableOrWriteNode node) -> void



134
135
136
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 134

def on_global_variable_or_write_node_enter(node)
  handle_global_variable_definition(node.name.to_s)
end

#on_global_variable_read_node_enter(node) ⇒ Object

: (Prism::GlobalVariableReadNode node) -> void



139
140
141
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 139

def on_global_variable_read_node_enter(node)
  handle_global_variable_definition(node.name.to_s)
end

#on_global_variable_target_node_enter(node) ⇒ Object

: (Prism::GlobalVariableTargetNode node) -> void



144
145
146
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 144

def on_global_variable_target_node_enter(node)
  handle_global_variable_definition(node.name.to_s)
end

#on_global_variable_write_node_enter(node) ⇒ Object

: (Prism::GlobalVariableWriteNode node) -> void



149
150
151
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 149

def on_global_variable_write_node_enter(node)
  handle_global_variable_definition(node.name.to_s)
end

#on_instance_variable_and_write_node_enter(node) ⇒ Object

: (Prism::InstanceVariableAndWriteNode node) -> void



164
165
166
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 164

def on_instance_variable_and_write_node_enter(node)
  handle_instance_variable_definition(node.name.to_s)
end

#on_instance_variable_operator_write_node_enter(node) ⇒ Object

: (Prism::InstanceVariableOperatorWriteNode node) -> void



169
170
171
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 169

def on_instance_variable_operator_write_node_enter(node)
  handle_instance_variable_definition(node.name.to_s)
end

#on_instance_variable_or_write_node_enter(node) ⇒ Object

: (Prism::InstanceVariableOrWriteNode node) -> void



174
175
176
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 174

def on_instance_variable_or_write_node_enter(node)
  handle_instance_variable_definition(node.name.to_s)
end

#on_instance_variable_read_node_enter(node) ⇒ Object

: (Prism::InstanceVariableReadNode node) -> void



154
155
156
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 154

def on_instance_variable_read_node_enter(node)
  handle_instance_variable_definition(node.name.to_s)
end

#on_instance_variable_target_node_enter(node) ⇒ Object

: (Prism::InstanceVariableTargetNode node) -> void



179
180
181
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 179

def on_instance_variable_target_node_enter(node)
  handle_instance_variable_definition(node.name.to_s)
end

#on_instance_variable_write_node_enter(node) ⇒ Object

: (Prism::InstanceVariableWriteNode node) -> void



159
160
161
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 159

def on_instance_variable_write_node_enter(node)
  handle_instance_variable_definition(node.name.to_s)
end

#on_string_node_enter(node) ⇒ Object

: (Prism::StringNode node) -> void



73
74
75
76
77
78
79
80
81
82
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 73

def on_string_node_enter(node)
  with_enclosing_call(node) do |enclosing_call, name|
    case name
    when :require, :require_relative
      handle_require_definition(node, name)
    when :send, :public_send
      handle_send_or_public_send_definition(enclosing_call, node) { node.content }
    end
  end
end

#on_super_node_enter(node) ⇒ Object

: (Prism::SuperNode node) -> void



184
185
186
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 184

def on_super_node_enter(node)
  handle_super_node_definition
end

#on_symbol_node_enter(node) ⇒ Object

: (Prism::SymbolNode node) -> void



85
86
87
88
89
90
91
92
93
94
 
# File 'lib/ruby_lsp/listeners/definition.rb', line 85

def on_symbol_node_enter(node)
  with_enclosing_call(node) do |enclosing_call, name|
    case name
    when :autoload
      handle_autoload_definition(enclosing_call)
    when :send, :public_send
      handle_send_or_public_send_definition(enclosing_call, node) { node.unescaped }
    end
  end
end