ruby-lsp 0.17.4 → 0.17.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71204369ec5201376f1af11875a2e1bf16df56a31719ea78932a7f5f6e9c7e5c
-  data.tar.gz: d83e299ade275415fe4cac25abe78f7ee7ec622c47cc1699d42b3b772816fdba
+  metadata.gz: 7299237468ae17d80028a1454903f58b1be4ff34428a6c8a538530b5caad54d1
+  data.tar.gz: 26351e5be1671219a9b3624076b2f50fb68c5838303fe1a021eecb39c4e3e9f1
 SHA512:
-  metadata.gz: f3ac517cb1c711dc1a5ddf2c4027f705e393e30028b9ae7063b18a5f51362fd4d7277607d19d8ca7a9a3c9146960bd612a02ed4a8933c8223a42daf3dfe5e63b
-  data.tar.gz: 0c4408865d1894547aeedfc0441fa558a8281f54e7e26c38b619e67fd67bfc3bed49aa27dc06d8b89924c7ee8db4452b5cd2f810c0dfb01157eef127910b2182
+  metadata.gz: 54cc76a3506a268398cfc51645a70300e2d14bda5b39c12274863270f70ed666b33bfebdf50dac8e013410e8ddba5645f4f435863af795d268710e0ccf9d8814
+  data.tar.gz: 95e52a4aa6f68785495f7435fe54cc395c062809ad3754703f808c68d2599bc34a619578bbb8453cb54de88a8312ac49eff8dd2e72a82bc04554c7b659c477cd

data/README.md

@@ -109,6 +109,10 @@ features. This is the mechanism that powers addons like
 - [Ruby LSP RSpec](https://github.com/st0012/ruby-lsp-rspec)
 - [Ruby LSP rubyfmt](https://github.com/jscharf/ruby-lsp-rubyfmt)
 
+Additionally, some tools may include a Ruby LSP addon directly, like
+
+- [Standard Ruby (from v1.39.1)](https://github.com/standardrb/standard/wiki/IDE:-vscode#using-ruby-lsp)
+
 Other community driven addons can be found in [rubygems](https://rubygems.org/search?query=name%3A+ruby-lsp) by
 searching for the `ruby-lsp` prefix.
 

data/VERSION

@@ -1 +1 @@
-0.17.4
+0.17.6

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -64,7 +64,8 @@ module RubyIndexer
     sig { params(node: Prism::ClassNode).void }
     def on_class_node_enter(node)
       @visibility_stack.push(Entry::Visibility::PUBLIC)
-      name = node.constant_path.location.slice
+      constant_path = node.constant_path
+      name = constant_path.slice
 
       comments = collect_comments(node)
 
@@ -93,6 +94,7 @@ module RubyIndexer
         nesting,
         @file_path,
         node.location,
+        constant_path.location,
         comments,
         parent_class,
       )
@@ -112,12 +114,13 @@ module RubyIndexer
     sig { params(node: Prism::ModuleNode).void }
     def on_module_node_enter(node)
       @visibility_stack.push(Entry::Visibility::PUBLIC)
-      name = node.constant_path.location.slice
+      constant_path = node.constant_path
+      name = constant_path.slice
 
       comments = collect_comments(node)
 
       nesting = name.start_with?("::") ? [name.delete_prefix("::")] : @stack + [name.delete_prefix("::")]
-      entry = Entry::Module.new(nesting, @file_path, node.location, comments)
+      entry = Entry::Module.new(nesting, @file_path, node.location, constant_path.location, comments)
 
       @owner_stack << entry
       @index.add(entry)
@@ -145,9 +148,16 @@ module RubyIndexer
 
         if existing_entries
           entry = T.must(existing_entries.first)
-          entry.update_singleton_information(node.location, collect_comments(node))
+          entry.update_singleton_information(node.location, expression.location, collect_comments(node))
         else
-          entry = Entry::SingletonClass.new(@stack, @file_path, node.location, collect_comments(node), nil)
+          entry = Entry::SingletonClass.new(
+            @stack,
+            @file_path,
+            node.location,
+            expression.location,
+            collect_comments(node),
+            nil,
+          )
           @index.add(entry, skip_prefix_tree: true)
         end
 
@@ -297,25 +307,29 @@ module RubyIndexer
           method_name,
           @file_path,
           node.location,
+          node.name_loc,
           comments,
-          list_params(node.parameters),
+          [Entry::Signature.new(list_params(node.parameters))],
           current_visibility,
           @owner_stack.last,
         ))
       when Prism::SelfNode
-        singleton = singleton_klass
+        owner = @owner_stack.last
+
+        if owner
+          singleton = @index.existing_or_new_singleton_class(owner.name)
+
+          @index.add(Entry::Method.new(
+            method_name,
+            @file_path,
+            node.location,
+            node.name_loc,
+            comments,
+            [Entry::Signature.new(list_params(node.parameters))],
+            current_visibility,
+            singleton,
+          ))
 
-        @index.add(Entry::Method.new(
-          method_name,
-          @file_path,
-          node.location,
-          comments,
-          list_params(node.parameters),
-          current_visibility,
-          singleton,
-        ))
-
-        if singleton
           @owner_stack << singleton
           @stack << "<Class:#{@stack.last}>"
         end
@@ -393,7 +407,12 @@ module RubyIndexer
 
       # When instance variables are declared inside the class body, they turn into class instance variables rather than
       # regular instance variables
-      owner = @inside_def ? @owner_stack.last : singleton_klass
+      owner = @owner_stack.last
+
+      if owner && !@inside_def
+        owner = @index.existing_or_new_singleton_class(owner.name)
+      end
+
       @index.add(Entry::InstanceVariable.new(name, @file_path, loc, collect_comments(node), owner))
     end
 
@@ -593,7 +612,8 @@ module RubyIndexer
         when :prepend
           owner.mixin_operations << Entry::Prepend.new(node.full_name)
         when :extend
-          owner.mixin_operations << Entry::Extend.new(node.full_name)
+          singleton = @index.existing_or_new_singleton_class(owner.name)
+          singleton.mixin_operations << Entry::Include.new(node.full_name)
         end
       rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
              Prism::ConstantPathNode::MissingNodesInConstantPathError
@@ -689,24 +709,5 @@ module RubyIndexer
         :"(#{names_with_commas})"
       end
     end
-
-    sig { returns(T.nilable(Entry::Class)) }
-    def singleton_klass
-      attached_class = @owner_stack.last
-      return unless attached_class
-
-      # Return the existing singleton class if available
-      owner = T.cast(
-        @index["#{attached_class.name}::<Class:#{attached_class.name}>"],
-        T.nilable(T::Array[Entry::SingletonClass]),
-      )
-      return owner.first if owner
-
-      # If not available, create the singleton class lazily
-      nesting = @stack + ["<Class:#{@stack.last}>"]
-      entry = Entry::SingletonClass.new(nesting, @file_path, attached_class.location, [], nil)
-      @index.add(entry, skip_prefix_tree: true)
-      entry
-    end
   end
 end

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

@@ -22,6 +22,8 @@ module RubyIndexer
     sig { returns(RubyIndexer::Location) }
     attr_reader :location
 
+    alias_method :name_location, :location
+
     sig { returns(T::Array[String]) }
     attr_reader :comments
 
@@ -57,6 +59,16 @@ module RubyIndexer
       )
     end
 
+    sig { returns(T::Boolean) }
+    def public?
+      visibility == Visibility::PUBLIC
+    end
+
+    sig { returns(T::Boolean) }
+    def protected?
+      visibility == Visibility::PROTECTED
+    end
+
     sig { returns(T::Boolean) }
     def private?
       visibility == Visibility::PRIVATE
@@ -84,7 +96,6 @@ module RubyIndexer
 
     class Include < ModuleOperation; end
     class Prepend < ModuleOperation; end
-    class Extend < ModuleOperation; end
 
     class Namespace < Entry
       extend T::Sig
@@ -95,20 +106,39 @@ module RubyIndexer
       sig { returns(T::Array[String]) }
       attr_reader :nesting
 
+      # Returns the location of the constant name, excluding the parent class or the body
+      sig { returns(Location) }
+      attr_reader :name_location
+
       sig do
         params(
           nesting: T::Array[String],
           file_path: String,
           location: T.any(Prism::Location, RubyIndexer::Location),
+          name_location: T.any(Prism::Location, Location),
           comments: T::Array[String],
         ).void
       end
-      def initialize(nesting, file_path, location, comments)
+      def initialize(nesting, file_path, location, name_location, comments)
         @name = T.let(nesting.join("::"), String)
         # The original nesting where this namespace was discovered
         @nesting = nesting
 
         super(@name, file_path, location, comments)
+
+        @name_location = T.let(
+          if name_location.is_a?(Prism::Location)
+            Location.new(
+              name_location.start_line,
+              name_location.end_line,
+              name_location.start_column,
+              name_location.end_column,
+            )
+          else
+            name_location
+          end,
+          RubyIndexer::Location,
+        )
       end
 
       sig { returns(T::Array[String]) }
@@ -146,12 +176,13 @@ module RubyIndexer
           nesting: T::Array[String],
           file_path: String,
           location: T.any(Prism::Location, RubyIndexer::Location),
+          name_location: T.any(Prism::Location, Location),
           comments: T::Array[String],
           parent_class: T.nilable(String),
         ).void
       end
-      def initialize(nesting, file_path, location, comments, parent_class)
-        super(nesting, file_path, location, comments)
+      def initialize(nesting, file_path, location, name_location, comments, parent_class) # rubocop:disable Metrics/ParameterLists
+        super(nesting, file_path, location, name_location, comments)
         @parent_class = parent_class
       end
 
@@ -164,8 +195,8 @@ module RubyIndexer
     class SingletonClass < Class
       extend T::Sig
 
-      sig { params(location: Prism::Location, comments: T::Array[String]).void }
-      def update_singleton_information(location, comments)
+      sig { params(location: Prism::Location, name_location: Prism::Location, comments: T::Array[String]).void }
+      def update_singleton_information(location, name_location, comments)
         # Create a new RubyIndexer::Location object from the Prism location
         @location = Location.new(
           location.start_line,
@@ -173,6 +204,12 @@ module RubyIndexer
           location.start_column,
           location.end_column,
         )
+        @name_location = Location.new(
+          name_location.start_line,
+          name_location.end_line,
+          name_location.start_column,
+          name_location.end_column,
+        )
         @comments.concat(comments)
       end
     end
@@ -251,6 +288,14 @@ module RubyIndexer
     class BlockParameter < Parameter
       DEFAULT_NAME = T.let(:"<anonymous block>", Symbol)
 
+      class << self
+        extend T::Sig
+        sig { returns(BlockParameter) }
+        def anonymous
+          new(name: DEFAULT_NAME)
+        end
+      end
+
       sig { override.returns(Symbol) }
       def decorated_name
         :"&#{@name}"
@@ -266,6 +311,11 @@ module RubyIndexer
       sig { returns(T.nilable(Entry::Namespace)) }
       attr_reader :owner
 
+      sig { returns(T::Array[RubyIndexer::Entry::Parameter]) }
+      def parameters
+        T.must(signatures.first).parameters
+      end
+
       sig do
         params(
           name: String,
@@ -282,47 +332,72 @@ module RubyIndexer
         @owner = owner
       end
 
-      sig { abstract.returns(T::Array[Parameter]) }
-      def parameters; end
+      sig { abstract.returns(T::Array[Entry::Signature]) }
+      def signatures; end
 
-      # Returns a string with the decorated names of the parameters of this member. E.g.: `(a, b = 1, c: 2)`
       sig { returns(String) }
       def decorated_parameters
-        "(#{parameters.map(&:decorated_name).join(", ")})"
+        first_signature = signatures.first
+        return "()" unless first_signature
+
+        "(#{first_signature.format})"
       end
     end
 
     class Accessor < Member
       extend T::Sig
 
-      sig { override.returns(T::Array[Parameter]) }
-      def parameters
-        params = []
-        params << RequiredParameter.new(name: name.delete_suffix("=").to_sym) if name.end_with?("=")
-        params
+      sig { override.returns(T::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]),
+        )
       end
     end
 
     class Method < Member
       extend T::Sig
 
-      sig { override.returns(T::Array[Parameter]) }
-      attr_reader :parameters
+      sig { override.returns(T::Array[Signature]) }
+      attr_reader :signatures
+
+      # Returns the location of the method name, excluding parameters or the body
+      sig { returns(Location) }
+      attr_reader :name_location
 
       sig do
         params(
           name: String,
           file_path: String,
           location: T.any(Prism::Location, RubyIndexer::Location),
+          name_location: T.any(Prism::Location, Location),
           comments: T::Array[String],
-          parameters: T::Array[Parameter],
+          signatures: T::Array[Signature],
           visibility: Visibility,
           owner: T.nilable(Entry::Namespace),
         ).void
       end
-      def initialize(name, file_path, location, comments, parameters, visibility, owner) # rubocop:disable Metrics/ParameterLists
+      def initialize(name, file_path, location, name_location, comments, signatures, visibility, owner) # rubocop:disable Metrics/ParameterLists
         super(name, file_path, location, comments, visibility, owner)
-        @parameters = parameters
+        @signatures = signatures
+        @name_location = T.let(
+          if name_location.is_a?(Prism::Location)
+            Location.new(
+              name_location.start_line,
+              name_location.end_line,
+              name_location.start_column,
+              name_location.end_column,
+            )
+          else
+            name_location
+          end,
+          RubyIndexer::Location,
+        )
       end
     end
 
@@ -437,6 +512,9 @@ module RubyIndexer
       sig { returns(T.any(Member, MethodAlias)) }
       attr_reader :target
 
+      sig { returns(T.nilable(Entry::Namespace)) }
+      attr_reader :owner
+
       sig { params(target: T.any(Member, MethodAlias), unresolved_alias: UnresolvedMethodAlias).void }
       def initialize(target, unresolved_alias)
         full_comments = ["Alias for #{target.name}\n"]
@@ -452,11 +530,7 @@ module RubyIndexer
         )
 
         @target = target
-      end
-
-      sig { returns(T.nilable(Entry::Namespace)) }
-      def owner
-        @target.owner
+        @owner = T.let(unresolved_alias.owner, T.nilable(Entry::Namespace))
       end
 
       sig { returns(T::Array[Parameter]) }
@@ -469,5 +543,26 @@ module RubyIndexer
         @target.decorated_parameters
       end
     end
+
+    # Ruby doesn't support method overloading, so a method will have only one signature.
+    # 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]) }
+      attr_reader :parameters
+
+      sig { params(parameters: T::Array[Parameter]).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) }
+      def format
+        @parameters.map(&:decorated_name).join(", ")
+      end
+    end
   end
 end