ruby-lsp 0.23.11 → 0.23.16

data/lib/ruby_indexer/lib/ruby_indexer/enhancement.rb

@@ -8,30 +8,30 @@ module RubyIndexer
 
     abstract!
 
-    @enhancements = T.let([], T::Array[T::Class[Enhancement]])
+    @enhancements = [] #: Array[Class[Enhancement]]
 
     class << self
       extend T::Sig
 
-      sig { params(child: T::Class[Enhancement]).void }
+      #: (Class[Enhancement] child) -> void
       def inherited(child)
         @enhancements << child
         super
       end
 
-      sig { params(listener: DeclarationListener).returns(T::Array[Enhancement]) }
+      #: (DeclarationListener listener) -> Array[Enhancement]
       def all(listener)
         @enhancements.map { |enhancement| enhancement.new(listener) }
       end
 
       # Only available for testing purposes
-      sig { void }
+      #: -> void
       def clear
         @enhancements.clear
       end
     end
 
-    sig { params(listener: DeclarationListener).void }
+    #: (DeclarationListener listener) -> void
     def initialize(listener)
       @listener = listener
     end
@@ -39,10 +39,12 @@ module RubyIndexer
     # The `on_extend` indexing enhancement is invoked whenever an extend is encountered in the code. It can be used to
     # register for an included callback, similar to what `ActiveSupport::Concern` does in order to auto-extend the
     # `ClassMethods` modules
-    sig { overridable.params(node: Prism::CallNode).void }
+    # @overridable
+    #: (Prism::CallNode node) -> void
     def on_call_node_enter(node); end # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
 
-    sig { overridable.params(node: Prism::CallNode).void }
+    # @overridable
+    #: (Prism::CallNode node) -> void
     def on_call_node_leave(node); end # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -11,68 +11,61 @@ module RubyIndexer
       end
     end
 
-    extend T::Sig
-
-    sig { returns(String) }
+    #: String
     attr_reader :name
 
-    sig { returns(URI::Generic) }
+    #: URI::Generic
     attr_reader :uri
 
-    sig { returns(RubyIndexer::Location) }
+    #: RubyIndexer::Location
     attr_reader :location
 
     alias_method :name_location, :location
 
-    sig { returns(Visibility) }
+    #: Visibility
     attr_accessor :visibility
 
-    sig do
-      params(
-        name: String,
-        uri: URI::Generic,
-        location: Location,
-        comments: T.nilable(String),
-      ).void
-    end
+    #: (String name, URI::Generic uri, Location location, String? comments) -> void
     def initialize(name, uri, location, comments)
       @name = name
       @uri = uri
       @comments = comments
-      @visibility = T.let(Visibility::PUBLIC, Visibility)
+      @visibility = Visibility::PUBLIC #: Visibility
       @location = location
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def public?
       visibility == Visibility::PUBLIC
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def protected?
       visibility == Visibility::PROTECTED
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def private?
       visibility == Visibility::PRIVATE
     end
 
-    sig { returns(String) }
+    #: -> String
     def file_name
       if @uri.scheme == "untitled"
-        T.must(@uri.opaque)
+        @uri.opaque #: as !nil
       else
-        File.basename(T.must(file_path))
+        File.basename(
+          file_path, #: as !nil
+        )
       end
     end
 
-    sig { returns(T.nilable(String)) }
+    #: -> String?
     def file_path
       @uri.full_path
     end
 
-    sig { returns(String) }
+    #: -> String
     def comments
       @comments ||= begin
         # Parse only the comments based on the file path, which is much faster than parsing the entire file
@@ -119,10 +112,10 @@ module RubyIndexer
 
       abstract!
 
-      sig { returns(String) }
+      #: String
       attr_reader :module_name
 
-      sig { params(module_name: String).void }
+      #: (String module_name) -> void
       def initialize(module_name)
         @module_name = module_name
       end
@@ -137,24 +130,16 @@ module RubyIndexer
 
       abstract!
 
-      sig { returns(T::Array[String]) }
+      #: Array[String]
       attr_reader :nesting
 
       # Returns the location of the constant name, excluding the parent class or the body
-      sig { returns(Location) }
+      #: Location
       attr_reader :name_location
 
-      sig do
-        params(
-          nesting: T::Array[String],
-          uri: URI::Generic,
-          location: Location,
-          name_location: Location,
-          comments: T.nilable(String),
-        ).void
-      end
+      #: (Array[String] nesting, URI::Generic uri, Location location, Location name_location, String? comments) -> void
       def initialize(nesting, uri, location, name_location, comments)
-        @name = T.let(nesting.join("::"), String)
+        @name = nesting.join("::") #: String
         # The original nesting where this namespace was discovered
         @nesting = nesting
 
@@ -163,7 +148,7 @@ module RubyIndexer
         @name_location = name_location
       end
 
-      sig { returns(T::Array[String]) }
+      #: -> Array[String]
       def mixin_operation_module_names
         mixin_operations.map(&:module_name)
       end
@@ -171,12 +156,12 @@ module RubyIndexer
       # Stores all explicit prepend, include and extend operations in the exact order they were discovered in the source
       # code. Maintaining the order is essential to linearize ancestors the right way when a module is both included
       # and prepended
-      sig { returns(T::Array[ModuleOperation]) }
+      #: -> Array[ModuleOperation]
       def mixin_operations
-        @mixin_operations ||= T.let([], T.nilable(T::Array[ModuleOperation]))
+        @mixin_operations ||= [] #: Array[ModuleOperation]?
       end
 
-      sig { returns(Integer) }
+      #: -> Integer
       def ancestor_hash
         mixin_operation_module_names.hash
       end
@@ -186,44 +171,26 @@ module RubyIndexer
     end
 
     class Class < Namespace
-      extend T::Sig
-
       # The unresolved name of the parent class. This may return `nil`, which indicates the lack of an explicit parent
       # and therefore ::Object is the correct parent class
-      sig { returns(T.nilable(String)) }
+      #: String?
       attr_reader :parent_class
 
-      sig do
-        params(
-          nesting: T::Array[String],
-          uri: URI::Generic,
-          location: Location,
-          name_location:  Location,
-          comments: T.nilable(String),
-          parent_class: T.nilable(String),
-        ).void
-      end
+      #: (Array[String] nesting, URI::Generic uri, Location location, Location name_location, String? comments, String? parent_class) -> void
       def initialize(nesting, uri, location, name_location, comments, parent_class) # rubocop:disable Metrics/ParameterLists
         super(nesting, uri, location, name_location, comments)
         @parent_class = parent_class
       end
 
-      sig { override.returns(Integer) }
+      # @override
+      #: -> Integer
       def ancestor_hash
         [mixin_operation_module_names, @parent_class].hash
       end
     end
 
     class SingletonClass < Class
-      extend T::Sig
-
-      sig do
-        params(
-          location: Location,
-          name_location: Location,
-          comments: T.nilable(String),
-        ).void
-      end
+      #: (Location location, Location name_location, String? comments) -> void
       def update_singleton_information(location, name_location, comments)
         @location = location
         @name_location = name_location
@@ -241,13 +208,13 @@ module RubyIndexer
       abstract!
 
       # Name includes just the name of the parameter, excluding symbols like splats
-      sig { returns(Symbol) }
+      #: Symbol
       attr_reader :name
 
       # Decorated name is the parameter name including the splat or block prefix, e.g.: `*foo`, `**foo` or `&block`
       alias_method :decorated_name, :name
 
-      sig { params(name: Symbol).void }
+      #: (name: Symbol) -> void
       def initialize(name:)
         @name = name
       end
@@ -259,7 +226,8 @@ module RubyIndexer
 
     # An optional method parameter, e.g. `def foo(a = 123)`
     class OptionalParameter < Parameter
-      sig { override.returns(Symbol) }
+      # @override
+      #: -> Symbol
       def decorated_name
         :"#{@name} = <default>"
       end
@@ -267,7 +235,8 @@ module RubyIndexer
 
     # An required keyword method parameter, e.g. `def foo(a:)`
     class KeywordParameter < Parameter
-      sig { override.returns(Symbol) }
+      # @override
+      #: -> Symbol
       def decorated_name
         :"#{@name}:"
       end
@@ -275,7 +244,8 @@ module RubyIndexer
 
     # An optional keyword method parameter, e.g. `def foo(a: 123)`
     class OptionalKeywordParameter < Parameter
-      sig { override.returns(Symbol) }
+      # @override
+      #: -> Symbol
       def decorated_name
         :"#{@name}: <default>"
       end
@@ -283,9 +253,10 @@ module RubyIndexer
 
     # A rest method parameter, e.g. `def foo(*a)`
     class RestParameter < Parameter
-      DEFAULT_NAME = T.let(:"<anonymous splat>", Symbol)
+      DEFAULT_NAME = :"<anonymous splat>" #: Symbol
 
-      sig { override.returns(Symbol) }
+      # @override
+      #: -> Symbol
       def decorated_name
         :"*#{@name}"
       end
@@ -293,9 +264,10 @@ module RubyIndexer
 
     # A keyword rest method parameter, e.g. `def foo(**a)`
     class KeywordRestParameter < Parameter
-      DEFAULT_NAME = T.let(:"<anonymous keyword splat>", Symbol)
+      DEFAULT_NAME = :"<anonymous keyword splat>" #: Symbol
 
-      sig { override.returns(Symbol) }
+      # @override
+      #: -> Symbol
       def decorated_name
         :"**#{@name}"
       end
@@ -303,17 +275,17 @@ module RubyIndexer
 
     # A block method parameter, e.g. `def foo(&block)`
     class BlockParameter < Parameter
-      DEFAULT_NAME = T.let(:"<anonymous block>", Symbol)
+      DEFAULT_NAME = :"<anonymous block>" #: Symbol
 
       class << self
-        extend T::Sig
-        sig { returns(BlockParameter) }
+        #: -> BlockParameter
         def anonymous
           new(name: DEFAULT_NAME)
         end
       end
 
-      sig { override.returns(Symbol) }
+      # @override
+      #: -> Symbol
       def decorated_name
         :"&#{@name}"
       end
@@ -321,9 +293,7 @@ module RubyIndexer
 
     # A forwarding method parameter, e.g. `def foo(...)`
     class ForwardingParameter < Parameter
-      extend T::Sig
-
-      sig { void }
+      #: -> void
       def initialize
         # You can't name a forwarding parameter, it's always called `...`
         super(name: :"...")
@@ -336,19 +306,10 @@ module RubyIndexer
 
       abstract!
 
-      sig { returns(T.nilable(Entry::Namespace)) }
+      #: Entry::Namespace?
       attr_reader :owner
 
-      sig do
-        params(
-          name: String,
-          uri: URI::Generic,
-          location: Location,
-          comments: T.nilable(String),
-          visibility: Visibility,
-          owner: T.nilable(Entry::Namespace),
-        ).void
-      end
+      #: (String name, URI::Generic uri, Location location, String? comments, Visibility visibility, Entry::Namespace? owner) -> void
       def initialize(name, uri, location, comments, visibility, owner) # rubocop:disable Metrics/ParameterLists
         super(name, uri, location, comments)
         @visibility = visibility
@@ -358,7 +319,7 @@ module RubyIndexer
       sig { abstract.returns(T::Array[Entry::Signature]) }
       def signatures; end
 
-      sig { returns(String) }
+      #: -> String
       def decorated_parameters
         first_signature = signatures.first
         return "()" unless first_signature
@@ -366,7 +327,7 @@ module RubyIndexer
         "(#{first_signature.format})"
       end
 
-      sig { returns(String) }
+      #: -> String
       def formatted_signatures
         overloads_count = signatures.size
         case overloads_count
@@ -381,43 +342,26 @@ module RubyIndexer
     end
 
     class Accessor < Member
-      extend T::Sig
-
-      sig { override.returns(T::Array[Signature]) }
+      # @override
+      #: -> Array[Signature]
       def signatures
-        @signatures ||= T.let(
-          begin
-            params = []
-            params << RequiredParameter.new(name: name.delete_suffix("=").to_sym) if name.end_with?("=")
-            [Entry::Signature.new(params)]
-          end,
-          T.nilable(T::Array[Signature]),
-        )
+        @signatures ||= begin
+          params = []
+          params << RequiredParameter.new(name: name.delete_suffix("=").to_sym) if name.end_with?("=")
+          [Entry::Signature.new(params)]
+        end #: Array[Signature]?
       end
     end
 
     class Method < Member
-      extend T::Sig
-
-      sig { override.returns(T::Array[Signature]) }
+      #: Array[Signature]
       attr_reader :signatures
 
       # Returns the location of the method name, excluding parameters or the body
-      sig { returns(Location) }
+      #: Location
       attr_reader :name_location
 
-      sig do
-        params(
-          name: String,
-          uri: URI::Generic,
-          location: Location,
-          name_location: Location,
-          comments: T.nilable(String),
-          signatures: T::Array[Signature],
-          visibility: Visibility,
-          owner: T.nilable(Entry::Namespace),
-        ).void
-      end
+      #: (String name, URI::Generic uri, Location location, Location name_location, String? comments, Array[Signature] signatures, Visibility visibility, Entry::Namespace? owner) -> void
       def initialize(name, uri, location, name_location, comments, signatures, visibility, owner) # rubocop:disable Metrics/ParameterLists
         super(name, uri, location, comments, visibility, owner)
         @signatures = signatures
@@ -436,24 +380,13 @@ module RubyIndexer
     # target in [rdoc-ref:Index#resolve]. If the right hand side contains a constant that doesn't exist, then it's not
     # possible to resolve the alias and it will remain an UnresolvedAlias until the right hand side constant exists
     class UnresolvedConstantAlias < Entry
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :target
 
-      sig { returns(T::Array[String]) }
+      #: Array[String]
       attr_reader :nesting
 
-      sig do
-        params(
-          target: String,
-          nesting: T::Array[String],
-          name: String,
-          uri: URI::Generic,
-          location: Location,
-          comments: T.nilable(String),
-        ).void
-      end
+      #: (String target, Array[String] nesting, String name, URI::Generic uri, Location location, String? comments) -> void
       def initialize(target, nesting, name, uri, location, comments) # rubocop:disable Metrics/ParameterLists
         super(name, uri, location, comments)
 
@@ -464,12 +397,10 @@ module RubyIndexer
 
     # Alias represents a resolved alias, which points to an existing constant target
     class ConstantAlias < Entry
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :target
 
-      sig { params(target: String, unresolved_alias: UnresolvedConstantAlias).void }
+      #: (String target, UnresolvedConstantAlias unresolved_alias) -> void
       def initialize(target, unresolved_alias)
         super(
           unresolved_alias.name,
@@ -488,18 +419,10 @@ module RubyIndexer
 
     # Represents a class variable e.g.: @@a = 1
     class ClassVariable < Entry
-      sig { returns(T.nilable(Entry::Namespace)) }
+      #: Entry::Namespace?
       attr_reader :owner
 
-      sig do
-        params(
-          name: String,
-          uri: URI::Generic,
-          location: Location,
-          comments: T.nilable(String),
-          owner: T.nilable(Entry::Namespace),
-        ).void
-      end
+      #: (String name, URI::Generic uri, Location location, String? comments, Entry::Namespace? owner) -> void
       def initialize(name, uri, location, comments, owner)
         super(name, uri, location, comments)
         @owner = owner
@@ -508,18 +431,10 @@ module RubyIndexer
 
     # Represents an instance variable e.g.: @a = 1
     class InstanceVariable < Entry
-      sig { returns(T.nilable(Entry::Namespace)) }
+      #: Entry::Namespace?
       attr_reader :owner
 
-      sig do
-        params(
-          name: String,
-          uri: URI::Generic,
-          location: Location,
-          comments: T.nilable(String),
-          owner: T.nilable(Entry::Namespace),
-        ).void
-      end
+      #: (String name, URI::Generic uri, Location location, String? comments, Entry::Namespace? owner) -> void
       def initialize(name, uri, location, comments, owner)
         super(name, uri, location, comments)
         @owner = owner
@@ -530,24 +445,13 @@ module RubyIndexer
     # example, if we have `alias a b`, we create an unresolved alias for `a` because we aren't sure immediate what `b`
     # is referring to
     class UnresolvedMethodAlias < Entry
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :new_name, :old_name
 
-      sig { returns(T.nilable(Entry::Namespace)) }
+      #: Entry::Namespace?
       attr_reader :owner
 
-      sig do
-        params(
-          new_name: String,
-          old_name: String,
-          owner: T.nilable(Entry::Namespace),
-          uri: URI::Generic,
-          location: Location,
-          comments: T.nilable(String),
-        ).void
-      end
+      #: (String new_name, String old_name, Entry::Namespace? owner, URI::Generic uri, Location location, String? comments) -> void
       def initialize(new_name, old_name, owner, uri, location, comments) # rubocop:disable Metrics/ParameterLists
         super(new_name, uri, location, comments)
 
@@ -559,17 +463,13 @@ module RubyIndexer
 
     # A method alias is a resolved alias entry that points to the exact method target it refers to
     class MethodAlias < Entry
-      extend T::Sig
-
-      sig { returns(T.any(Member, MethodAlias)) }
+      #: (Member | MethodAlias)
       attr_reader :target
 
-      sig { returns(T.nilable(Entry::Namespace)) }
+      #: Entry::Namespace?
       attr_reader :owner
 
-      sig do
-        params(target: T.any(Member, MethodAlias), unresolved_alias: UnresolvedMethodAlias).void
-      end
+      #: ((Member | MethodAlias) target, UnresolvedMethodAlias unresolved_alias) -> void
       def initialize(target, unresolved_alias)
         full_comments = +"Alias for #{target.name}\n"
         full_comments << "#{unresolved_alias.comments}\n"
@@ -583,20 +483,20 @@ module RubyIndexer
         )
 
         @target = target
-        @owner = T.let(unresolved_alias.owner, T.nilable(Entry::Namespace))
+        @owner = unresolved_alias.owner #: Entry::Namespace?
       end
 
-      sig { returns(String) }
+      #: -> String
       def decorated_parameters
         @target.decorated_parameters
       end
 
-      sig { returns(String) }
+      #: -> String
       def formatted_signatures
         @target.formatted_signatures
       end
 
-      sig { returns(T::Array[Signature]) }
+      #: -> Array[Signature]
       def signatures
         @target.signatures
       end
@@ -606,18 +506,16 @@ module RubyIndexer
     # However RBS can represent the concept of method overloading, with different return types based on the arguments
     # passed, so we need to store all the signatures.
     class Signature
-      extend T::Sig
-
-      sig { returns(T::Array[Parameter]) }
+      #: Array[Parameter]
       attr_reader :parameters
 
-      sig { params(parameters: T::Array[Parameter]).void }
+      #: (Array[Parameter] parameters) -> void
       def initialize(parameters)
         @parameters = parameters
       end
 
       # Returns a string with the decorated names of the parameters of this member. E.g.: `(a, b = 1, c: 2)`
-      sig { returns(String) }
+      #: -> String
       def format
         @parameters.map(&:decorated_name).join(", ")
       end
@@ -637,13 +535,13 @@ module RubyIndexer
       # foo(1)
       # foo(1, 2)
       # ```
-      sig { params(arguments: T::Array[Prism::Node]).returns(T::Boolean) }
+      #: (Array[Prism::Node] arguments) -> bool
       def matches?(arguments)
         min_pos = 0
-        max_pos = T.let(0, T.any(Integer, Float))
+        max_pos = 0 #: (Integer | Float)
         names = []
-        has_forward = T.let(false, T::Boolean)
-        has_keyword_rest = T.let(false, T::Boolean)
+        has_forward = false #: bool
+        has_keyword_rest = false #: bool
 
         @parameters.each do |param|
           case param
@@ -688,15 +586,7 @@ module RubyIndexer
           )
       end
 
-      sig do
-        params(
-          positional_args: T::Array[Prism::Node],
-          forwarding_arguments: T::Array[Prism::Node],
-          keyword_args: T.nilable(T::Array[Prism::Node]),
-          min_pos: Integer,
-          max_pos: T.any(Integer, Float),
-        ).returns(T::Boolean)
-      end
+      #: (Array[Prism::Node] positional_args, Array[Prism::Node] forwarding_arguments, Array[Prism::Node]? keyword_args, Integer min_pos, (Integer | Float) max_pos) -> bool
       def positional_arguments_match?(positional_args, forwarding_arguments, keyword_args, min_pos, max_pos)
         # If the method accepts at least one positional argument and a splat has been passed
         (min_pos > 0 && positional_args.any? { |arg| arg.is_a?(Prism::SplatNode) }) ||
@@ -709,7 +599,7 @@ module RubyIndexer
           (min_pos == 0 && positional_args.empty?)
       end
 
-      sig { params(args: T.nilable(T::Array[Prism::Node]), names: T::Array[Symbol]).returns(T::Boolean) }
+      #: (Array[Prism::Node]? args, Array[Symbol] names) -> bool
       def keyword_arguments_match?(args, names)
         return true unless args
         return true if args.any? { |arg| arg.is_a?(Prism::AssocSplatNode) }