ruby-lsp 0.23.11 → 0.26.6

data/lib/ruby_indexer/lib/ruby_indexer/location.rb

@@ -3,20 +3,8 @@
 
 module RubyIndexer
   class Location
-    extend T::Sig
-
     class << self
-      extend T::Sig
-
-      sig do
-        params(
-          prism_location: Prism::Location,
-          code_units_cache: T.any(
-            T.proc.params(arg0: Integer).returns(Integer),
-            Prism::CodeUnitsCache,
-          ),
-        ).returns(T.attached_class)
-      end
+      #: (Prism::Location prism_location, (^(Integer arg0) -> Integer | Prism::CodeUnitsCache) code_units_cache) -> instance
       def from_prism_location(prism_location, code_units_cache)
         new(
           prism_location.start_line,
@@ -27,17 +15,10 @@ module RubyIndexer
       end
     end
 
-    sig { returns(Integer) }
+    #: Integer
     attr_reader :start_line, :end_line, :start_column, :end_column
 
-    sig do
-      params(
-        start_line: Integer,
-        end_line: Integer,
-        start_column: Integer,
-        end_column: Integer,
-      ).void
-    end
+    #: (Integer start_line, Integer end_line, Integer start_column, Integer end_column) -> void
     def initialize(start_line, end_line, start_column, end_column)
       @start_line = start_line
       @end_line = end_line
@@ -45,11 +26,7 @@ module RubyIndexer
       @end_column = end_column
     end
 
-    sig do
-      params(
-        other: T.any(Location, Prism::Location),
-      ).returns(T::Boolean)
-    end
+    #: ((Location | Prism::Location) other) -> bool
     def ==(other)
       start_line == other.start_line &&
         end_line == other.end_line &&

data/lib/ruby_indexer/lib/ruby_indexer/prefix_tree.rb

@@ -32,22 +32,21 @@ module RubyIndexer
   # `Value` type.
   #
   # See https://en.wikipedia.org/wiki/Trie for more information
+  #: [Value]
   class PrefixTree
-    extend T::Sig
-    extend T::Generic
-
-    Value = type_member
-
-    sig { void }
+    #: -> void
     def initialize
-      @root = T.let(Node.new("", ""), Node[Value])
+      @root = Node.new(
+        "",
+        "", #: as untyped
+      ) #: Node[Value]
     end
 
     # Search the PrefixTree based on a given `prefix`. If `foo` is an entry in the tree, then searching for `fo` will
     # return it as a result. The result is always an array of the type of value attribute to the generic `Value` type.
     # Notice that if the `Value` is an array, this method will return an array of arrays, where each entry is the array
     # of values for a given match
-    sig { params(prefix: String).returns(T::Array[Value]) }
+    #: (String prefix) -> Array[Value]
     def search(prefix)
       node = find_node(prefix)
       return [] unless node
@@ -56,7 +55,7 @@ module RubyIndexer
     end
 
     # Inserts a `value` using the given `key`
-    sig { params(key: String, value: Value).void }
+    #: (String key, Value value) -> void
     def insert(key, value)
       node = @root
 
@@ -73,13 +72,13 @@ module RubyIndexer
 
     # Deletes the entry identified by `key` from the tree. Notice that a partial match will still delete all entries
     # that match it. For example, if the tree contains `foo` and we ask to delete `fo`, then `foo` will be deleted
-    sig { params(key: String).void }
+    #: (String key) -> void
     def delete(key)
       node = find_node(key)
       return unless node
 
       # Remove the node from the tree and then go up the parents to remove any of them with empty children
-      parent = T.let(T.must(node.parent), T.nilable(Node[Value]))
+      parent = node.parent #: Node[Value]?
 
       while parent
         parent.children.delete(node.key)
@@ -93,7 +92,7 @@ module RubyIndexer
     private
 
     # Find a node that matches the given `key`
-    sig { params(key: String).returns(T.nilable(Node[Value])) }
+    #: (String key) -> Node[Value]?
     def find_node(key)
       node = @root
 
@@ -107,28 +106,24 @@ module RubyIndexer
       node
     end
 
+    #: [Value]
     class Node
-      extend T::Sig
-      extend T::Generic
-
-      Value = type_member
-
-      sig { returns(T::Hash[String, Node[Value]]) }
+      #: Hash[String, Node[Value]]
       attr_reader :children
 
-      sig { returns(String) }
+      #: String
       attr_reader :key
 
-      sig { returns(Value) }
+      #: Value
       attr_accessor :value
 
-      sig { returns(T::Boolean) }
+      #: bool
       attr_accessor :leaf
 
-      sig { returns(T.nilable(Node[Value])) }
+      #: Node[Value]?
       attr_reader :parent
 
-      sig { params(key: String, value: Value, parent: T.nilable(Node[Value])).void }
+      #: (String key, Value value, ?Node[Value]? parent) -> void
       def initialize(key, value, parent = nil)
         @key = key
         @value = value
@@ -137,13 +132,14 @@ module RubyIndexer
         @leaf = false
       end
 
-      sig { returns(T::Array[Value]) }
+      #: -> Array[Value]
       def collect
         result = []
-        result << @value if @leaf
+        stack = [self]
 
-        @children.each_value do |node|
-          result.concat(node.collect)
+        while (node = stack.pop)
+          result << node.value if node.leaf
+          stack.concat(node.children.values)
         end
 
         result

data/lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb

@@ -3,16 +3,14 @@
 
 module RubyIndexer
   class RBSIndexer
-    extend T::Sig
+    HAS_UNTYPED_FUNCTION = !!defined?(RBS::Types::UntypedFunction) #: bool
 
-    HAS_UNTYPED_FUNCTION = T.let(!!defined?(RBS::Types::UntypedFunction), T::Boolean)
-
-    sig { params(index: Index).void }
+    #: (Index index) -> void
     def initialize(index)
       @index = index
     end
 
-    sig { void }
+    #: -> void
     def index_ruby_core
       loader = RBS::EnvironmentLoader.new
       RBS::Environment.from_loader(loader).resolve_type_names
@@ -22,12 +20,7 @@ module RubyIndexer
       end
     end
 
-    sig do
-      params(
-        pathname: Pathname,
-        declarations: T::Array[RBS::AST::Declarations::Base],
-      ).void
-    end
+    #: (Pathname pathname, Array[RBS::AST::Declarations::Base] declarations) -> void
     def process_signature(pathname, declarations)
       declarations.each do |declaration|
         process_declaration(declaration, pathname)
@@ -36,7 +29,7 @@ module RubyIndexer
 
     private
 
-    sig { params(declaration: RBS::AST::Declarations::Base, pathname: Pathname).void }
+    #: (RBS::AST::Declarations::Base declaration, Pathname pathname) -> void
     def process_declaration(declaration, pathname)
       case declaration
       when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module
@@ -51,9 +44,7 @@ module RubyIndexer
       end
     end
 
-    sig do
-      params(declaration: T.any(RBS::AST::Declarations::Class, RBS::AST::Declarations::Module), pathname: Pathname).void
-    end
+    #: ((RBS::AST::Declarations::Class | RBS::AST::Declarations::Module) declaration, Pathname pathname) -> void
     def handle_class_or_module_declaration(declaration, pathname)
       nesting = [declaration.name.name.to_s]
       uri = URI::Generic.from_path(path: pathname.to_s)
@@ -61,9 +52,9 @@ module RubyIndexer
       comments = comments_to_string(declaration)
       entry = if declaration.is_a?(RBS::AST::Declarations::Class)
         parent_class = declaration.super_class&.name&.name&.to_s
-        Entry::Class.new(nesting, uri, location, location, comments, parent_class)
+        Entry::Class.new(@index.configuration, nesting, uri, location, location, comments, parent_class)
       else
-        Entry::Module.new(nesting, uri, location, location, comments)
+        Entry::Module.new(@index.configuration, nesting, uri, location, location, comments)
       end
 
       add_declaration_mixins_to_entry(declaration, entry)
@@ -83,7 +74,7 @@ module RubyIndexer
       end
     end
 
-    sig { params(rbs_location: RBS::Location).returns(RubyIndexer::Location) }
+    #: (RBS::Location rbs_location) -> RubyIndexer::Location
     def to_ruby_indexer_location(rbs_location)
       RubyIndexer::Location.new(
         rbs_location.start_line,
@@ -93,12 +84,7 @@ module RubyIndexer
       )
     end
 
-    sig do
-      params(
-        declaration: T.any(RBS::AST::Declarations::Class, RBS::AST::Declarations::Module),
-        entry: Entry::Namespace,
-      ).void
-    end
+    #: ((RBS::AST::Declarations::Class | RBS::AST::Declarations::Module) declaration, Entry::Namespace entry) -> void
     def add_declaration_mixins_to_entry(declaration, entry)
       declaration.each_mixin do |mixin|
         name = mixin.name.name.to_s
@@ -114,37 +100,29 @@ module RubyIndexer
       end
     end
 
-    sig { params(member: RBS::AST::Members::MethodDefinition, owner: Entry::Namespace).void }
+    #: (RBS::AST::Members::MethodDefinition member, Entry::Namespace owner) -> void
     def handle_method(member, owner)
       name = member.name.name
-      uri = URI::Generic.from_path(path: member.location.buffer.name)
+      uri = URI::Generic.from_path(path: member.location.buffer.name.to_s)
       location = to_ruby_indexer_location(member.location)
       comments = comments_to_string(member)
 
-      visibility = case member.visibility
-      when :private
-        Entry::Visibility::PRIVATE
-      when :protected
-        Entry::Visibility::PROTECTED
-      else
-        Entry::Visibility::PUBLIC
-      end
-
       real_owner = member.singleton? ? @index.existing_or_new_singleton_class(owner.name) : owner
       signatures = signatures(member)
       @index.add(Entry::Method.new(
+        @index.configuration,
         name,
         uri,
         location,
         location,
         comments,
         signatures,
-        visibility,
+        member.visibility || :public,
         real_owner,
       ))
     end
 
-    sig { params(member: RBS::AST::Members::MethodDefinition).returns(T::Array[Entry::Signature]) }
+    #: (RBS::AST::Members::MethodDefinition member) -> Array[Entry::Signature]
     def signatures(member)
       member.overloads.map do |overload|
         parameters = process_overload(overload)
@@ -152,7 +130,7 @@ module RubyIndexer
       end
     end
 
-    sig { params(overload: RBS::AST::Members::MethodDefinition::Overload).returns(T::Array[Entry::Parameter]) }
+    #: (RBS::AST::Members::MethodDefinition::Overload overload) -> Array[Entry::Parameter]
     def process_overload(overload)
       function = overload.method_type.type
 
@@ -173,7 +151,7 @@ module RubyIndexer
       end
     end
 
-    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::Parameter]) }
+    #: (RBS::Types::Function function) -> Array[Entry::Parameter]
     def parse_arguments(function)
       parameters = []
       parameters.concat(process_required_and_optional_positionals(function))
@@ -185,7 +163,7 @@ module RubyIndexer
       parameters
     end
 
-    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::RequiredParameter]) }
+    #: (RBS::Types::Function function) -> Array[Entry::RequiredParameter]
     def process_required_and_optional_positionals(function)
       argument_offset = 0
 
@@ -209,14 +187,14 @@ module RubyIndexer
       required + optional
     end
 
-    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::OptionalParameter]) }
+    #: (RBS::Types::Function function) -> Array[Entry::OptionalParameter]
     def process_trailing_positionals(function)
       function.trailing_positionals.map do |param|
         Entry::OptionalParameter.new(name: param.name)
       end
     end
 
-    sig { params(function: RBS::Types::Function).returns(Entry::RestParameter) }
+    #: (RBS::Types::Function function) -> Entry::RestParameter
     def process_rest_positionals(function)
       rest = function.rest_positionals
 
@@ -225,21 +203,21 @@ module RubyIndexer
       Entry::RestParameter.new(name: rest_name)
     end
 
-    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::KeywordParameter]) }
+    #: (RBS::Types::Function function) -> Array[Entry::KeywordParameter]
     def process_required_keywords(function)
       function.required_keywords.map do |name, _param|
         Entry::KeywordParameter.new(name: name)
       end
     end
 
-    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::OptionalKeywordParameter]) }
+    #: (RBS::Types::Function function) -> Array[Entry::OptionalKeywordParameter]
     def process_optional_keywords(function)
       function.optional_keywords.map do |name, _param|
         Entry::OptionalKeywordParameter.new(name: name)
       end
     end
 
-    sig { params(function: RBS::Types::Function).returns(Entry::KeywordRestParameter) }
+    #: (RBS::Types::Function function) -> Entry::KeywordRestParameter
     def process_rest_keywords(function)
       param = function.rest_keywords
 
@@ -262,10 +240,11 @@ module RubyIndexer
     # Complex::I = ... # Complex::I is a top-level constant
     #
     # And we need to handle their nesting differently.
-    sig { params(declaration: RBS::AST::Declarations::Constant, nesting: T::Array[String], uri: URI::Generic).void }
+    #: (RBS::AST::Declarations::Constant declaration, Array[String] nesting, URI::Generic uri) -> void
     def handle_constant(declaration, nesting, uri)
       fully_qualified_name = [*nesting, declaration.name.name.to_s].join("::")
       @index.add(Entry::Constant.new(
+        @index.configuration,
         fully_qualified_name,
         uri,
         to_ruby_indexer_location(declaration.location),
@@ -273,7 +252,7 @@ module RubyIndexer
       ))
     end
 
-    sig { params(declaration: RBS::AST::Declarations::Global, pathname: Pathname).void }
+    #: (RBS::AST::Declarations::Global declaration, Pathname pathname) -> void
     def handle_global_variable(declaration, pathname)
       name = declaration.name.to_s
       uri = URI::Generic.from_path(path: pathname.to_s)
@@ -281,6 +260,7 @@ module RubyIndexer
       comments = comments_to_string(declaration)
 
       @index.add(Entry::GlobalVariable.new(
+        @index.configuration,
         name,
         uri,
         location,
@@ -288,12 +268,13 @@ module RubyIndexer
       ))
     end
 
-    sig { params(member: RBS::AST::Members::Alias, owner_entry: Entry::Namespace).void }
+    #: (RBS::AST::Members::Alias member, Entry::Namespace owner_entry) -> void
     def handle_signature_alias(member, owner_entry)
-      uri = URI::Generic.from_path(path: member.location.buffer.name)
+      uri = URI::Generic.from_path(path: member.location.buffer.name.to_s)
       comments = comments_to_string(member)
 
       entry = Entry::UnresolvedMethodAlias.new(
+        @index.configuration,
         member.new_name.to_s,
         member.old_name.to_s,
         owner_entry,
@@ -305,16 +286,7 @@ module RubyIndexer
       @index.add(entry)
     end
 
-    sig do
-      params(declaration: T.any(
-        RBS::AST::Declarations::Class,
-        RBS::AST::Declarations::Module,
-        RBS::AST::Declarations::Constant,
-        RBS::AST::Declarations::Global,
-        RBS::AST::Members::MethodDefinition,
-        RBS::AST::Members::Alias,
-      )).returns(T.nilable(String))
-    end
+    #: ((RBS::AST::Declarations::Class | RBS::AST::Declarations::Module | RBS::AST::Declarations::Constant | RBS::AST::Declarations::Global | RBS::AST::Members::MethodDefinition | RBS::AST::Members::Alias) declaration) -> String?
     def comments_to_string(declaration)
       declaration.comment&.string
     end