ruby-lsp 0.23.11 → 0.26.1

data/lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb

@@ -3,21 +3,14 @@
 
 module RubyIndexer
   class ReferenceFinder
-    extend T::Sig
-
-    class Target
-      extend T::Helpers
-
-      abstract!
-    end
+    # @abstract
+    class Target; end
 
     class ConstTarget < Target
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :fully_qualified_name
 
-      sig { params(fully_qualified_name: String).void }
+      #: (String fully_qualified_name) -> void
       def initialize(fully_qualified_name)
         super()
         @fully_qualified_name = fully_qualified_name
@@ -25,12 +18,10 @@ module RubyIndexer
     end
 
     class MethodTarget < Target
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :method_name
 
-      sig { params(method_name: String).void }
+      #: (String method_name) -> void
       def initialize(method_name)
         super()
         @method_name = method_name
@@ -38,31 +29,31 @@ module RubyIndexer
     end
 
     class InstanceVariableTarget < Target
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :name
 
-      sig { params(name: String).void }
-      def initialize(name)
+      #: Array[String]
+      attr_reader :owner_ancestors
+
+      #: (String name, Array[String] owner_ancestors) -> void
+      def initialize(name, owner_ancestors)
         super()
         @name = name
+        @owner_ancestors = owner_ancestors
       end
     end
 
     class Reference
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :name
 
-      sig { returns(Prism::Location) }
+      #: Prism::Location
       attr_reader :location
 
-      sig { returns(T::Boolean) }
+      #: bool
       attr_reader :declaration
 
-      sig { params(name: String, location: Prism::Location, declaration: T::Boolean).void }
+      #: (String name, Prism::Location location, declaration: bool) -> void
       def initialize(name, location, declaration:)
         @name = name
         @location = location
@@ -70,22 +61,14 @@ module RubyIndexer
       end
     end
 
-    sig do
-      params(
-        target: Target,
-        index: RubyIndexer::Index,
-        dispatcher: Prism::Dispatcher,
-        uri: URI::Generic,
-        include_declarations: T::Boolean,
-      ).void
-    end
+    #: (Target target, RubyIndexer::Index index, Prism::Dispatcher dispatcher, URI::Generic uri, ?include_declarations: bool) -> void
     def initialize(target, index, dispatcher, uri, include_declarations: true)
       @target = target
       @index = index
       @uri = uri
       @include_declarations = include_declarations
-      @stack = T.let([], T::Array[String])
-      @references = T.let([], T::Array[Reference])
+      @stack = [] #: Array[String]
+      @references = [] #: Array[Reference]
 
       dispatcher.register(
         self,
@@ -119,34 +102,34 @@ module RubyIndexer
       )
     end
 
-    sig { returns(T::Array[Reference]) }
+    #: -> Array[Reference]
     def references
       return @references if @include_declarations
 
       @references.reject(&:declaration)
     end
 
-    sig { params(node: Prism::ClassNode).void }
+    #: (Prism::ClassNode node) -> void
     def on_class_node_enter(node)
       @stack << node.constant_path.slice
     end
 
-    sig { params(node: Prism::ClassNode).void }
+    #: (Prism::ClassNode node) -> void
     def on_class_node_leave(node)
       @stack.pop
     end
 
-    sig { params(node: Prism::ModuleNode).void }
+    #: (Prism::ModuleNode node) -> void
     def on_module_node_enter(node)
       @stack << node.constant_path.slice
     end
 
-    sig { params(node: Prism::ModuleNode).void }
+    #: (Prism::ModuleNode node) -> void
     def on_module_node_leave(node)
       @stack.pop
     end
 
-    sig { params(node: Prism::SingletonClassNode).void }
+    #: (Prism::SingletonClassNode node) -> void
     def on_singleton_class_node_enter(node)
       expression = node.expression
       return unless expression.is_a?(Prism::SelfNode)
@@ -154,12 +137,12 @@ module RubyIndexer
       @stack << "<Class:#{@stack.last}>"
     end
 
-    sig { params(node: Prism::SingletonClassNode).void }
+    #: (Prism::SingletonClassNode node) -> void
     def on_singleton_class_node_leave(node)
       @stack.pop
     end
 
-    sig { params(node: Prism::ConstantPathNode).void }
+    #: (Prism::ConstantPathNode node) -> void
     def on_constant_path_node_enter(node)
       name = Index.constant_name(node)
       return unless name
@@ -167,7 +150,7 @@ module RubyIndexer
       collect_constant_references(name, node.location)
     end
 
-    sig { params(node: Prism::ConstantReadNode).void }
+    #: (Prism::ConstantReadNode node) -> void
     def on_constant_read_node_enter(node)
       name = Index.constant_name(node)
       return unless name
@@ -175,7 +158,7 @@ module RubyIndexer
       collect_constant_references(name, node.location)
     end
 
-    sig { params(node: Prism::MultiWriteNode).void }
+    #: (Prism::MultiWriteNode node) -> void
     def on_multi_write_node_enter(node)
       [*node.lefts, *node.rest, *node.rights].each do |target|
         case target
@@ -185,7 +168,7 @@ module RubyIndexer
       end
     end
 
-    sig { params(node: Prism::ConstantPathWriteNode).void }
+    #: (Prism::ConstantPathWriteNode node) -> void
     def on_constant_path_write_node_enter(node)
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -196,7 +179,7 @@ module RubyIndexer
       collect_constant_references(name, target.location)
     end
 
-    sig { params(node: Prism::ConstantPathOrWriteNode).void }
+    #: (Prism::ConstantPathOrWriteNode node) -> void
     def on_constant_path_or_write_node_enter(node)
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -207,7 +190,7 @@ module RubyIndexer
       collect_constant_references(name, target.location)
     end
 
-    sig { params(node: Prism::ConstantPathOperatorWriteNode).void }
+    #: (Prism::ConstantPathOperatorWriteNode node) -> void
     def on_constant_path_operator_write_node_enter(node)
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -218,7 +201,7 @@ module RubyIndexer
       collect_constant_references(name, target.location)
     end
 
-    sig { params(node: Prism::ConstantPathAndWriteNode).void }
+    #: (Prism::ConstantPathAndWriteNode node) -> void
     def on_constant_path_and_write_node_enter(node)
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -229,27 +212,27 @@ module RubyIndexer
       collect_constant_references(name, target.location)
     end
 
-    sig { params(node: Prism::ConstantWriteNode).void }
+    #: (Prism::ConstantWriteNode node) -> void
     def on_constant_write_node_enter(node)
       collect_constant_references(node.name.to_s, node.name_loc)
     end
 
-    sig { params(node: Prism::ConstantOrWriteNode).void }
+    #: (Prism::ConstantOrWriteNode node) -> void
     def on_constant_or_write_node_enter(node)
       collect_constant_references(node.name.to_s, node.name_loc)
     end
 
-    sig { params(node: Prism::ConstantAndWriteNode).void }
+    #: (Prism::ConstantAndWriteNode node) -> void
     def on_constant_and_write_node_enter(node)
       collect_constant_references(node.name.to_s, node.name_loc)
     end
 
-    sig { params(node: Prism::ConstantOperatorWriteNode).void }
+    #: (Prism::ConstantOperatorWriteNode node) -> void
     def on_constant_operator_write_node_enter(node)
       collect_constant_references(node.name.to_s, node.name_loc)
     end
 
-    sig { params(node: Prism::DefNode).void }
+    #: (Prism::DefNode node) -> void
     def on_def_node_enter(node)
       if @target.is_a?(MethodTarget) && (name = node.name.to_s) == @target.method_name
         @references << Reference.new(name, node.name_loc, declaration: true)
@@ -260,53 +243,57 @@ module RubyIndexer
       end
     end
 
-    sig { params(node: Prism::DefNode).void }
+    #: (Prism::DefNode node) -> void
     def on_def_node_leave(node)
       if node.receiver.is_a?(Prism::SelfNode)
         @stack.pop
       end
     end
 
-    sig { params(node: Prism::InstanceVariableReadNode).void }
+    #: (Prism::InstanceVariableReadNode node) -> void
     def on_instance_variable_read_node_enter(node)
       collect_instance_variable_references(node.name.to_s, node.location, false)
     end
 
-    sig { params(node: Prism::InstanceVariableWriteNode).void }
+    #: (Prism::InstanceVariableWriteNode node) -> void
     def on_instance_variable_write_node_enter(node)
       collect_instance_variable_references(node.name.to_s, node.name_loc, true)
     end
 
-    sig { params(node: Prism::InstanceVariableAndWriteNode).void }
+    #: (Prism::InstanceVariableAndWriteNode node) -> void
     def on_instance_variable_and_write_node_enter(node)
       collect_instance_variable_references(node.name.to_s, node.name_loc, true)
     end
 
-    sig { params(node: Prism::InstanceVariableOperatorWriteNode).void }
+    #: (Prism::InstanceVariableOperatorWriteNode node) -> void
     def on_instance_variable_operator_write_node_enter(node)
       collect_instance_variable_references(node.name.to_s, node.name_loc, true)
     end
 
-    sig { params(node: Prism::InstanceVariableOrWriteNode).void }
+    #: (Prism::InstanceVariableOrWriteNode node) -> void
     def on_instance_variable_or_write_node_enter(node)
       collect_instance_variable_references(node.name.to_s, node.name_loc, true)
     end
 
-    sig { params(node: Prism::InstanceVariableTargetNode).void }
+    #: (Prism::InstanceVariableTargetNode node) -> void
     def on_instance_variable_target_node_enter(node)
       collect_instance_variable_references(node.name.to_s, node.location, true)
     end
 
-    sig { params(node: Prism::CallNode).void }
+    #: (Prism::CallNode node) -> void
     def on_call_node_enter(node)
       if @target.is_a?(MethodTarget) && (name = node.name.to_s) == @target.method_name
-        @references << Reference.new(name, T.must(node.message_loc), declaration: false)
+        @references << Reference.new(
+          name,
+          node.message_loc, #: as !nil
+          declaration: false,
+        )
       end
     end
 
     private
 
-    sig { params(name: String, location: Prism::Location).void }
+    #: (String name, Prism::Location location) -> void
     def collect_constant_references(name, location)
       return unless @target.is_a?(ConstTarget)
 
@@ -335,11 +322,14 @@ module RubyIndexer
       @references << Reference.new(name, location, declaration: declaration)
     end
 
-    sig { params(name: String, location: Prism::Location, declaration: T::Boolean).void }
+    #: (String name, Prism::Location location, bool declaration) -> void
     def collect_instance_variable_references(name, location, declaration)
       return unless @target.is_a?(InstanceVariableTarget) && name == @target.name
 
-      @references << Reference.new(name, location, declaration: declaration)
+      receiver_type = Index.actual_nesting(@stack, nil).join("::")
+      if @target.owner_ancestors.include?(receiver_type)
+        @references << Reference.new(name, location, declaration: declaration)
+      end
     end
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/uri.rb

@@ -1,35 +1,33 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "uri"
+
 module URI
   class Generic
-    extend T::Sig
-
     # Avoid a deprecation warning with Ruby 3.4 where the default parser was changed to RFC3986.
     # This condition must remain even after support for 3.4 has been dropped for users that have
     # `uri` in their lockfile, decoupling it from the ruby version.
-    PARSER = T.let(const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER, RFC2396_Parser)
 
-    class << self
-      extend T::Sig
+    # NOTE: We also define this in the shim
+    PARSER = const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER
 
-      sig do
-        params(
-          path: String,
-          fragment: T.nilable(String),
-          scheme: String,
-          load_path_entry: T.nilable(String),
-        ).returns(URI::Generic)
-      end
+    class << self
+      #: (path: String, ?fragment: String?, ?scheme: String, ?load_path_entry: String?) -> URI::Generic
       def from_path(path:, fragment: nil, scheme: "file", load_path_entry: nil)
+        # This unsafe regex is the same one used in the URI::RFC2396_REGEXP class with the exception of the fact that we
+        # do not include colon as a safe character. VS Code URIs always escape colons and we need to ensure we do the
+        # same to avoid inconsistencies in our URIs, which are used to identify resources
+        unsafe_regex = %r{[^\-_.!~*'()a-zA-Z\d;/?@&=+$,\[\]]}
+
         # On Windows, if the path begins with the disk name, we need to add a leading slash to make it a valid URI
         escaped_path = if /^[A-Z]:/i.match?(path)
-          PARSER.escape("/#{path}")
+          PARSER.escape("/#{path}", unsafe_regex)
         elsif path.start_with?("//?/")
           # Some paths on Windows start with "//?/". This is a special prefix that allows for long file paths
-          PARSER.escape(path.delete_prefix("//?"))
+          PARSER.escape(path.delete_prefix("//?"), unsafe_regex)
         else
-          PARSER.escape(path)
+          PARSER.escape(path, unsafe_regex)
         end
 
         uri = build(scheme: scheme, path: escaped_path, fragment: fragment)
@@ -42,10 +40,10 @@ module URI
       end
     end
 
-    sig { returns(T.nilable(String)) }
+    #: String?
     attr_accessor :require_path
 
-    sig { params(load_path_entry: String).void }
+    #: (String load_path_entry) -> void
     def add_require_path_from_load_entry(load_path_entry)
       path = to_standardized_path
       return unless path
@@ -53,7 +51,7 @@ module URI
       self.require_path = path.delete_prefix("#{load_path_entry}/").delete_suffix(".rb")
     end
 
-    sig { returns(T.nilable(String)) }
+    #: -> String?
     def to_standardized_path
       parsed_path = path
       return unless parsed_path

data/lib/ruby_indexer/lib/ruby_indexer/visibility_scope.rb

@@ -5,30 +5,26 @@ module RubyIndexer
   # Represents the visibility scope in a Ruby namespace. This keeps track of whether methods are in a public, private or
   # protected section, and whether they are module functions.
   class VisibilityScope
-    extend T::Sig
-
     class << self
-      extend T::Sig
-
-      sig { returns(T.attached_class) }
+      #: -> instance
       def module_function_scope
-        new(module_func: true, visibility: Entry::Visibility::PRIVATE)
+        new(module_func: true, visibility: :private)
       end
 
-      sig { returns(T.attached_class) }
+      #: -> instance
       def public_scope
         new
       end
     end
 
-    sig { returns(Entry::Visibility) }
+    #: Symbol
     attr_reader :visibility
 
-    sig { returns(T::Boolean) }
+    #: bool
     attr_reader :module_func
 
-    sig { params(visibility: Entry::Visibility, module_func: T::Boolean).void }
-    def initialize(visibility: Entry::Visibility::PUBLIC, module_func: false)
+    #: (?visibility: Symbol, ?module_func: bool) -> void
+    def initialize(visibility: :public, module_func: false)
       @visibility = visibility
       @module_func = module_func
     end

data/lib/ruby_indexer/test/class_variables_test.rb

@@ -14,8 +14,8 @@ module RubyIndexer
 
       assert_entry("@@bar", Entry::ClassVariable, "/fake/path/foo.rb:1-2:1-7")
 
-      entry = T.must(@index["@@bar"]&.first)
-      owner = T.must(entry.owner)
+      entry = @index["@@bar"]&.first #: as Entry::ClassVariable
+      owner = entry.owner #: as !nil
       assert_instance_of(Entry::Class, owner)
       assert_equal("Foo", owner.name)
     end
@@ -50,13 +50,13 @@ module RubyIndexer
       assert_entry("@@foo", Entry::ClassVariable, "/fake/path/foo.rb:1-2:1-7")
       assert_entry("@@bar", Entry::ClassVariable, "/fake/path/foo.rb:1-9:1-14")
 
-      entry = T.must(@index["@@foo"]&.first)
-      owner = T.must(entry.owner)
+      entry = @index["@@foo"]&.first #: as Entry::ClassVariable
+      owner = entry.owner #: as !nil
       assert_instance_of(Entry::Class, owner)
       assert_equal("Foo", owner.name)
 
-      entry = T.must(@index["@@bar"]&.first)
-      owner = T.must(entry.owner)
+      entry = @index["@@bar"]&.first #: as Entry::ClassVariable
+      owner = entry.owner #: as !nil
       assert_instance_of(Entry::Class, owner)
       assert_equal("Foo", owner.name)
     end
@@ -83,10 +83,10 @@ module RubyIndexer
 
     def test_top_level_class_variable
       index(<<~RUBY)
-        @foo = 123
+        @@foo = 123
       RUBY
 
-      entry = T.must(@index["@foo"]&.first)
+      entry = @index["@@foo"]&.first #: as Entry::ClassVariable
       assert_nil(entry.owner)
     end
 
@@ -99,8 +99,8 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["@@bar"]&.first)
-      owner = T.must(entry.owner)
+      entry = @index["@@bar"]&.first #: as Entry::ClassVariable
+      owner = entry.owner #: as !nil
       assert_instance_of(Entry::Class, owner)
       assert_equal("Foo", owner.name)
     end
@@ -114,8 +114,8 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["@@bar"]&.first)
-      owner = T.must(entry.owner)
+      entry = @index["@@bar"]&.first #: as Entry::ClassVariable
+      owner = entry.owner #: as !nil
       assert_instance_of(Entry::Class, owner)
       assert_equal("Foo", owner.name)
     end
@@ -131,8 +131,8 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["@@bar"]&.first)
-      owner = T.must(entry.owner)
+      entry = @index["@@bar"]&.first #: as Entry::ClassVariable
+      owner = entry.owner #: as !nil
       assert_instance_of(Entry::Class, owner)
       assert_equal("Foo", owner.name)
     end