mt-lang 0.3.9 → 0.3.10

data/lib/milk_tea/lsp/server/definition.rb

@@ -4,741 +4,740 @@ module MilkTea
   module LSP
     class Server
       module ServerDefinition
-        private
+        def is_builtin_name?(name, tokens, token_index)
+          return false unless token_index
+          builtin_hover_info(name, tokens, token_index)
+        end
 
-      def is_builtin_name?(name, tokens, token_index)
-        return false unless token_index
-        builtin_hover_info(name, tokens, token_index)
-      end
+        def handle_definition(params)
+          handle_definition_request('textDocument/definition', params, error_label: 'definition')
+        end
 
-      def handle_definition(params)
-        handle_definition_request('textDocument/definition', params, error_label: 'definition')
-      end
+        def handle_declaration(params)
+          handle_definition_request('textDocument/declaration', params, error_label: 'declaration')
+        end
 
-      def handle_declaration(params)
-        handle_definition_request('textDocument/declaration', params, error_label: 'declaration')
-      end
+        def handle_type_definition(params)
+          stages = new_perf_stages
+          total_start = stages ? monotonic_time : nil
+          uri = params.dig('textDocument', 'uri')
+          result_state = 'miss'
+
+          location = resolve_type_definition_location(params, stages: stages)
+          result_state = location ? 'hit' : 'miss'
+          location
+        rescue StandardError => e
+          result_state = 'error'
+          warn "Error in typeDefinition handler: #{e.message}"
+          nil
+        ensure
+          log_request_stage_breakdown('textDocument/typeDefinition', total_start, uri: uri, stages: stages, summary: "result=#{result_state}")
+        end
 
-      def handle_type_definition(params)
-        stages = new_perf_stages
-        total_start = stages ? monotonic_time : nil
-        uri = params.dig('textDocument', 'uri')
-        result_state = 'miss'
-
-        location = resolve_type_definition_location(params, stages: stages)
-        result_state = location ? 'hit' : 'miss'
-        location
-      rescue StandardError => e
-        result_state = 'error'
-        warn "Error in typeDefinition handler: #{e.message}"
-        nil
-      ensure
-        log_request_stage_breakdown('textDocument/typeDefinition', total_start, uri: uri, stages: stages, summary: "result=#{result_state}")
-      end
+        def handle_implementation(params)
+          stages = new_perf_stages
+          total_start = stages ? monotonic_time : nil
+          uri = params.dig('textDocument', 'uri')
+          result_state = 'miss'
+
+          locations = resolve_implementation_locations(params, stages: stages)
+          result_state = locations.empty? ? 'miss' : 'hit'
+          locations
+        rescue StandardError => e
+          result_state = 'error'
+          warn "Error in implementation handler: #{e.message}"
+          []
+        ensure
+          log_request_stage_breakdown('textDocument/implementation', total_start, uri: uri, stages: stages, summary: "result=#{result_state}")
+        end
 
-      def handle_implementation(params)
-        stages = new_perf_stages
-        total_start = stages ? monotonic_time : nil
-        uri = params.dig('textDocument', 'uri')
-        result_state = 'miss'
-
-        locations = resolve_implementation_locations(params, stages: stages)
-        result_state = locations.empty? ? 'miss' : 'hit'
-        locations
-      rescue StandardError => e
-        result_state = 'error'
-        warn "Error in implementation handler: #{e.message}"
-        []
-      ensure
-        log_request_stage_breakdown('textDocument/implementation', total_start, uri: uri, stages: stages, summary: "result=#{result_state}")
-      end
+        def handle_definition_request(method_name, params, error_label:)
+          stages = new_perf_stages
+          total_start = stages ? monotonic_time : nil
+          uri = params.dig('textDocument', 'uri')
+          result_state = 'miss'
+
+          location = resolve_definition_location(params, stages: stages)
+          result_state = location ? 'hit' : 'miss'
+          location
+        rescue StandardError => e
+          result_state = 'error'
+          warn "Error in #{error_label} handler: #{e.message}"
+          nil
+        ensure
+          log_request_stage_breakdown(method_name, total_start, uri: uri, stages: stages, summary: "result=#{result_state}")
+        end
 
-      def handle_definition_request(method_name, params, error_label:)
-        stages = new_perf_stages
-        total_start = stages ? monotonic_time : nil
-        uri = params.dig('textDocument', 'uri')
-        result_state = 'miss'
-
-        location = resolve_definition_location(params, stages: stages)
-        result_state = location ? 'hit' : 'miss'
-        location
-      rescue StandardError => e
-        result_state = 'error'
-        warn "Error in #{error_label} handler: #{e.message}"
-        nil
-      ensure
-        log_request_stage_breakdown(method_name, total_start, uri: uri, stages: stages, summary: "result=#{result_state}")
-      end
+        def resolve_definition_location(params, stages: nil)
+          uri      = params['textDocument']['uri']
+          lsp_line = params['position']['line']
+          lsp_char = params['position']['character']
+
+          context = measure_perf_stage(stages, 'context') { token_context_at(uri, lsp_line, lsp_char) }
+          token = context&.fetch(:token, nil)
+          return nil unless token&.type == :identifier
+
+          tokens = context[:tokens]
+          token_index = context[:token_index]
+          return nil if token_index && module_declaration_info_at(tokens, token_index)
+
+          if token_index && named_argument_label_token?(tokens, token_index)
+            location = named_argument_definition_location(uri, token.lexeme, tokens, token_index, stages:)
+            return location if location
+          end
 
-      def resolve_definition_location(params, stages: nil)
-        uri      = params['textDocument']['uri']
-        lsp_line = params['position']['line']
-        lsp_char = params['position']['character']
-
-        context = measure_perf_stage(stages, 'context') { token_context_at(uri, lsp_line, lsp_char) }
-        token = context&.fetch(:token, nil)
-        return nil unless token&.type == :identifier
-
-        tokens = context[:tokens]
-        token_index = context[:token_index]
-        return nil if token_index && module_declaration_info_at(tokens, token_index)
-
-        if token_index && named_argument_label_token?(tokens, token_index)
-          location = named_argument_definition_location(uri, token.lexeme, tokens, token_index, stages:)
-          return location if location
-        end
-
-        import_info = token_index ? measure_perf_stage(stages, 'import_path') { import_path_info_at(tokens, token_index) } : nil
-        if import_info
-          return module_definition_location(uri, import_info[:module_name])
-        end
-
-        facts = measure_perf_stage(stages, 'facts') { @workspace.get_facts(uri) }
-        if facts
-          facts_location = measure_perf_stage(stages, 'facts_lookup') do
-            location = nil
-            dot_receiver = @workspace.find_dot_receiver(uri, lsp_line, lsp_char)
-            dot_receiver_path = @workspace.find_dot_receiver_path(uri, lsp_line, lsp_char)
-            imported_module_name = dot_receiver ? (facts.imports[dot_receiver]&.name || imported_module_name_from_ast(uri, dot_receiver)) : nil
-
-            if token_index && (field_location = resolve_field_member_definition_location(uri, facts, tokens, token_index))
-              location = field_location
-            elsif token_index && (enum_member_location = resolve_enum_member_definition_location(uri, facts, tokens, token_index))
-              location = enum_member_location
-            elsif token_index && imported_module_name && module_member_access_info(tokens, token_index)
-              location = module_member_definition_location(uri, imported_module_name, token.lexeme)
-              location ||= module_definition_location(uri, imported_module_name)
-            elsif (type_method = resolve_static_type_receiver_method(facts, dot_receiver, dot_receiver_path, token.lexeme))
-              location = module_member_binding_location(uri, type_method[:module_name], token.lexeme, type_method[:binding]) ||
-                module_member_definition_location(uri, type_method[:module_name], token.lexeme) ||
-                module_definition_location(uri, type_method[:module_name])
-            elsif (binding = method_binding_at_token(facts, token))
-              location = module_member_binding_location(uri, facts.module_name, token.lexeme, binding)
-              location ||= module_member_definition_location(uri, facts.module_name, token.lexeme)
-            elsif (binding = facts.functions[token.lexeme])
-              location = module_member_binding_location(uri, facts.module_name, token.lexeme, binding)
-              location ||= module_member_definition_location(uri, facts.module_name, token.lexeme)
-            elsif facts.interfaces[token.lexeme]
-              location = module_member_definition_location(uri, facts.module_name, token.lexeme)
-            elsif facts.types.key?(token.lexeme)
-              location = module_member_definition_location(uri, facts.module_name, token.lexeme)
-            elsif (binding = facts.values[token.lexeme])
-              location = module_member_binding_location(uri, facts.module_name, token.lexeme, binding)
-              location ||= module_member_definition_location(uri, facts.module_name, token.lexeme)
-            else
-              if imported_module_name
-                location = module_member_definition_location(uri, imported_module_name, token.lexeme) || module_definition_location(uri, imported_module_name)
-              elsif facts.imports.key?(token.lexeme)
-                module_name = facts.imports.fetch(token.lexeme).name
-                location = module_member_definition_location(uri, module_name, token.lexeme)
-                location ||= module_definition_location(uri, module_name)
-              elsif (module_name = imported_module_name_from_ast(uri, token.lexeme))
-                location = module_definition_location(uri, module_name)
+          import_info = token_index ? measure_perf_stage(stages, 'import_path') { import_path_info_at(tokens, token_index) } : nil
+          if import_info
+            return module_definition_location(uri, import_info[:module_name])
+          end
+
+          facts = measure_perf_stage(stages, 'facts') { @workspace.get_facts(uri) }
+          if facts
+            facts_location = measure_perf_stage(stages, 'facts_lookup') do
+              location = nil
+              dot_receiver = @workspace.find_dot_receiver(uri, lsp_line, lsp_char)
+              dot_receiver_path = @workspace.find_dot_receiver_path(uri, lsp_line, lsp_char)
+              imported_module_name = dot_receiver ? (facts.imports[dot_receiver]&.name || imported_module_name_from_ast(uri, dot_receiver)) : nil
+
+              if token_index && (field_location = resolve_field_member_definition_location(uri, facts, tokens, token_index))
+                location = field_location
+              elsif token_index && (enum_member_location = resolve_enum_member_definition_location(uri, facts, tokens, token_index))
+                location = enum_member_location
+              elsif token_index && imported_module_name && module_member_access_info(tokens, token_index)
+                location = module_member_definition_location(uri, imported_module_name, token.lexeme)
+                location ||= module_definition_location(uri, imported_module_name)
+              elsif (type_method = resolve_static_type_receiver_method(facts, dot_receiver, dot_receiver_path, token.lexeme))
+                location = module_member_binding_location(uri, type_method[:module_name], token.lexeme, type_method[:binding]) ||
+                  module_member_definition_location(uri, type_method[:module_name], token.lexeme) ||
+                  module_definition_location(uri, type_method[:module_name])
+              elsif (binding = method_binding_at_token(facts, token))
+                location = module_member_binding_location(uri, facts.module_name, token.lexeme, binding)
+                location ||= module_member_definition_location(uri, facts.module_name, token.lexeme)
+              elsif (binding = facts.functions[token.lexeme])
+                location = module_member_binding_location(uri, facts.module_name, token.lexeme, binding)
+                location ||= module_member_definition_location(uri, facts.module_name, token.lexeme)
+              elsif facts.interfaces[token.lexeme]
+                location = module_member_definition_location(uri, facts.module_name, token.lexeme)
+              elsif facts.types.key?(token.lexeme)
+                location = module_member_definition_location(uri, facts.module_name, token.lexeme)
+              elsif (binding = facts.values[token.lexeme])
+                location = module_member_binding_location(uri, facts.module_name, token.lexeme, binding)
+                location ||= module_member_definition_location(uri, facts.module_name, token.lexeme)
+              else
+                if imported_module_name
+                  location = module_member_definition_location(uri, imported_module_name, token.lexeme) || module_definition_location(uri, imported_module_name)
+                elsif facts.imports.key?(token.lexeme)
+                  module_name = facts.imports.fetch(token.lexeme).name
+                  location = module_member_definition_location(uri, module_name, token.lexeme)
+                  location ||= module_definition_location(uri, module_name)
+                elsif (module_name = imported_module_name_from_ast(uri, token.lexeme))
+                  location = module_definition_location(uri, module_name)
+                end
               end
+
+              location
             end
 
-            location
+            return facts_location if facts_location
           end
 
-          return facts_location if facts_location
-        end
-
-        return nil if token_index && is_builtin_name?(token.lexeme, tokens, token_index)
+          return nil if token_index && is_builtin_name?(token.lexeme, tokens, token_index)
 
-        if facts && token_index && !facts_location
-          local_location = measure_perf_stage(stages, 'local_binding') do
-            name = token.lexeme
-            line = lsp_line + 1
-            char = lsp_char + 1
-            local_binding = resolve_local_hover_binding(facts, name, line, char)
-            next nil unless local_binding
+          if facts && token_index && !facts_location
+            local_location = measure_perf_stage(stages, 'local_binding') do
+              name = token.lexeme
+              line = lsp_line + 1
+              char = lsp_char + 1
+              local_binding = resolve_local_hover_binding(facts, name, line, char)
+              next nil unless local_binding
 
-            ast_node = local_binding.respond_to?(:ast) ? local_binding.ast : nil
-            if ast_node&.line && ast_node.respond_to?(:column) && ast_node.column
-              {
-                uri: uri,
-                range: {
-                  start: { line: ast_node.line - 1, character: ast_node.column - 1 },
-                  end: { line: ast_node.line - 1, character: ast_node.column - 1 + name.length }
-                }
-              }
-            else
-              declaration_node = find_local_declaration_ast_node(uri, name, line)
-              if declaration_node
+              ast_node = local_binding.respond_to?(:ast) ? local_binding.ast : nil
+              if ast_node&.line && ast_node.column
                 {
                   uri: uri,
                   range: {
-                    start: { line: declaration_node.line - 1, character: declaration_node.column - 1 },
-                    end: { line: declaration_node.line - 1, character: declaration_node.column - 1 + name.length }
+                    start: { line: ast_node.line - 1, character: ast_node.column - 1 },
+                    end: { line: ast_node.line - 1, character: ast_node.column - 1 + name.length }
                   }
                 }
+              else
+                declaration_node = find_local_declaration_ast_node(uri, name, line)
+                if declaration_node
+                  {
+                    uri: uri,
+                    range: {
+                      start: { line: declaration_node.line - 1, character: declaration_node.column - 1 },
+                      end: { line: declaration_node.line - 1, character: declaration_node.column - 1 + name.length }
+                    }
+                  }
+                end
               end
             end
+            return local_location if local_location
           end
-          return local_location if local_location
-        end
 
-        found = measure_perf_stage(stages, 'global_lookup') do
-          @workspace.find_definition_token_global(
-            token.lexeme,
-            preferred_uri: uri,
-            before_line: lsp_line + 1,
-            before_char: lsp_char + 1,
-          )
-        end
-        return nil unless found
+          found = measure_perf_stage(stages, 'global_lookup') do
+            @workspace.find_definition_token_global(
+              token.lexeme,
+              preferred_uri: uri,
+              before_line: lsp_line + 1,
+              before_char: lsp_char + 1,
+            )
+          end
+          return nil unless found
 
-        {
-          uri: found[:uri],
-          range: token_to_range(found[:token])
-        }
-      end
+          {
+            uri: found[:uri],
+            range: token_to_range(found[:token])
+          }
+        end
 
-      def find_local_declaration_ast_node(uri, name, before_line)
-        ast = @workspace.get_ast(uri)
-        return nil unless ast
+        def find_local_declaration_ast_node(uri, name, before_line)
+          ast = @workspace.get_ast(uri)
+          return nil unless ast
 
-        result = nil
-        find_local_decl_node(ast, name, before_line) { |node| result = node; true }
-        result
-      end
+          result = nil
+          find_local_decl_node(ast, name, before_line) { |node| result = node; true }
+          result
+        end
 
-      def find_local_decl_node(node, name, before_line, &block)
-        return false if node.nil?
+        def find_local_decl_node(node, name, before_line, &block)
+          return false if node.nil?
 
-        if (node.is_a?(AST::LocalDecl) || node.is_a?(AST::ForBinding)) && node.name == name && node.line && node.line < before_line
-          return true if yield node
-        end
+          if (node.is_a?(AST::LocalDecl) || node.is_a?(AST::ForBinding)) && node.name == name && node.line && node.line < before_line
+            return true if yield node
+          end
 
-        if node.is_a?(Array)
-          node.each { |item| return true if find_local_decl_node(item, name, before_line, &block) }
-          return false
-        end
+          if node.is_a?(Array)
+            node.each { |item| return true if find_local_decl_node(item, name, before_line, &block) }
+            return false
+          end
 
-        return false unless node.class.name&.start_with?("MilkTea::AST::")
+          return false unless node.class.name&.start_with?("MilkTea::AST::")
 
-        if node.respond_to?(:members)
-          node.members.each do |member|
-            next unless member.is_a?(Symbol)
-            return true if find_local_decl_node(node.public_send(member), name, before_line, &block)
+          if node.respond_to?(:members)
+            node.members.each do |member|
+              next unless member.is_a?(Symbol)
+              return true if find_local_decl_node(node.public_send(member), name, before_line, &block)
+            end
           end
-        end
 
-        false
-      end
+          false
+        end
 
-      def resolve_field_member_definition_location(current_uri, facts, tokens, token_index)
-        chain = member_access_chain_at(tokens, token_index)
-        return nil unless chain
+        def resolve_field_member_definition_location(current_uri, facts, tokens, token_index)
+          chain = member_access_chain_at(tokens, token_index)
+          return nil unless chain
 
-        hovered_segment = chain[:segments].find { |segment| segment[:token_index] == token_index }
-        return nil unless hovered_segment && hovered_segment[:position].positive?
+          hovered_segment = chain[:segments].find { |segment| segment[:token_index] == token_index }
+          return nil unless hovered_segment && hovered_segment[:position].positive?
 
-        current_type = resolve_dot_receiver_value_type(
-          facts,
-          chain[:segments].first[:name],
-          chain[:line],
-          chain[:char],
-        )
-        unless current_type
-          first_name = chain[:segments].first[:name]
-          current_type = facts.types[first_name]
-        end
-        return nil unless current_type
+          current_type = resolve_dot_receiver_value_type(
+            facts,
+            chain[:segments].first[:name],
+            chain[:line],
+            chain[:char],
+          )
+          unless current_type
+            first_name = chain[:segments].first[:name]
+            current_type = facts.types[first_name]
+          end
+          return nil unless current_type
 
-          chain[:segments][1..hovered_segment[:position]].each do |segment|
-            field_receiver_type = project_field_receiver_type_for_completion(current_type, facts)
-            if field_receiver_type.respond_to?(:field) && (field_type = field_receiver_type.field(segment[:name]))
-              return field_definition_location(current_uri, field_receiver_type, segment[:name]) if segment[:token_index] == token_index
+            chain[:segments][1..hovered_segment[:position]].each do |segment|
+              field_receiver_type = project_field_receiver_type_for_completion(current_type, facts)
+              if field_receiver_type.respond_to?(:field) && (field_type = field_receiver_type.field(segment[:name]))
+                return field_definition_location(current_uri, field_receiver_type, segment[:name]) if segment[:token_index] == token_index
 
-              current_type = field_type
-              next
-            end
+                current_type = field_type
+                next
+              end
 
-            if current_type.respond_to?(:nested_types) && (nested = current_type.nested_types[segment[:name]])
-              if segment[:token_index] == token_index
-                decl = nested.respond_to?(:ast_declaration) ? nested.ast_declaration : nil
-                if decl&.line && decl.respond_to?(:column) && decl.column
-                  return {
-                    uri: current_uri,
-                    range: {
-                      start: { line: decl.line - 1, character: decl.column - 1 },
-                      end: { line: decl.line - 1, character: decl.column - 1 + segment[:name].length },
-                    },
-                  }
+              if current_type.respond_to?(:nested_types) && (nested = current_type.nested_types[segment[:name]])
+                if segment[:token_index] == token_index
+                  decl = nested.respond_to?(:ast_declaration) ? nested.ast_declaration : nil
+                  if decl&.line && decl.column
+                    return {
+                      uri: current_uri,
+                      range: {
+                        start: { line: decl.line - 1, character: decl.column - 1 },
+                        end: { line: decl.line - 1, character: decl.column - 1 + segment[:name].length },
+                      },
+                    }
+                  end
+                  return nil
                 end
-                return nil
+                current_type = nested
+                next
               end
-              current_type = nested
-              next
-            end
 
-            if segment[:token_index] == token_index
-              method_receiver_type = project_method_receiver_type_for_completion(current_type)
-              method_info = member_method_info_for_receiver_type(facts, method_receiver_type, segment[:name])
-              return nil unless method_info
+              if segment[:token_index] == token_index
+                method_receiver_type = project_method_receiver_type_for_completion(current_type)
+                method_info = member_method_info_for_receiver_type(facts, method_receiver_type, segment[:name])
+                return nil unless method_info
 
-              return module_member_binding_location(current_uri, method_info[:module_name], segment[:name], method_info[:binding]) ||
-                module_member_definition_location(current_uri, method_info[:module_name], segment[:name])
-            end
+                return module_member_binding_location(current_uri, method_info[:module_name], segment[:name], method_info[:binding]) ||
+                  module_member_definition_location(current_uri, method_info[:module_name], segment[:name])
+              end
 
-          break
+            break
+          end
+
+          nil
         end
 
-        nil
-      end
+        def resolve_type_definition_location(params, stages: nil)
+          uri      = params['textDocument']['uri']
+          lsp_line = params['position']['line']
+          lsp_char = params['position']['character']
 
-      def resolve_type_definition_location(params, stages: nil)
-        uri      = params['textDocument']['uri']
-        lsp_line = params['position']['line']
-        lsp_char = params['position']['character']
+          context = measure_perf_stage(stages, 'context') { token_context_at(uri, lsp_line, lsp_char) }
+          token = context&.fetch(:token, nil)
+          return nil unless token&.type == :identifier
 
-        context = measure_perf_stage(stages, 'context') { token_context_at(uri, lsp_line, lsp_char) }
-        token = context&.fetch(:token, nil)
-        return nil unless token&.type == :identifier
+          name = token.lexeme
+          tokens = context[:tokens]
+          token_index = context[:token_index]
 
-        name = token.lexeme
-        tokens = context[:tokens]
-        token_index = context[:token_index]
+          import_info = token_index ? measure_perf_stage(stages, 'import_path') { import_path_info_at(tokens, token_index) } : nil
+          if import_info
+            return module_definition_location(uri, import_info[:module_name])
+          end
 
-        import_info = token_index ? measure_perf_stage(stages, 'import_path') { import_path_info_at(tokens, token_index) } : nil
-        if import_info
-          return module_definition_location(uri, import_info[:module_name])
-        end
+          facts = measure_perf_stage(stages, 'facts') { @workspace.get_facts(uri) }
+          return nil unless facts
 
-        facts = measure_perf_stage(stages, 'facts') { @workspace.get_facts(uri) }
-        return nil unless facts
+          dot_receiver = @workspace.find_dot_receiver(uri, lsp_line, lsp_char)
+          imported_module_name = dot_receiver ? (facts.imports[dot_receiver]&.name || imported_module_name_from_ast(uri, dot_receiver)) : nil
 
-        dot_receiver = @workspace.find_dot_receiver(uri, lsp_line, lsp_char)
-        imported_module_name = dot_receiver ? (facts.imports[dot_receiver]&.name || imported_module_name_from_ast(uri, dot_receiver)) : nil
+          if facts.types.key?(name) || facts.interfaces.key?(name)
+            return module_member_definition_location(uri, facts.module_name, name)
+          end
 
-        if facts.types.key?(name) || facts.interfaces.key?(name)
-          return module_member_definition_location(uri, facts.module_name, name)
-        end
+          if token_index && imported_module_name && module_member_access_info(tokens, token_index)
+            return module_member_definition_location(uri, imported_module_name, name) ||
+                  module_definition_location(uri, imported_module_name)
+          end
 
-        if token_index && imported_module_name && module_member_access_info(tokens, token_index)
-          return module_member_definition_location(uri, imported_module_name, name) ||
-                 module_definition_location(uri, imported_module_name)
-        end
+          if imported_module_name && (facts.types.key?(imported_module_name) || facts.interfaces.key?(imported_module_name))
+            return module_member_definition_location(uri, imported_module_name, name) ||
+                  module_definition_location(uri, imported_module_name)
+          end
 
-        if imported_module_name && (facts.types.key?(imported_module_name) || facts.interfaces.key?(imported_module_name))
-          return module_member_definition_location(uri, imported_module_name, name) ||
-                 module_definition_location(uri, imported_module_name)
+          handle_definition_request('textDocument/typeDefinition', params, error_label: 'typeDefinition')
         end
 
-        handle_definition_request('textDocument/typeDefinition', params, error_label: 'typeDefinition')
-      end
+        def resolve_implementation_locations(params, stages: nil)
+          uri      = params['textDocument']['uri']
+          lsp_line = params['position']['line']
+          lsp_char = params['position']['character']
 
-      def resolve_implementation_locations(params, stages: nil)
-        uri      = params['textDocument']['uri']
-        lsp_line = params['position']['line']
-        lsp_char = params['position']['character']
+          token = measure_perf_stage(stages, 'token') { @workspace.find_token_at(uri, lsp_line, lsp_char) }
+          return [] unless token&.type == :identifier
 
-        token = measure_perf_stage(stages, 'token') { @workspace.find_token_at(uri, lsp_line, lsp_char) }
-        return [] unless token&.type == :identifier
+          facts = measure_perf_stage(stages, 'facts') { @workspace.get_facts(uri) }
+          return [] unless facts
 
-        facts = measure_perf_stage(stages, 'facts') { @workspace.get_facts(uri) }
-        return [] unless facts
+          target = measure_perf_stage(stages, 'target_lookup') { resolve_interface_method_target_at_token(facts, token) }
+          if target
+            return measure_perf_stage(stages, 'implementation_lookup') do
+              interface_method_implementation_locations(target[:interface], target[:method])
+            end
+          end
 
-        target = measure_perf_stage(stages, 'target_lookup') { resolve_interface_method_target_at_token(facts, token) }
-        if target
-          return measure_perf_stage(stages, 'implementation_lookup') do
-            interface_method_implementation_locations(target[:interface], target[:method])
+          interface_binding = measure_perf_stage(stages, 'binding_lookup') do
+            resolve_interface_binding_at_position(uri, facts, token, lsp_line, lsp_char)
           end
-        end
+          return [] unless interface_binding
 
-        interface_binding = measure_perf_stage(stages, 'binding_lookup') do
-          resolve_interface_binding_at_position(uri, facts, token, lsp_line, lsp_char)
+          measure_perf_stage(stages, 'implementation_lookup') { interface_implementation_locations(interface_binding) }
         end
-        return [] unless interface_binding
 
-        measure_perf_stage(stages, 'implementation_lookup') { interface_implementation_locations(interface_binding) }
-      end
-
-      def module_definition_location(current_uri, module_name)
-        path = module_path_for_name(current_uri, module_name)
-        return nil unless path
+        def module_definition_location(current_uri, module_name)
+          path = module_path_for_name(current_uri, module_name)
+          return nil unless path
 
-        {
-          uri: path_to_uri(File.expand_path(path)),
-          range: {
-            start: { line: 0, character: 0 },
-            end: { line: 0, character: 0 }
+          {
+            uri: path_to_uri(File.expand_path(path)),
+            range: {
+              start: { line: 0, character: 0 },
+              end: { line: 0, character: 0 }
+            }
           }
-        }
-      end
+        end
 
-      def module_member_definition_location(current_uri, module_name, member_name)
-        path = module_path_for_name(current_uri, module_name)
-        return nil unless path
+        def module_member_definition_location(current_uri, module_name, member_name)
+          path = module_path_for_name(current_uri, module_name)
+          return nil unless path
 
-        token = find_definition_token_in_file(path, member_name)
-        return nil unless token
+          token = find_definition_token_in_file(path, member_name)
+          return nil unless token
 
-        {
-          uri: path_to_uri(File.expand_path(path)),
-          range: token_to_range(token)
-        }
-      end
+          {
+            uri: path_to_uri(File.expand_path(path)),
+            range: token_to_range(token)
+          }
+        end
 
-      def field_definition_location(current_uri, receiver_type, field_name)
-        owner_type = field_owner_type(receiver_type)
-        return nil unless owner_type&.respond_to?(:name)
+        def field_definition_location(current_uri, receiver_type, field_name)
+          owner_type = field_owner_type(receiver_type)
+          return nil unless owner_type&.respond_to?(:name)
 
-        path = module_path_for_name(current_uri, owner_type.module_name)
-        return nil unless path
+          path = module_path_for_name(current_uri, owner_type.module_name)
+          return nil unless path
 
-        token = find_field_token_in_type(path, owner_type.name, field_name, current_uri: current_uri)
-        return nil unless token
+          token = find_field_token_in_type(path, owner_type.name, field_name, current_uri: current_uri)
+          return nil unless token
 
-        {
-          uri: path_to_uri(File.expand_path(path)),
-          range: token_to_range(token)
-        }
-      end
+          {
+            uri: path_to_uri(File.expand_path(path)),
+            range: token_to_range(token)
+          }
+        end
 
-      def enum_member_definition_location(current_uri, module_name, type_name, member_name)
-        path = module_path_for_name(current_uri, module_name)
-        return nil unless path
+        def enum_member_definition_location(current_uri, module_name, type_name, member_name)
+          path = module_path_for_name(current_uri, module_name)
+          return nil unless path
 
-        token = find_enum_member_token_in_file(path, type_name, member_name)
-        return nil unless token
+          token = find_enum_member_token_in_file(path, type_name, member_name)
+          return nil unless token
 
-        {
-          uri: path_to_uri(File.expand_path(path)),
-          range: token_to_range(token)
-        }
-      end
+          {
+            uri: path_to_uri(File.expand_path(path)),
+            range: token_to_range(token)
+          }
+        end
 
-      def module_member_binding_location(current_uri, module_name, member_name, binding)
-        path = module_path_for_name(current_uri, module_name)
-        return nil unless path
+        def module_member_binding_location(current_uri, module_name, member_name, binding)
+          path = module_path_for_name(current_uri, module_name)
+          return nil unless path
 
-        ast = binding.respond_to?(:ast) ? binding.ast : nil
-        if ast&.line && ast.respond_to?(:column) && ast.column
-          start_line = ast.line - 1
-          start_char = ast.column - 1
+          ast = binding.respond_to?(:ast) ? binding.ast : nil
+          if ast&.line && ast.column
+            start_line = ast.line - 1
+            start_char = ast.column - 1
 
-          return {
-            uri: path_to_uri(File.expand_path(path)),
-            range: {
-              start: { line: start_line, character: start_char },
-              end: { line: start_line, character: start_char + member_name.length }
+            return {
+              uri: path_to_uri(File.expand_path(path)),
+              range: {
+                start: { line: start_line, character: start_char },
+                end: { line: start_line, character: start_char + member_name.length }
+              }
             }
-          }
-        end
+          end
 
-        module_member_definition_location(current_uri, module_name, member_name)
-      end
+          module_member_definition_location(current_uri, module_name, member_name)
+        end
 
-      def module_path_for_name(current_uri, module_name)
-        current_path = uri_to_path(current_uri)
-        return nil unless current_path
-        return current_path if module_name.nil? || module_name.empty?
+        def module_path_for_name(current_uri, module_name)
+          current_path = uri_to_path(current_uri)
+          return nil unless current_path
+          return current_path if module_name.nil? || module_name.empty?
 
-        current_facts = @workspace.get_facts(current_uri)
-        return current_path if current_facts&.module_name == module_name
+          current_facts = @workspace.get_facts(current_uri)
+          return current_path if current_facts&.module_name == module_name
 
-        resolution = DependencyResolution.resolve(current_path, mode: @workspace.dependency_resolution_mode)
-        module_roots = if resolution.ok?
-                         MilkTea::ModuleRoots.roots_for_path(current_path, locked: resolution.locked)
-                       else
-                         MilkTea::ModuleRoots.roots_for_path(current_path)
-                       end
-        relative_path = File.join(*module_name.split('.')) + '.mt'
-        resolved_path = module_roots.lazy.map { |root| File.join(root, relative_path) }.find { |candidate| File.file?(candidate) }
-        return resolved_path if resolved_path
+          resolution = DependencyResolution.resolve(current_path, mode: @workspace.dependency_resolution_mode)
+          module_roots = if resolution.ok?
+            MilkTea::ModuleRoots.roots_for_path(current_path, locked: resolution.locked)
+          else
+            MilkTea::ModuleRoots.roots_for_path(current_path)
+          end
+          relative_path = File.join(*module_name.split('.')) + '.mt'
+          resolved_path = module_roots.lazy.map { |root| File.join(root, relative_path) }.find { |candidate| File.file?(candidate) }
+          return resolved_path if resolved_path
 
-        workspace_root = @root_uri ? uri_to_path(@root_uri) : nil
-        return nil unless workspace_root && File.directory?(workspace_root)
+          workspace_root = @root_uri ? uri_to_path(@root_uri) : nil
+          return nil unless workspace_root && File.directory?(workspace_root)
 
-        workspace_candidate = File.join(workspace_root, relative_path)
-        return workspace_candidate if File.file?(workspace_candidate)
+          workspace_candidate = File.join(workspace_root, relative_path)
+          return workspace_candidate if File.file?(workspace_candidate)
 
-        nil
-      rescue PackageLockError
-        module_roots = MilkTea::ModuleRoots.roots_for_path(current_path)
-        relative_path = File.join(*module_name.split('.')) + '.mt'
-        resolved_path = module_roots.lazy.map { |root| File.join(root, relative_path) }.find { |candidate| File.file?(candidate) }
-        return resolved_path if resolved_path
+          nil
+        rescue PackageLockError
+          module_roots = MilkTea::ModuleRoots.roots_for_path(current_path)
+          relative_path = File.join(*module_name.split('.')) + '.mt'
+          resolved_path = module_roots.lazy.map { |root| File.join(root, relative_path) }.find { |candidate| File.file?(candidate) }
+          return resolved_path if resolved_path
 
-        workspace_root = @root_uri ? uri_to_path(@root_uri) : nil
-        return nil unless workspace_root && File.directory?(workspace_root)
+          workspace_root = @root_uri ? uri_to_path(@root_uri) : nil
+          return nil unless workspace_root && File.directory?(workspace_root)
 
-        workspace_candidate = File.join(workspace_root, relative_path)
-        return workspace_candidate if File.file?(workspace_candidate)
+          workspace_candidate = File.join(workspace_root, relative_path)
+          return workspace_candidate if File.file?(workspace_candidate)
 
-        nil
-      end
+          nil
+        end
 
-      def imported_module_name_from_ast(uri, alias_name)
-        return nil if alias_name.nil? || alias_name.empty?
+        def imported_module_name_from_ast(uri, alias_name)
+          return nil if alias_name.nil? || alias_name.empty?
 
-        ast = @workspace.get_ast(uri)
-        return nil unless ast
+          ast = @workspace.get_ast(uri)
+          return nil unless ast
 
-        import = ast.imports.find do |entry|
-          resolved_alias = entry.alias_name || entry.path.parts.last
-          resolved_alias == alias_name
+          import = ast.imports.find do |entry|
+            resolved_alias = entry.alias_name || entry.path.parts.last
+            resolved_alias == alias_name
+          end
+          import&.path&.to_s
+        rescue StandardError
+          nil
         end
-        import&.path&.to_s
-      rescue StandardError
-        nil
-      end
 
-      def find_definition_token_in_file(path, name)
-        tokens = definition_file_tokens(path)
+        def find_definition_token_in_file(path, name)
+          tokens = definition_file_tokens(path)
 
-        tokens.each_cons(2) do |kw_tok, id_tok|
-          next unless MilkTea::LSP::Workspace::DEFINITION_KEYWORDS.include?(kw_tok.type)
-          next unless id_tok.type == :identifier && id_tok.lexeme == name
+          tokens.each_cons(2) do |kw_tok, id_tok|
+            next unless MilkTea::LSP::Workspace::DEFINITION_KEYWORDS.include?(kw_tok.type)
+            next unless id_tok.type == :identifier && id_tok.lexeme == name
 
-          return id_tok
+            return id_tok
+          end
+
+          nil
+        rescue StandardError
+          nil
         end
 
-        nil
-      rescue StandardError
-        nil
-      end
+        def find_field_token_in_type(path, type_name, field_name, current_uri: nil)
+          tokens = definition_lookup_tokens(path, current_uri: current_uri)
 
-      def find_field_token_in_type(path, type_name, field_name, current_uri: nil)
-        tokens = definition_lookup_tokens(path, current_uri: current_uri)
+          tokens.each_with_index do |token, index|
+            next unless [:struct, :union].include?(token.type)
 
-        tokens.each_with_index do |token, index|
-          next unless [:struct, :union].include?(token.type)
+            name_index = next_non_trivia_token_index(tokens, index + 1)
+            next unless name_index && tokens[name_index].type == :identifier && tokens[name_index].lexeme == type_name
 
-          name_index = next_non_trivia_token_index(tokens, index + 1)
-          next unless name_index && tokens[name_index].type == :identifier && tokens[name_index].lexeme == type_name
+            field_token = find_field_token_in_body(tokens, index, field_name)
+            return field_token if field_token
+          end
 
-          field_token = find_field_token_in_body(tokens, index, field_name)
-          return field_token if field_token
+          nil
+        rescue StandardError
+          nil
         end
 
-        nil
-      rescue StandardError
-        nil
-      end
+        def find_field_token_in_body(tokens, header_index, field_name)
+          header = tokens[header_index]
+          i = header_index + 1
 
-      def find_field_token_in_body(tokens, header_index, field_name)
-        header = tokens[header_index]
-        i = header_index + 1
+          while i < tokens.length
+            token = tokens[i]
 
-        while i < tokens.length
-          token = tokens[i]
+            if token.line > header.line && ![:newline, :indent, :dedent, :eof].include?(token.type) &&
+                first_non_trivia_token_on_line?(tokens, i) && token.column <= header.column
+              break
+            end
 
-          if token.line > header.line && ![:newline, :indent, :dedent, :eof].include?(token.type) &&
-              first_non_trivia_token_on_line?(tokens, i) && token.column <= header.column
-            break
-          end
+            if token.type == :identifier && token.lexeme == field_name && token.line > header.line &&
+                first_non_trivia_token_on_line?(tokens, i) && token.column > header.column
+              colon_index = next_non_trivia_token_index(tokens, i + 1)
+              return token if colon_index && tokens[colon_index].type == :colon
+            end
 
-          if token.type == :identifier && token.lexeme == field_name && token.line > header.line &&
-              first_non_trivia_token_on_line?(tokens, i) && token.column > header.column
-            colon_index = next_non_trivia_token_index(tokens, i + 1)
-            return token if colon_index && tokens[colon_index].type == :colon
+            i += 1
           end
 
-          i += 1
+          nil
         end
 
-        nil
-      end
+        def find_enum_member_token_in_file(path, type_name, member_name)
+          tokens = definition_file_tokens(path)
 
-      def find_enum_member_token_in_file(path, type_name, member_name)
-        tokens = definition_file_tokens(path)
+          tokens.each_with_index do |token, index|
+            next unless [:enum, :flags].include?(token.type)
 
-        tokens.each_with_index do |token, index|
-          next unless [:enum, :flags].include?(token.type)
+            name_index = next_non_trivia_token_index(tokens, index + 1)
+            next unless name_index && tokens[name_index].type == :identifier && tokens[name_index].lexeme == type_name
 
-          name_index = next_non_trivia_token_index(tokens, index + 1)
-          next unless name_index && tokens[name_index].type == :identifier && tokens[name_index].lexeme == type_name
+            member_token = find_enum_member_token_in_body(tokens, index, member_name)
+            return member_token if member_token
+          end
 
-          member_token = find_enum_member_token_in_body(tokens, index, member_name)
-          return member_token if member_token
+          nil
+        rescue StandardError
+          nil
         end
 
-        nil
-      rescue StandardError
-        nil
-      end
+        def find_enum_member_token_in_body(tokens, header_index, member_name)
+          header = tokens[header_index]
+          i = header_index + 1
 
-      def find_enum_member_token_in_body(tokens, header_index, member_name)
-        header = tokens[header_index]
-        i = header_index + 1
+          while i < tokens.length
+            token = tokens[i]
 
-        while i < tokens.length
-          token = tokens[i]
+            if token.line > header.line && ![:newline, :indent, :dedent, :eof].include?(token.type) &&
+                first_non_trivia_token_on_line?(tokens, i) && token.column <= header.column
+              break
+            end
 
-          if token.line > header.line && ![:newline, :indent, :dedent, :eof].include?(token.type) &&
-              first_non_trivia_token_on_line?(tokens, i) && token.column <= header.column
-            break
-          end
+            if token.type == :identifier && token.lexeme == member_name && token.line > header.line &&
+                first_non_trivia_token_on_line?(tokens, i) && token.column > header.column
+              return token
+            end
 
-          if token.type == :identifier && token.lexeme == member_name && token.line > header.line &&
-              first_non_trivia_token_on_line?(tokens, i) && token.column > header.column
-            return token
+            i += 1
           end
 
-          i += 1
+          nil
         end
 
-        nil
-      end
+        def enum_member_value_text(current_uri, module_name, type_name, member_name)
+          path = module_path_for_name(current_uri, module_name)
+          return nil unless path
 
-      def enum_member_value_text(current_uri, module_name, type_name, member_name)
-        path = module_path_for_name(current_uri, module_name)
-        return nil unless path
+          declaration = definition_file_ast(path)&.declarations&.find do |decl|
+            (decl.is_a?(AST::EnumDecl) || decl.is_a?(AST::FlagsDecl)) && decl.name == type_name
+          end
+          return nil unless declaration
 
-        declaration = definition_file_ast(path)&.declarations&.find do |decl|
-          (decl.is_a?(AST::EnumDecl) || decl.is_a?(AST::FlagsDecl)) && decl.name == type_name
+          member = declaration.members.find { |candidate| candidate.name == member_name }
+          return nil unless member&.value
+
+          MilkTea::PrettyPrinter::ASTFormatter.new.send(:render_expression, member.value)
+        rescue StandardError
+          nil
         end
-        return nil unless declaration
 
-        member = declaration.members.find { |candidate| candidate.name == member_name }
-        return nil unless member&.value
+        def definition_file_mtime_key(path)
+          stat = File.stat(path)
+          "#{stat.mtime.to_i}:#{stat.mtime.nsec}"
+        rescue StandardError
+          'missing'
+        end
 
-        MilkTea::PrettyPrinter::ASTFormatter.new.send(:render_expression, member.value)
-      rescue StandardError
-        nil
-      end
+        def definition_file_tokens(path, mtime_key: nil)
+          cache_key = "#{path}:#{mtime_key || definition_file_mtime_key(path)}"
+          @definition_file_token_cache[cache_key] ||= begin
+            MilkTea::Lexer.lex(File.read(path), path: path_to_uri(path))
+          end
+        end
 
-      def definition_file_mtime_key(path)
-        stat = File.stat(path)
-        "#{stat.mtime.to_i}:#{stat.mtime.nsec}"
-      rescue StandardError
-        'missing'
-      end
+        def definition_lookup_tokens(path, current_uri: nil)
+          current_path = current_uri ? uri_to_path(current_uri) : nil
+          if current_path && File.expand_path(current_path) == File.expand_path(path)
+            workspace_tokens = @workspace.get_tokens(current_uri)
+            return workspace_tokens if workspace_tokens
+          end
 
-      def definition_file_tokens(path, mtime_key: nil)
-        cache_key = "#{path}:#{mtime_key || definition_file_mtime_key(path)}"
-        @definition_file_token_cache[cache_key] ||= begin
-          MilkTea::Lexer.lex(File.read(path), path: path_to_uri(path))
+          definition_file_tokens(path)
         end
-      end
 
-      def definition_lookup_tokens(path, current_uri: nil)
-        current_path = current_uri ? uri_to_path(current_uri) : nil
-        if current_path && File.expand_path(current_path) == File.expand_path(path)
-          workspace_tokens = @workspace.get_tokens(current_uri)
-          return workspace_tokens if workspace_tokens
+        def definition_file_ast(path)
+          mtime_key = definition_file_mtime_key(path)
+          cache_key = "#{path}:#{mtime_key}"
+          @definition_file_ast_cache[cache_key] ||= begin
+            MilkTea::Parser.parse(nil, path: path_to_uri(path), tokens: definition_file_tokens(path, mtime_key: mtime_key))
+          end
         end
 
-        definition_file_tokens(path)
-      end
-
-      def definition_file_ast(path)
-        mtime_key = definition_file_mtime_key(path)
-        cache_key = "#{path}:#{mtime_key}"
-        @definition_file_ast_cache[cache_key] ||= begin
-          MilkTea::Parser.parse(nil, path: path_to_uri(path), tokens: definition_file_tokens(path, mtime_key: mtime_key))
-        end
-      end
+        def resolve_interface_binding_at_position(uri, facts, token, lsp_line, lsp_char)
+          binding = facts.interfaces[token.lexeme]
+          return binding if binding
 
-      def resolve_interface_binding_at_position(uri, facts, token, lsp_line, lsp_char)
-        binding = facts.interfaces[token.lexeme]
-        return binding if binding
+          dot_receiver = @workspace.find_dot_receiver(uri, lsp_line, lsp_char)
+          return nil unless dot_receiver
 
-        dot_receiver = @workspace.find_dot_receiver(uri, lsp_line, lsp_char)
-        return nil unless dot_receiver
+          facts.imports[dot_receiver]&.interfaces&.fetch(token.lexeme, nil)
+        end
 
-        facts.imports[dot_receiver]&.interfaces&.fetch(token.lexeme, nil)
-      end
+        def resolve_interface_method_target_at_token(facts, token)
+          facts.interfaces.each_value do |interface_binding|
+            method_binding = interface_binding.methods[token.lexeme]
+            next unless method_binding
+            next unless method_binding.ast.line == token.line
+            next unless method_binding.ast.column == token.column
 
-      def resolve_interface_method_target_at_token(facts, token)
-        facts.interfaces.each_value do |interface_binding|
-          method_binding = interface_binding.methods[token.lexeme]
-          next unless method_binding
-          next unless method_binding.ast.line == token.line
-          next unless method_binding.ast.respond_to?(:column) && method_binding.ast.column == token.column
+            return { interface: interface_binding, method: method_binding }
+          end
 
-          return { interface: interface_binding, method: method_binding }
+          nil
         end
 
-        nil
-      end
+        def interface_implementation_locations(interface_binding)
+          seen = Set.new
+          @workspace.all_documents.filter_map do |doc_uri|
+            facts = @workspace.get_facts(doc_uri)
+            next unless facts
 
-      def interface_implementation_locations(interface_binding)
-        seen = Set.new
-        @workspace.all_documents.filter_map do |doc_uri|
-          facts = @workspace.get_facts(doc_uri)
-          next unless facts
+            facts.implemented_interfaces.each_with_object([]) do |(receiver_type, interfaces), locations|
+              next unless interfaces.any? { |candidate| same_interface_binding?(candidate, interface_binding) }
 
-          facts.implemented_interfaces.each_with_object([]) do |(receiver_type, interfaces), locations|
-            next unless interfaces.any? { |candidate| same_interface_binding?(candidate, interface_binding) }
+              location = interface_receiver_definition_location(doc_uri, receiver_type)
+              next unless location
 
-            location = interface_receiver_definition_location(doc_uri, receiver_type)
-            next unless location
+              key = [location[:uri], location.dig(:range, :start, :line), location.dig(:range, :start, :character)]
+              next if seen.include?(key)
 
-            key = [location[:uri], location.dig(:range, :start, :line), location.dig(:range, :start, :character)]
-            next if seen.include?(key)
+              seen << key
+              locations << location
+            end
+          end.flatten
+        end
 
-            seen << key
-            locations << location
-          end
-        end.flatten
-      end
+        def interface_method_implementation_locations(interface_binding, interface_method)
+          seen = Set.new
+          @workspace.all_documents.filter_map do |doc_uri|
+            facts = @workspace.get_facts(doc_uri)
+            next unless facts
 
-      def interface_method_implementation_locations(interface_binding, interface_method)
-        seen = Set.new
-        @workspace.all_documents.filter_map do |doc_uri|
-          facts = @workspace.get_facts(doc_uri)
-          next unless facts
+            facts.implemented_interfaces.each_with_object([]) do |(receiver_type, interfaces), locations|
+              next unless interfaces.any? { |candidate| same_interface_binding?(candidate, interface_binding) }
 
-          facts.implemented_interfaces.each_with_object([]) do |(receiver_type, interfaces), locations|
-            next unless interfaces.any? { |candidate| same_interface_binding?(candidate, interface_binding) }
+              method = methods_for_receiver_type(facts, receiver_type)[interface_method.name]
+              next unless method
 
-            method = methods_for_receiver_type(facts, receiver_type)[interface_method.name]
-            next unless method
+              module_name = receiver_module_name(receiver_type)
+              location = module_member_binding_location(doc_uri, module_name, interface_method.name, method)
+              location ||= module_member_definition_location(doc_uri, module_name, interface_method.name)
+              next unless location
 
-            module_name = receiver_module_name(receiver_type)
-            location = module_member_binding_location(doc_uri, module_name, interface_method.name, method)
-            location ||= module_member_definition_location(doc_uri, module_name, interface_method.name)
-            next unless location
+              key = [location[:uri], location.dig(:range, :start, :line), location.dig(:range, :start, :character)]
+              next if seen.include?(key)
 
-            key = [location[:uri], location.dig(:range, :start, :line), location.dig(:range, :start, :character)]
-            next if seen.include?(key)
+              seen << key
+              locations << location
+            end
+          end.flatten
+        end
 
-            seen << key
-            locations << location
-          end
-        end.flatten
-      end
+        def interface_receiver_definition_location(current_uri, receiver_type)
+          receiver_type = receiver_type.definition if receiver_type.is_a?(Types::StructInstance) || receiver_type.is_a?(Types::VariantInstance)
 
-      def interface_receiver_definition_location(current_uri, receiver_type)
-        receiver_type = receiver_type.definition if receiver_type.is_a?(Types::StructInstance) || receiver_type.is_a?(Types::VariantInstance)
+          if receiver_type.module_name.nil? || receiver_type.module_name.empty?
+            token = local_type_definition_token(current_uri, receiver_type.name)
+            token ||= @workspace.find_definition_token(current_uri, receiver_type.name)
+            return { uri: current_uri, range: token_to_range(token) } if token
+          end
 
-        if receiver_type.module_name.nil? || receiver_type.module_name.empty?
-          token = local_type_definition_token(current_uri, receiver_type.name)
-          token ||= @workspace.find_definition_token(current_uri, receiver_type.name)
-          return { uri: current_uri, range: token_to_range(token) } if token
+          module_member_definition_location(current_uri, receiver_type.module_name, receiver_type.name)
         end
 
-        module_member_definition_location(current_uri, receiver_type.module_name, receiver_type.name)
-      end
+        def receiver_module_name(receiver_type)
+          receiver_type = receiver_type.definition if receiver_type.is_a?(Types::StructInstance) || receiver_type.is_a?(Types::VariantInstance)
 
-      def receiver_module_name(receiver_type)
-        receiver_type = receiver_type.definition if receiver_type.is_a?(Types::StructInstance) || receiver_type.is_a?(Types::VariantInstance)
+          receiver_type.module_name
+        end
 
-        receiver_type.module_name
-      end
+        def local_type_definition_token(uri, name)
+          tokens = @workspace.get_tokens(uri)
+          return nil unless tokens
 
-      def local_type_definition_token(uri, name)
-        tokens = @workspace.get_tokens(uri)
-        return nil unless tokens
+          tokens.each_cons(2) do |kw_tok, id_tok|
+            next unless [:struct, :opaque, :enum, :flags, :variant, :union].include?(kw_tok.type)
+            next unless id_tok.type == :identifier && id_tok.lexeme == name
 
-        tokens.each_cons(2) do |kw_tok, id_tok|
-          next unless [:struct, :opaque, :enum, :flags, :variant, :union].include?(kw_tok.type)
-          next unless id_tok.type == :identifier && id_tok.lexeme == name
+            return id_tok
+          end
 
-          return id_tok
+          nil
         end
 
-        nil
+        def same_interface_binding?(left, right)
+          left.name == right.name && left.module_name == right.module_name
+        end
       end
 
-      def same_interface_binding?(left, right)
-        left.name == right.name && left.module_name == right.module_name
-      end
-      end
       def named_argument_definition_location(uri, name, tokens, token_index, stages: nil)
         return nil unless named_argument_label_token?(tokens, token_index)