steep 1.10.0.pre.3 → 2.0.0

data/lib/steep/services/completion_provider.rb

@@ -1,8 +1,6 @@
 module Steep
   module Services
-    class CompletionProvider
-      include NodeHelper
-
+    module CompletionProvider
       Position = _ = Struct.new(:line, :column, keyword_init: true) do
         # @implements Position
         def -(size)
@@ -28,11 +26,18 @@ module Steep
 
         def comments
           case entry = env.constant_entry(full_name)
-          when RBS::Environment::ConstantEntry
+          when ::RBS::Environment::ConstantEntry
             [entry.decl.comment]
-          when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
-            entry.decls.map {|d| d.decl.comment }
-          when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
+          when ::RBS::Environment::ClassEntry, ::RBS::Environment::ModuleEntry
+            entry.each_decl.map do |decl|
+              case decl
+              when ::RBS::AST::Declarations::Base
+                decl.comment
+              when ::RBS::AST::Ruby::Declarations::Base
+                nil
+              end
+            end
+          when ::RBS::Environment::ClassAliasEntry, ::RBS::Environment::ModuleAliasEntry
             [entry.decl.comment]
           else
             raise
@@ -41,11 +46,11 @@ module Steep
 
         def decl
           case entry = env.constant_entry(full_name)
-          when RBS::Environment::ConstantEntry
+          when ::RBS::Environment::ConstantEntry
             entry.decl
-          when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
-            entry.primary.decl
-          when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
+          when ::RBS::Environment::ClassEntry, ::RBS::Environment::ModuleEntry
+            entry.primary_decl
+          when ::RBS::Environment::ClassAliasEntry, ::RBS::Environment::ModuleAliasEntry
             entry.decl
           else
             raise
@@ -65,7 +70,12 @@ module Steep
         # @implements SimpleMethodNameItem
 
         def comment
-          method_member.comment
+          case method_member
+          when ::RBS::AST::Members::Base
+            method_member.comment
+          when ::RBS::AST::Ruby::Members::Base
+            nil
+          end
         end
       end
 
@@ -89,18 +99,20 @@ module Steep
 
         def defining_method_name(type_name, name, member)
           case member
-          when RBS::AST::Members::MethodDefinition
+          when ::RBS::AST::Members::MethodDefinition
             if member.instance?
               InstanceMethodName.new(type_name: type_name, method_name: name)
             else
               SingletonMethodName.new(type_name: type_name, method_name: name)
             end
-          when RBS::AST::Members::Attribute
+          when ::RBS::AST::Members::Attribute
             if member.kind == :instance
               InstanceMethodName.new(type_name: type_name, method_name: name)
             else
               SingletonMethodName.new(type_name: type_name, method_name: name)
             end
+          when ::RBS::AST::Ruby::Members::DefMember, ::RBS::AST::Ruby::Members::AttributeMember
+            InstanceMethodName.new(type_name: type_name, method_name: name)
           end
         end
       end
@@ -118,9 +130,9 @@ module Steep
             env.type_alias_decls.fetch(absolute_type_name).decl
           when absolute_type_name.class?
             case entry = env.module_class_entry(absolute_type_name)
-            when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
-              entry.primary.decl
-            when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
+            when ::RBS::Environment::ClassEntry, ::RBS::Environment::ModuleEntry
+              entry.primary_decl
+            when ::RBS::Environment::ClassAliasEntry, ::RBS::Environment::ModuleAliasEntry
               entry.decl
             else
               raise "absolute_type_name=#{absolute_type_name}, relative_type_name=#{relative_type_name}"
@@ -144,13 +156,18 @@ module Steep
             end
           when absolute_type_name.class?
             case entry = env.module_class_entry(absolute_type_name)
-            when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
-              entry.decls.each do |decl|
-                if comment = decl.decl.comment
-                  comments << comment
+            when ::RBS::Environment::ClassEntry, ::RBS::Environment::ModuleEntry
+              entry.each_decl do |decl|
+                case decl
+                when ::RBS::AST::Declarations::Base
+                  if comment = decl.comment
+                    comments << comment
+                  end
+                when ::RBS::AST::Ruby::Declarations::Base
+                  # noop
                 end
               end
-            when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
+            when ::RBS::Environment::ClassAliasEntry, ::RBS::Environment::ModuleAliasEntry
               if comment = entry.decl.comment
                 comments << comment
               end
@@ -167,646 +184,6 @@ module Steep
 
       class TextItem < Struct.new(:text, :help_text, :range, :label, keyword_init: true)
       end
-
-      attr_reader :source_text
-      attr_reader :path
-      attr_reader :subtyping
-      attr_reader :modified_text
-      attr_reader :source
-      attr_reader :typing
-
-      def initialize(source_text:, path:, subtyping:)
-        @source_text = source_text
-        @path = path
-        @subtyping = subtyping
-      end
-
-      def type_check!(text, line:, column:)
-        @modified_text = text
-
-        Steep.measure "parsing" do
-          @source = Source
-                      .parse(text, path: path, factory: subtyping.factory)
-                      .without_unrelated_defs(line: line, column: column)
-        end
-
-        Steep.measure "typechecking" do
-          location = source.buffer.loc_to_pos([line, column])
-          resolver = RBS::Resolver::ConstantResolver.new(builder: subtyping.factory.definition_builder)
-          @typing = TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver, cursor: location)
-        end
-      end
-
-      def env
-        subtyping.factory.env
-      end
-
-      def run(line:, column:)
-        source_text = self.source_text.dup
-        index = index_for(source_text, line:line, column: column)
-        possible_trigger = source_text[index-1]
-
-        Steep.logger.debug "possible_trigger: #{possible_trigger.inspect}"
-
-        position = Position.new(line: line, column: column)
-
-        begin
-          Steep.logger.tagged "completion_provider#run(line: #{line}, column: #{column})" do
-            Steep.measure "type_check!" do
-              type_check!(source_text, line: line, column: column)
-            end
-          end
-
-          if comment = at_comment?(position)
-            node, *parents = source.find_nodes(line: position.line, column: position.column)
-
-            case
-            when node&.type == :assertion
-              # continue
-              node or raise
-              assertion = node.children[1] #: AST::Node::TypeAssertion
-              return items_for_rbs(position: position, buffer: assertion.location.buffer)
-
-            when node && parents && tapp_node = ([node] + parents).find {|n| n.type == :tapp }
-              tapp = tapp_node.children[1] #: AST::Node::TypeApplication
-              type_range = tapp.type_location.range
-
-              if type_range.begin < index && index <= type_range.end
-                return items_for_rbs(position: position, buffer: tapp.location.buffer)
-              end
-            else
-              annotation = source.each_annotation.flat_map {|_, annots| annots }.find do |a|
-                if a.location
-                  a.location.start_pos < index && index <= a.location.end_pos
-                end
-              end
-
-              if annotation
-                annotation.location or raise
-                return items_for_rbs(position: position, buffer: annotation.location.buffer)
-              end
-
-              comment_content = comment.text[1..] || ""
-              comment_content.strip!
-
-              range = Range.new(
-                start: Position.new(line: line, column: column),
-                end: Position.new(line: line, column: column)
-              )
-
-              items = [
-                TextItem.new(label: "steep:ignore:start", text: "steep:ignore:start", help_text: "Open ignore block", range: range),
-                TextItem.new(label: "steep:ignore:end", text: "steep:ignore:end", help_text: "Close ignore block", range: range),
-                TextItem.new(label: "steep:ignore", text: "steep:ignore ${1:optional diagnostics}", help_text: "Ignore line", range: range),
-                TextItem.new(label: "@type var x: T", text: "@type var ${1:variable}: ${2:var type}", help_text: "Type of local variable", range: range),
-                TextItem.new(label: "@type self: T", text: "@type self: ${1:self type}", help_text: "Type of `self`", range: range),
-                TextItem.new(label: "@type block: T", text: "@type block: ${1:block type}", help_text: "Type of `block`", range: range),
-                TextItem.new(label: "@type break: T", text: "@type break: ${1:break type}", help_text: "Type of `block`", range: range),
-              ]
-
-              items = items.filter_map do |item|
-                if item.text.start_with?(comment_content)
-                  TextItem.new(
-                    label: item.label,
-                    text: item.text,
-                    help_text: item.help_text,
-                    range: Range.new(
-                      start: Position.new(line: item.range.start.line, column: item.range.start.column - comment_content.size),
-                      end: item.range.end
-                    )
-                  )
-                end
-              end
-
-              return items
-            end
-          end
-
-          Steep.measure "completion item collection" do
-            items_for_trigger(position: position)
-          end
-
-        rescue Parser::SyntaxError => exn
-          Steep.logger.info "recovering syntax error: #{exn.inspect}"
-
-          @source_text = source_text.dup
-
-          case possible_trigger
-          when "."
-            if source_text[index-2] == "&"
-              source_text[index-1] = " "
-              source_text[index-2] = " "
-              type_check!(source_text, line: line, column: column)
-              items_for_qcall(position: position)
-            else
-              source_text[index-1] = " "
-              type_check!(source_text, line: line, column: column)
-              items_for_dot(position: position)
-            end
-          when "@"
-            source_text[index-1] = " "
-            type_check!(source_text, line: line, column: column)
-            items_for_atmark(position: position)
-          when ":"
-            if source_text[index-2] == ":"
-              source_text[index-1] = " "
-              source_text[index-2] = " "
-              type_check!(source_text, line: line, column: column)
-              items_for_colon2(position: position)
-            else
-              []
-            end
-          else
-            items = [] #: Array[item]
-            items_for_following_keyword_arguments(source_text, index: index, line: line, column: column, items: items)
-            items
-          end
-        end
-      end
-
-      def range_from_loc(loc)
-        Range.new(
-          start: Position.new(line: loc.line, column: loc.column),
-          end: Position.new(line: loc.last_line, column: loc.last_line)
-        )
-      end
-
-      def at_end?(pos, of:)
-        if of
-          of.last_line == pos.line && of.last_column == pos.column
-        end
-      end
-
-      def at_comment?(position)
-        source.find_comment(line: position.line, column: position.column)
-      end
-
-      def range_for(position, prefix: "")
-        if prefix.empty?
-          Range.new(start: position, end: position)
-        else
-          Range.new(start: position - prefix.size, end: position)
-        end
-      end
-
-      def items_for_trigger(position:)
-        node, *parents = source.find_nodes(line: position.line, column: position.column)
-        node ||= source.node
-
-        return [] unless node && parents
-
-        items = [] #: Array[item]
-
-        context = typing.cursor_context.context or raise
-
-        case
-        when node.type == :send && node.children[0] == nil && at_end?(position, of: (_ = node.loc).selector)
-          # foo ←
-          prefix = node.children[1].to_s
-
-          method_items_for_receiver_type(context.self_type, include_private: true, prefix: prefix, position: position, items: items)
-          local_variable_items_for_context(context, position: position, prefix: prefix, items: items)
-
-          if (send_node, block_node = deconstruct_sendish_and_block_nodes(*parents))
-            keyword_argument_items_for_method(
-              call_node: block_node || send_node,
-              send_node: send_node,
-              position: position,
-              prefix: prefix,
-              items: items
-            )
-          end
-
-        when node.type == :lvar && at_end?(position, of: node.loc)
-          # foo ← (lvar)
-          local_variable_items_for_context(context, position: position, prefix: node.children[0].to_s, items: items)
-
-        when node.type == :send && node.children[0] && at_end?(position, of: (_ = node.loc).selector)
-          # foo.ba ←
-          receiver_type =
-            case (type = typing.type_of(node: node.children[0]))
-            when AST::Types::Self
-              context.self_type
-            else
-              type
-            end
-          prefix = node.children[1].to_s
-
-          method_items_for_receiver_type(receiver_type, include_private: false, prefix: prefix, position: position, items: items)
-
-        when node.type == :csend && node.children[0] && at_end?(position, of: (_ = node.loc).selector)
-          # foo&.ba ←
-          receiver_type =
-            case (type = typing.type_of(node: node.children[0]))
-            when AST::Types::Self
-              context.self_type
-            else
-              unwrap_optional(type)
-            end
-          prefix = node.children[1].to_s
-
-          method_items_for_receiver_type(receiver_type, include_private: false, prefix: prefix, position: position, items: items)
-
-        when node.type == :const && node.children[0] == nil && at_end?(position, of: node.loc)
-          # Foo ← (const)
-          prefix = node.children[1].to_s
-
-          method_items_for_receiver_type(context.self_type, include_private: false, prefix: prefix, position: position, items: items)
-          constant_items_for_context(context, prefix: prefix, position: position, items: items)
-
-        when node.type == :const && node.children[0] && at_end?(position, of: node.loc)
-          # Foo::Ba ← (const)
-          parent_node = node.children[0]
-          parent_type = typing.type_of(node: parent_node)
-
-          if parent_type
-            prefix = node.children[1].to_s
-
-            method_items_for_receiver_type(parent_type, include_private: false, prefix: prefix, position: position, items: items)
-            constant_items_for_context(context, parent: parent_node, prefix: prefix, position: position, items: items)
-          end
-
-        when node.type == :send && at_end?(position, of: (_ = node.loc).dot) && (_ = node.loc).dot.source == "."
-          # foo.← ba
-          receiver_type =
-            case (type = typing.type_of(node: node.children[0]))
-            when AST::Types::Self
-              context.self_type
-            else
-              type
-            end
-
-          method_items_for_receiver_type(receiver_type, include_private: false, prefix: "", position: position, items: items)
-
-        when node.type == :send && at_end?(position, of: (_ = node.loc).dot) && (_ = node.loc).dot.source == "::"
-          # foo::← ba
-          items.push(*items_for_colon2(position: position))
-
-        when node.type == :csend && at_end?(position, of: (_ = node.loc).dot)
-          # foo&.← ba
-          receiver_type =
-            case (type = typing.type_of(node: node.children[0]))
-            when AST::Types::Self
-              context.self_type
-            else
-              unwrap_optional(type)
-            end
-
-          method_items_for_receiver_type(receiver_type, include_private: false, prefix: "", position: position, items: items)
-
-        when node.type == :ivar && at_end?(position, of: node.loc)
-          # @fo ←
-          instance_variable_items_for_context(context, position: position, prefix: node.children[0].to_s, items: items)
-
-        else
-          method_items_for_receiver_type(context.self_type, include_private: true, prefix: "", position: position, items: items)
-          local_variable_items_for_context(context, position: position, prefix: "", items: items)
-          instance_variable_items_for_context(context, position: position, prefix: "", items: items)
-          constant_items_for_context(context, position: position, prefix: "", items: items)
-        end
-
-        items
-      end
-
-      def items_for_dot(position:)
-        # foo. ←
-        shift_pos = position-1
-        node, *_parents = source.find_nodes(line: shift_pos.line, column: shift_pos.column)
-        node ||= source.node
-
-        return [] unless node
-
-        if at_end?(shift_pos, of: node.loc)
-          begin
-            context = typing.cursor_context.context or raise
-            receiver_type =
-              case (type = typing.type_of(node: node))
-              when AST::Types::Self
-                context.self_type
-              else
-                type
-              end
-
-            items = [] #: Array[item]
-            method_items_for_receiver_type(receiver_type, include_private: false, prefix: "", position: position, items: items)
-            items
-          rescue Typing::UnknownNodeError
-            []
-          end
-        else
-          []
-        end
-      end
-
-      def items_for_qcall(position:)
-        # foo&. ←
-        shift_pos = position-2
-        node, *_parents = source.find_nodes(line: shift_pos.line, column: shift_pos.column)
-        node ||= source.node
-
-        return [] unless node
-
-        if at_end?(shift_pos, of: node.loc)
-          begin
-            context = typing.cursor_context.context or raise
-            receiver_type =
-              case (type = typing.type_of(node: node))
-              when AST::Types::Self
-                context.self_type
-              else
-                unwrap_optional(type)
-              end
-
-            items = [] #: Array[item]
-            method_items_for_receiver_type(receiver_type, include_private: false, prefix: "", position: position, items: items)
-            items
-          rescue Typing::UnknownNodeError
-            []
-          end
-        else
-          []
-        end
-      end
-
-      def items_for_colon2(position:)
-        # :: ←
-        shift_pos = position-2
-        node, *_ = source.find_nodes(line: shift_pos.line, column: shift_pos.column)
-        node ||= source.node
-
-        items = [] #: Array[item]
-        case node&.type
-        when :const
-          # Constant:: ←
-          context = typing.cursor_context.context or raise
-          constant_items_for_context(context, parent: node, position: position, items: items, prefix: "")
-        when nil
-          # :: ←
-          context = typing.cursor_context.context or raise
-          constant_items_for_context(context, parent: nil, position: position, items: items, prefix: "")
-        end
-
-        if node
-          items.push(*items_for_dot(position: position - 1))
-        end
-
-        items
-      end
-
-      def items_for_atmark(position:)
-        # @ ←
-        shift_pos = position-1
-        node, *_ = source.find_nodes(line: shift_pos.line, column: shift_pos.column)
-        node ||= source.node
-
-        return [] unless node
-
-        context = typing.cursor_context.context or raise
-        items = [] #: Array[item]
-        instance_variable_items_for_context(context, prefix: "@", position: position, items: items)
-        items
-      end
-
-      def items_for_rbs(position:, buffer:)
-        items = [] #: Array[item]
-
-        context = typing.cursor_context.context or raise
-        completion = TypeNameCompletion.new(env: context.env, context: context.module_context.nesting, dirs: [])
-        prefix = TypeNameCompletion::Prefix.parse(buffer, line: position.line, column: position.column)
-
-        size = prefix&.size || 0
-        range = Range.new(start: position - size, end: position)
-
-        completion.find_type_names(prefix).each do |name|
-          absolute, relative = completion.resolve_name_in_context(name)
-          items << TypeNameItem.new(relative_type_name: relative, absolute_type_name: absolute, env: context.env, range: range)
-        end
-
-        items
-      end
-
-      def items_for_following_keyword_arguments(text, index:, line:, column:, items:)
-        return if text[index - 1] !~ /[a-zA-Z0-9]/
-
-        text = text.dup
-        argname = [] #: Array[String]
-        while text[index - 1] =~ /[a-zA-Z0-9]/
-          argname.unshift(text[index - 1] || '')
-          source_text[index - 1] = " "
-          index -= 1
-        end
-
-        begin
-          type_check!(source_text, line: line, column: column)
-        rescue Parser::SyntaxError
-          return
-        end
-
-        if nodes = source.find_nodes(line: line, column: column)
-          if (send_node, block_node = deconstruct_sendish_and_block_nodes(*nodes))
-            position = Position.new(line: line, column: column)
-            keyword_argument_items_for_method(
-              call_node: block_node || send_node,
-              send_node: send_node,
-              position: position,
-              prefix: argname.join,
-              items: items
-            )
-          end
-        end
-      end
-
-      def method_items_for_receiver_type(type, include_private:, prefix:, position:, items:)
-        range = range_for(position, prefix: prefix)
-        context = typing.cursor_context.context or raise
-
-        config =
-          if (module_type = context.module_context&.module_type) && (instance_type = context.module_context&.instance_type)
-            Interface::Builder::Config.new(
-              self_type: context.self_type,
-              class_type: module_type,
-              instance_type: instance_type,
-              variable_bounds: context.variable_context.upper_bounds
-            )
-          else
-            Interface::Builder::Config.new(self_type: context.self_type, variable_bounds: context.variable_context.upper_bounds)
-          end
-
-        if shape = subtyping.builder.shape(type, config)
-          shape = shape.public_shape unless include_private
-
-          shape.methods.each do |name, method_entry|
-            next if disallowed_method?(name)
-
-            if name.to_s.start_with?(prefix)
-              if word_name?(name.to_s)
-                case type
-                when AST::Types::Name::Instance, AST::Types::Name::Interface, AST::Types::Name::Singleton
-                  # Simple method type
-                  all_decls = Set.new(method_entry.overloads.flat_map {|overload| overload.method_decls(name) }).sort_by {|decl| decl.method_name.to_s }
-                  all_members = Set.new(all_decls.flat_map {|decl| decl.method_def.member })
-                  all_members.each do |member|
-                    associated_decl = all_decls.find {|decl| decl.method_def.member == member } or next
-                    overloads = method_entry.overloads.select {|overload| overload.method_defs.any? {|defn| defn.member == member }}
-                    annotations = associated_decl.method_def.member_annotations
-                    items << SimpleMethodNameItem.new(
-                      identifier: name,
-                      range: range,
-                      receiver_type: type,
-                      method_name: associated_decl.method_name,
-                      method_types: overloads.map {|overload| subtyping.factory.method_type_1(overload.method_type) },
-                      method_member: member,
-                      deprecated: AnnotationsHelper.deprecated_annotation?(annotations) ? true : false
-                    )
-                  end
-                else
-                  generated_overloads, defined_overloads =
-                    method_entry.overloads.partition {|overload| overload.method_defs.empty? }
-
-                  unless defined_overloads.empty?
-                    items << ComplexMethodNameItem.new(
-                      identifier: name,
-                      range: range,
-                      receiver_type: type,
-                      method_types: defined_overloads.map { subtyping.factory.method_type_1(_1.method_type) },
-                      method_decls: defined_overloads.flat_map { _1.method_decls(name).to_a }.sort_by {|decl| decl.method_name.to_s }
-                    )
-                  end
-
-                  unless generated_overloads.empty?
-                    items << GeneratedMethodNameItem.new(
-                      identifier: name,
-                      range: range,
-                      receiver_type: type,
-                      method_types: generated_overloads.map { subtyping.factory.method_type_1(_1.method_type) }
-                    )
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-
-      def word_name?(name)
-        name =~ /\w/ ? true : false
-      end
-
-      def local_variable_items_for_context(context, position:, prefix:, items:)
-        range = range_for(position, prefix: prefix)
-        context.type_env.local_variable_types.each do |name, pair|
-          type, _ = pair
-
-          if name.to_s.start_with?(prefix)
-            items << LocalVariableItem.new(identifier: name, range: range, type: type)
-          end
-        end
-      end
-
-      def constant_items_for_context(context, parent: nil, position:, prefix:, items:)
-        range = range_for(position, prefix: prefix)
-
-        if parent
-          case parent.type
-          when :const
-            const_name = typing.source_index.reference(constant_node: parent) or raise "Unknown node in source_index: #{parent}"
-            consts = context.type_env.constant_env.children(const_name)
-          end
-        else
-          consts = context.type_env.constant_env.constants
-        end
-
-        if consts
-          consts.each do |name, tuple|
-            type, full_name, _ = tuple
-
-            if name.to_s.start_with?(prefix)
-              items << ConstantItem.new(env: env, identifier: name, range: range, type: type, full_name: full_name)
-            end
-          end
-        end
-      end
-
-      def instance_variable_items_for_context(context, position:, prefix:, items:)
-        range = range_for(position, prefix: prefix)
-        context.type_env.instance_variable_types.each do |name, type|
-          if name.to_s.start_with?(prefix)
-            items << InstanceVariableItem.new(identifier: name, range: range, type: type)
-          end
-        end
-      end
-
-      def keyword_argument_items_for_method(call_node:, send_node:, position:, prefix:, items:)
-        _receiver_node, _method_name, argument_nodes = deconstruct_send_node!(send_node)
-
-        call = typing.call_of(node: call_node)
-
-        case call
-        when TypeInference::MethodCall::Typed, TypeInference::MethodCall::Error
-          context = typing.cursor_context.context or raise
-          type = call.receiver_type
-          type = type.subst(Interface::Substitution.build([], self_type: context.self_type, module_type: context.module_context&.module_type, instance_type: context.module_context&.instance_type))
-
-          config = Interface::Builder::Config.new(self_type: type, variable_bounds: context.variable_context.upper_bounds)
-          if shape = subtyping.builder.shape(type, config)
-            shape = shape.public_shape if private_send?(call_node)
-            if method = shape.methods[call.method_name]
-              method.overloads.each.with_index do |overload, i|
-                defn = overload.method_decls(call.method_name).to_a[0]&.method_def
-                if defn && defn.type.type
-                  range = range_for(position, prefix: prefix)
-                  kwargs = argument_nodes.find { |arg| arg.type == :kwargs }&.children || []
-                  used_kwargs = kwargs.filter_map { |arg| arg.type == :pair && arg.children.first.children.first }
-
-                  if defn.type.type.is_a?(RBS::Types::UntypedFunction)
-                    kwargs = [] #: Array[Symbol]
-                  else
-                    kwargs = defn.type.type.required_keywords.keys + defn.type.type.optional_keywords.keys
-                  end
-
-                  kwargs.each do |name|
-                    if name.to_s.start_with?(prefix) && !used_kwargs.include?(name)
-                      items << KeywordArgumentItem.new(identifier: "#{name}:", range: range)
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-
-
-      def index_for(string, line:, column:)
-        index = 0
-
-        string.each_line.with_index do |s, i|
-          if i+1 == line
-            index += column
-            break
-          else
-            index += s.size
-          end
-        end
-
-        index
-      end
-
-      def disallowed_method?(name)
-        # initialize isn't invoked by developers when creating
-        # instances of new classes, so don't show it as
-        # an LSP option
-        name == :initialize
-      end
-
-      def unwrap_optional(type)
-        if type.is_a?(AST::Types::Union) && type.types.include?(AST::Builtin.nil_type)
-          types = type.types.reject { |t| t == AST::Builtin.nil_type }
-          AST::Types::Union.new(types: types)
-        else
-          type
-        end
-      end
     end
   end
 end