Module: MilkTea::LSP::Server::ServerSignatureHelp

Included in:
MilkTea::LSP::Server
Defined in:
lib/milk_tea/lsp/server/signature_help.rb

Instance Method Summary collapse

Instance Method Details

#build_signature_from_binding(binding, name, ctx) ⇒ Object 



111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/milk_tea/lsp/server/signature_help.rb', line 111

def build_signature_from_binding(binding, name, ctx)
  if binding.is_a?(Types::Struct) || binding.is_a?(Types::StructInstance) || binding.is_a?(Types::VariantArmPayload)
    fields = binding.is_a?(Types::StructInstance) ? binding.definition.fields : binding.fields
    params_list = fields.map { |fname, ftype| Types::Registry.parameter(fname, ftype) }
    return_type_label = binding.is_a?(Types::StructInstance) ? binding.to_s : binding.name
  elsif binding.respond_to?(:[])
    builtin_name = binding[:builtin]
    info = BUILTIN_CALL_HOVER_INFO[builtin_name]
    return nil unless info

    label = info[:signature].sub(/^builtin /, '')
    parameters = []
    return {
      signatures:      [{ label: label, parameters: parameters }],
      activeSignature: 0,
      activeParameter: ctx[:active_parameter],
    }
  else
    return nil unless binding.respond_to?(:type) && binding.type.respond_to?(:params)
    params_list = binding.type.params
    return_type_label = binding.type.return_type
  end

  params_str = format_params(params_list)
  label = "#{name}(#{params_str}) -> #{return_type_label}"

  parameters = params_list.map do |parameter|
    { label: "#{parameter.name}: #{parameter.type}" }
  end

  {
    signatures:      [{ label: label, parameters: parameters }],
    activeSignature: 0,
    activeParameter: ctx[:active_parameter],
  }
end

#handle_signature_help(params) ⇒ Object 



148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
 
# File 'lib/milk_tea/lsp/server/signature_help.rb', line 148

def handle_signature_help(params)
  stages = new_perf_stages
  total_start = stages ? monotonic_time : nil
  uri      = params['textDocument']['uri']
  lsp_line = params['position']['line']
  lsp_char = params['position']['character']
  result_state = 'miss'

  ctx = measure_perf_stage(stages, 'call_context') { @workspace.find_call_context(uri, lsp_line, lsp_char) }
  return nil unless ctx

  facts = measure_perf_stage(stages, 'facts') do
    @workspace.get_facts(uri, allow_last_good_fallback: allow_hover_last_good_fallback?(uri))
  end
  return nil unless facts

  binding_info = measure_perf_stage(stages, 'binding') do
    signature_help_bindings_for_name(facts, uri, lsp_line, lsp_char, ctx[:name])
  end
  return nil unless binding_info

  binding, display_name = binding_info

  doc_comment = measure_perf_stage(stages, 'docs') do
    signature_help_doc_comment_for_call(uri, ctx[:name], lsp_line, lsp_char)
  end

  result = measure_perf_stage(stages, 'build') do
    sig = build_signature_from_binding(binding, display_name, ctx)

    if sig && sig[:signatures] && (sig_entry = sig[:signatures].first)
      param_docs = doc_tag_param_descriptions(doc_comment)
      sig_entry[:parameters]&.each do |param|
        param_name = param[:label].to_s.split(':').first&.strip
        if param_name && param_docs.key?(param_name)
          param[:documentation] = { kind: 'markdown', value: param_docs[param_name] }
        end
      end

      signature_docs = signature_help_markdown_for_doc_comment(doc_comment)
      unless signature_docs.empty?
        sig_entry[:documentation] = { kind: 'markdown', value: signature_docs }
      end
    end

    sig
  end
  result_state = 'hit' if result
  result
rescue StandardError => e
  result_state = 'error'
  warn "Error in signatureHelp handler: #{e.message}"
  nil
ensure
  log_request_stage_breakdown('textDocument/signatureHelp', total_start, uri: uri, stages: stages, summary: "result=#{result_state}")
end

#resolve_this_receiver_type(facts, uri, lsp_line) ⇒ Object 



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/milk_tea/lsp/server/signature_help.rb', line 94

def resolve_this_receiver_type(facts, uri, lsp_line)
  ast = @workspace.get_ast(uri)
  return nil unless ast

  extending = nil
  each_ast_node(ast) do |node|
    next unless node.is_a?(AST::ExtendingBlock)
    if node.line && lsp_line + 1 >= node.line && (!node.respond_to?(:end_line) || !node.end_line || lsp_line + 1 <= node.end_line)
      extending = node
    end
  end

  return nil unless extending
  facts.types[extending.type_name] ||
    facts.imports.each_value.find { |mod| mod.types.key?(extending.type_name) }&.types&.dig(extending.type_name)
end

#signature_help_bindings_for_name(facts, uri, lsp_line, lsp_char, name) ⇒ Object 



7
8
9
10
11
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/milk_tea/lsp/server/signature_help.rb', line 7

def signature_help_bindings_for_name(facts, uri, lsp_line, lsp_char, name)
  # 1. Top-level functions
  if (binding = facts.functions[name])
    return [binding, name]
  end

  # 2. Imported module functions (e.g. mod.func(...))
  facts.imports.each_value do |mod|
    if (binding = mod.functions[name])
      return [binding, name]
    end
  end

  # 3. Methods — find via dot-receiver resolution
  dot_recv = @workspace.find_dot_receiver(uri, lsp_line, lsp_char)
  if dot_recv && name
    if (mod_binding = facts.imports[dot_recv])
      if (binding = mod_binding.functions[name])
        return [binding, name]
      end
    end

    if (receiver_type = resolve_dot_receiver_value_type(facts, dot_recv, lsp_line + 1, lsp_char + 1) ||
                        resolve_dot_receiver_value_type(facts, dot_recv.sub(/\[.*\]\z/, ""), lsp_line + 1, lsp_char + 1))
      methods = methods_for_receiver_type(facts, receiver_type)
      if (binding = methods[name] || methods["static:#{name}"])
        return [binding, name]
      end
    end

    if (type_receiver = resolve_type_receiver_info(facts, dot_recv, nil) ||
                        resolve_type_receiver_info(facts, dot_recv.sub(/\[.*\]\z/, ""), nil))
      methods = methods_for_receiver_type(facts, type_receiver[:type])
      if (binding = methods[name] || methods["static:#{name}"])
        return [binding, name]
      end
      if type_receiver[:type].respond_to?(:arms) && (arm = type_receiver[:type].arms[name])
        if arm.respond_to?(:payload) && arm.payload
          return [arm.payload, name]
        end
      end
    end
  end

  # 4. Method name directly (e.g. method(...) on `this` in extending block)
  receiver_type = resolve_this_receiver_type(facts, uri, lsp_line)
  if receiver_type
    methods = methods_for_receiver_type(facts, receiver_type)
    if (binding = methods[name] || methods["static:#{name}"])
      return [binding, name]
    end
  end

  # 5. Value with callable type (fn/proc)
  if (val_binding = facts.values[name])
    if val_binding.type.is_a?(Types::Function)
      return [val_binding, name]
    end
  end

  # 6. Type constructor (struct constructor)
  if (type = facts.types[name] || facts.imports.each_value.find { |mod| mod.types.key?(name) }&.types&.dig(name))
    if type.respond_to?(:fields) && !type.fields.empty?
      return [type, name]
    end
  end

  # Resolve module-qualified type constructor (mod.Type(...))
  if name.include?('.')
    parts = name.split('.', 2)
    if (mod_binding = facts.imports[parts[0]])
      if (type = mod_binding.types[parts[1]])
        if type.respond_to?(:fields) && !type.fields.empty?
          return [type, name]
        end
      end
    end
  end

  # 7. Builtin callables
  if BUILTIN_CALL_HOVER_INFO.key?(name)
    return [{ builtin: name }, name]
  end

  nil
end