ruby-lsp 0.18.3 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 399abe97e6c7a69238a01464936c1c8e9365462e142a1175fdccc37b8ee32882
-  data.tar.gz: 97fe2193dd4569a78e1e2a55911adfd833ba7c791955953385152d0fd930b685
+  metadata.gz: f1d89f4c5d5724a4b8c17002986c64d9f3ea2951282e4a35d96d50b0dd699ba9
+  data.tar.gz: f3513888e58fbde4a85d93a2ef58ae124e02c354729693ae5e928a66548cd058
 SHA512:
-  metadata.gz: dd5960a18a96e3f5c40aa768f47977097e74c68b470adba70903436ffeef6e4e0038e4ea6bcd8d19f9dc1d4b23e0c36b11d9f5b4fd61e75346dda28b98582620
-  data.tar.gz: d021ddfd3850a4a5378232ecc6788f5c335d56d6093211ce4fb968738ce38c8d53bddca6f0a820af13e7a240d7c157bf07263960593128d7e2c48e5a798b5cfc
+  metadata.gz: 57b44fec7c55b57408e042a9c40fe900c2445aa9fefa811223aa3154f5a4e1e8b1d0f11cf306548b13653f3a61877bcb8d01df7beeadb4766f2094b27786653b
+  data.tar.gz: cf769828221a3a1cb65e906b2b9c5c0c8fac8feee265e5f31b90fb96813f10a225798da1b3746165e11fd4591f7bd0620ab177233c2214d939986e22a1e3709b

data/VERSION

@@ -1 +1 @@
-0.18.3
+0.19.0

data/lib/core_ext/uri.rb

@@ -3,6 +3,11 @@
 
 module URI
   class Generic
+    # 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
 
@@ -10,12 +15,12 @@ module URI
       def from_path(path:, fragment: nil, scheme: "file")
         # 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)
-          DEFAULT_PARSER.escape("/#{path}")
+          PARSER.escape("/#{path}")
         elsif path.start_with?("//?/")
           # Some paths on Windows start with "//?/". This is a special prefix that allows for long file paths
-          DEFAULT_PARSER.escape(path.delete_prefix("//?"))
+          PARSER.escape(path.delete_prefix("//?"))
         else
-          DEFAULT_PARSER.escape(path)
+          PARSER.escape(path)
         end
 
         build(scheme: scheme, path: escaped_path, fragment: fragment)
@@ -29,7 +34,7 @@ module URI
       parsed_path = path
       return unless parsed_path
 
-      unescaped_path = DEFAULT_PARSER.unescape(parsed_path)
+      unescaped_path = PARSER.unescape(parsed_path)
 
       # On Windows, when we're getting the file system path back from the URI, we need to remove the leading forward
       # slash

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -19,9 +19,13 @@ module RubyIndexer
     sig { params(workspace_path: String).void }
     attr_writer :workspace_path
 
+    sig { returns(Encoding) }
+    attr_accessor :encoding
+
     sig { void }
     def initialize
       @workspace_path = T.let(Dir.pwd, String)
+      @encoding = T.let(Encoding::UTF_8, Encoding)
       @excluded_gems = T.let(initial_excluded_gems, T::Array[String])
       @included_gems = T.let([], T::Array[String])
       @excluded_patterns = T.let([File.join("**", "*_test.rb"), File.join("tmp", "**", "*")], T::Array[String])
@@ -235,6 +239,8 @@ module RubyIndexer
 
       excluded.uniq!
       excluded.map(&:name)
+    rescue Bundler::GemfileNotFound
+      []
     end
   end
 end

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

@@ -109,6 +109,7 @@ module RubyIndexer
         node.location,
         constant_path.location,
         comments,
+        @index.configuration.encoding,
         parent_class,
       )
 
@@ -132,7 +133,14 @@ module RubyIndexer
 
       comments = collect_comments(node)
 
-      entry = Entry::Module.new(actual_nesting(name), @file_path, node.location, constant_path.location, comments)
+      entry = Entry::Module.new(
+        actual_nesting(name),
+        @file_path,
+        node.location,
+        constant_path.location,
+        comments,
+        @index.configuration.encoding,
+      )
 
       @owner_stack << entry
       @index.add(entry)
@@ -161,7 +169,12 @@ module RubyIndexer
 
         if existing_entries
           entry = T.must(existing_entries.first)
-          entry.update_singleton_information(node.location, expression.location, collect_comments(node))
+          entry.update_singleton_information(
+            node.location,
+            expression.location,
+            collect_comments(node),
+            @index.configuration.encoding,
+          )
         else
           entry = Entry::SingletonClass.new(
             real_nesting,
@@ -169,6 +182,7 @@ module RubyIndexer
             node.location,
             expression.location,
             collect_comments(node),
+            @index.configuration.encoding,
             nil,
           )
           @index.add(entry, skip_prefix_tree: true)
@@ -329,6 +343,7 @@ module RubyIndexer
           node.location,
           node.name_loc,
           comments,
+          @index.configuration.encoding,
           [Entry::Signature.new(list_params(node.parameters))],
           current_visibility,
           @owner_stack.last,
@@ -345,6 +360,7 @@ module RubyIndexer
             node.location,
             node.name_loc,
             comments,
+            @index.configuration.encoding,
             [Entry::Signature.new(list_params(node.parameters))],
             current_visibility,
             singleton,
@@ -403,6 +419,7 @@ module RubyIndexer
           @file_path,
           node.new_name.location,
           comments,
+          @index.configuration.encoding,
         ),
       )
     end
@@ -433,7 +450,14 @@ module RubyIndexer
         owner = @index.existing_or_new_singleton_class(owner.name)
       end
 
-      @index.add(Entry::InstanceVariable.new(name, @file_path, loc, collect_comments(node), owner))
+      @index.add(Entry::InstanceVariable.new(
+        name,
+        @file_path,
+        loc,
+        collect_comments(node),
+        @index.configuration.encoding,
+        owner,
+      ))
     end
 
     sig { params(node: Prism::CallNode).void }
@@ -496,6 +520,7 @@ module RubyIndexer
           @file_path,
           new_name.location,
           comments,
+          @index.configuration.encoding,
         ),
       )
     end
@@ -525,19 +550,43 @@ module RubyIndexer
       @index.add(
         case value
         when Prism::ConstantReadNode, Prism::ConstantPathNode
-          Entry::UnresolvedConstantAlias.new(value.slice, @stack.dup, name, @file_path, node.location, comments)
+          Entry::UnresolvedConstantAlias.new(
+            value.slice,
+            @stack.dup,
+            name,
+            @file_path,
+            node.location,
+            comments,
+            @index.configuration.encoding,
+          )
         when Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode,
         Prism::ConstantOperatorWriteNode
 
           # If the right hand side is another constant assignment, we need to visit it because that constant has to be
           # indexed too
-          Entry::UnresolvedConstantAlias.new(value.name.to_s, @stack.dup, name, @file_path, node.location, comments)
+          Entry::UnresolvedConstantAlias.new(
+            value.name.to_s,
+            @stack.dup,
+            name,
+            @file_path,
+            node.location,
+            comments,
+            @index.configuration.encoding,
+          )
         when Prism::ConstantPathWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode,
         Prism::ConstantPathAndWriteNode
 
-          Entry::UnresolvedConstantAlias.new(value.target.slice, @stack.dup, name, @file_path, node.location, comments)
+          Entry::UnresolvedConstantAlias.new(
+            value.target.slice,
+            @stack.dup,
+            name,
+            @file_path,
+            node.location,
+            comments,
+            @index.configuration.encoding,
+          )
         else
-          Entry::Constant.new(name, @file_path, node.location, comments)
+          Entry::Constant.new(name, @file_path, node.location, comments, @index.configuration.encoding)
         end,
       )
     end
@@ -600,7 +649,15 @@ module RubyIndexer
         next unless name && loc
 
         if reader
-          @index.add(Entry::Accessor.new(name, @file_path, loc, comments, current_visibility, @owner_stack.last))
+          @index.add(Entry::Accessor.new(
+            name,
+            @file_path,
+            loc,
+            comments,
+            @index.configuration.encoding,
+            current_visibility,
+            @owner_stack.last,
+          ))
         end
 
         next unless writer
@@ -610,6 +667,7 @@ module RubyIndexer
           @file_path,
           loc,
           comments,
+          @index.configuration.encoding,
           current_visibility,
           @owner_stack.last,
         ))

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

@@ -33,9 +33,10 @@ module RubyIndexer
         file_path: String,
         location: T.any(Prism::Location, RubyIndexer::Location),
         comments: T.nilable(String),
+        encoding: Encoding,
       ).void
     end
-    def initialize(name, file_path, location, comments)
+    def initialize(name, file_path, location, comments, encoding)
       @name = name
       @file_path = file_path
       @comments = comments
@@ -46,8 +47,8 @@ module RubyIndexer
           Location.new(
             location.start_line,
             location.end_line,
-            location.start_column,
-            location.end_column,
+            location.start_code_units_column(encoding),
+            location.end_code_units_column(encoding),
           )
         else
           location
@@ -150,22 +151,23 @@ module RubyIndexer
           location: T.any(Prism::Location, RubyIndexer::Location),
           name_location: T.any(Prism::Location, Location),
           comments: T.nilable(String),
+          encoding: Encoding,
         ).void
       end
-      def initialize(nesting, file_path, location, name_location, comments)
+      def initialize(nesting, file_path, location, name_location, comments, encoding) # rubocop:disable Metrics/ParameterLists
         @name = T.let(nesting.join("::"), String)
         # The original nesting where this namespace was discovered
         @nesting = nesting
 
-        super(@name, file_path, location, comments)
+        super(@name, file_path, location, comments, encoding)
 
         @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,
+              name_location.start_code_units_column(encoding),
+              name_location.end_code_units_column(encoding),
             )
           else
             name_location
@@ -211,11 +213,12 @@ module RubyIndexer
           location: T.any(Prism::Location, RubyIndexer::Location),
           name_location: T.any(Prism::Location, Location),
           comments: T.nilable(String),
+          encoding: Encoding,
           parent_class: T.nilable(String),
         ).void
       end
-      def initialize(nesting, file_path, location, name_location, comments, parent_class) # rubocop:disable Metrics/ParameterLists
-        super(nesting, file_path, location, name_location, comments)
+      def initialize(nesting, file_path, location, name_location, comments, encoding, parent_class) # rubocop:disable Metrics/ParameterLists
+        super(nesting, file_path, location, name_location, comments, encoding)
         @parent_class = parent_class
       end
 
@@ -228,20 +231,27 @@ module RubyIndexer
     class SingletonClass < Class
       extend T::Sig
 
-      sig { params(location: Prism::Location, name_location: Prism::Location, comments: T.nilable(String)).void }
-      def update_singleton_information(location, name_location, comments)
+      sig do
+        params(
+          location: Prism::Location,
+          name_location: Prism::Location,
+          comments: T.nilable(String),
+          encoding: Encoding,
+        ).void
+      end
+      def update_singleton_information(location, name_location, comments, encoding)
         # Create a new RubyIndexer::Location object from the Prism location
         @location = Location.new(
           location.start_line,
           location.end_line,
-          location.start_column,
-          location.end_column,
+          location.start_code_units_column(encoding),
+          location.end_code_units_column(encoding),
         )
         @name_location = Location.new(
           name_location.start_line,
           name_location.end_line,
-          name_location.start_column,
-          name_location.end_column,
+          name_location.start_code_units_column(encoding),
+          name_location.end_code_units_column(encoding),
         )
         (@comments ||= +"") << comments if comments
       end
@@ -361,12 +371,13 @@ module RubyIndexer
           file_path: String,
           location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T.nilable(String),
+          encoding: Encoding,
           visibility: Visibility,
           owner: T.nilable(Entry::Namespace),
         ).void
       end
-      def initialize(name, file_path, location, comments, visibility, owner) # rubocop:disable Metrics/ParameterLists
-        super(name, file_path, location, comments)
+      def initialize(name, file_path, location, comments, encoding, visibility, owner) # rubocop:disable Metrics/ParameterLists
+        super(name, file_path, location, comments, encoding)
         @visibility = visibility
         @owner = owner
       end
@@ -429,21 +440,22 @@ module RubyIndexer
           location: T.any(Prism::Location, RubyIndexer::Location),
           name_location: T.any(Prism::Location, Location),
           comments: T.nilable(String),
+          encoding: Encoding,
           signatures: T::Array[Signature],
           visibility: Visibility,
           owner: T.nilable(Entry::Namespace),
         ).void
       end
-      def initialize(name, file_path, location, name_location, comments, signatures, visibility, owner) # rubocop:disable Metrics/ParameterLists
-        super(name, file_path, location, comments, visibility, owner)
+      def initialize(name, file_path, location, name_location, comments, encoding, signatures, visibility, owner) # rubocop:disable Metrics/ParameterLists
+        super(name, file_path, location, comments, encoding, visibility, owner)
         @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,
+              name_location.start_code_units_column(encoding),
+              name_location.end_code_units_column(encoding),
             )
           else
             name_location
@@ -480,10 +492,11 @@ module RubyIndexer
           file_path: String,
           location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T.nilable(String),
+          encoding: Encoding,
         ).void
       end
-      def initialize(target, nesting, name, file_path, location, comments) # rubocop:disable Metrics/ParameterLists
-        super(name, file_path, location, comments)
+      def initialize(target, nesting, name, file_path, location, comments, encoding) # rubocop:disable Metrics/ParameterLists
+        super(name, file_path, location, comments, encoding)
 
         @target = target
         @nesting = nesting
@@ -497,9 +510,15 @@ module RubyIndexer
       sig { returns(String) }
       attr_reader :target
 
-      sig { params(target: String, unresolved_alias: UnresolvedConstantAlias).void }
-      def initialize(target, unresolved_alias)
-        super(unresolved_alias.name, unresolved_alias.file_path, unresolved_alias.location, unresolved_alias.comments)
+      sig { params(target: String, unresolved_alias: UnresolvedConstantAlias, encoding: Encoding).void }
+      def initialize(target, unresolved_alias, encoding)
+        super(
+          unresolved_alias.name,
+          unresolved_alias.file_path,
+          unresolved_alias.location,
+          unresolved_alias.comments,
+          encoding
+        )
 
         @visibility = unresolved_alias.visibility
         @target = target
@@ -517,11 +536,12 @@ module RubyIndexer
           file_path: String,
           location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T.nilable(String),
+          encoding: Encoding,
           owner: T.nilable(Entry::Namespace),
         ).void
       end
-      def initialize(name, file_path, location, comments, owner)
-        super(name, file_path, location, comments)
+      def initialize(name, file_path, location, comments, encoding, owner) # rubocop:disable Metrics/ParameterLists
+        super(name, file_path, location, comments, encoding)
         @owner = owner
       end
     end
@@ -546,10 +566,11 @@ module RubyIndexer
           file_path: String,
           location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T.nilable(String),
+          encoding: Encoding,
         ).void
       end
-      def initialize(new_name, old_name, owner, file_path, location, comments) # rubocop:disable Metrics/ParameterLists
-        super(new_name, file_path, location, comments)
+      def initialize(new_name, old_name, owner, file_path, location, comments, encoding) # rubocop:disable Metrics/ParameterLists
+        super(new_name, file_path, location, comments, encoding)
 
         @new_name = new_name
         @old_name = old_name
@@ -567,8 +588,10 @@ module RubyIndexer
       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)
+      sig do
+        params(target: T.any(Member, MethodAlias), unresolved_alias: UnresolvedMethodAlias, encoding: Encoding).void
+      end
+      def initialize(target, unresolved_alias, encoding)
         full_comments = +"Alias for #{target.name}\n"
         full_comments << "#{unresolved_alias.comments}\n"
         full_comments << target.comments
@@ -578,6 +601,7 @@ module RubyIndexer
           unresolved_alias.file_path,
           unresolved_alias.location,
           full_comments,
+          encoding
         )
 
         @target = target

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -665,6 +665,7 @@ module RubyIndexer
           attached_ancestor.location,
           attached_ancestor.name_location,
           nil,
+          @configuration.encoding,
           nil,
         )
         add(singleton, skip_prefix_tree: true)
@@ -856,7 +857,7 @@ module RubyIndexer
       return entry unless target
 
       target_name = T.must(target.first).name
-      resolved_alias = Entry::ConstantAlias.new(target_name, entry)
+      resolved_alias = Entry::ConstantAlias.new(target_name, entry, @configuration.encoding)
 
       # Replace the UnresolvedAlias by a resolved one so that we don't have to do this again later
       original_entries = T.must(@entries[alias_name])
@@ -1047,7 +1048,7 @@ module RubyIndexer
       target_method_entries = resolve_method(entry.old_name, receiver_name, seen_names)
       return entry unless target_method_entries
 
-      resolved_alias = Entry::MethodAlias.new(T.must(target_method_entries.first), entry)
+      resolved_alias = Entry::MethodAlias.new(T.must(target_method_entries.first), entry, @configuration.encoding)
       original_entries = T.must(@entries[new_name])
       original_entries.delete(entry)
       original_entries << resolved_alias

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

@@ -5,6 +5,8 @@ module RubyIndexer
   class RBSIndexer
     extend T::Sig
 
+    HAS_UNTYPED_FUNCTION = T.let(!!defined?(RBS::Types::UntypedFunction), T::Boolean)
+
     sig { params(index: Index).void }
     def initialize(index)
       @index = index
@@ -57,9 +59,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, file_path, location, location, comments, parent_class)
+        Entry::Class.new(nesting, file_path, location, location, comments, @index.configuration.encoding, parent_class)
       else
-        Entry::Module.new(nesting, file_path, location, location, comments)
+        Entry::Module.new(nesting, file_path, location, location, comments, @index.configuration.encoding)
       end
       add_declaration_mixins_to_entry(declaration, entry)
       @index.add(entry)
@@ -126,7 +128,17 @@ module RubyIndexer
 
       real_owner = member.singleton? ? @index.existing_or_new_singleton_class(owner.name) : owner
       signatures = signatures(member)
-      @index.add(Entry::Method.new(name, file_path, location, location, comments, signatures, visibility, real_owner))
+      @index.add(Entry::Method.new(
+        name,
+        file_path,
+        location,
+        location,
+        comments,
+        @index.configuration.encoding,
+        signatures,
+        visibility,
+        real_owner,
+      ))
     end
 
     sig { params(member: RBS::AST::Members::MethodDefinition).returns(T::Array[Entry::Signature]) }
@@ -139,13 +151,23 @@ module RubyIndexer
 
     sig { params(overload: RBS::AST::Members::MethodDefinition::Overload).returns(T::Array[Entry::Parameter]) }
     def process_overload(overload)
-      function = T.cast(overload.method_type.type, RBS::Types::Function)
-      parameters = parse_arguments(function)
+      function = overload.method_type.type
 
-      block = overload.method_type.block
-      parameters << Entry::BlockParameter.anonymous if block&.required
+      if function.is_a?(RBS::Types::Function)
+        parameters = parse_arguments(function)
 
-      parameters
+        block = overload.method_type.block
+        parameters << Entry::BlockParameter.anonymous if block&.required
+        return parameters
+      end
+
+      # Untyped functions are a new RBS feature (since v3.6.0) to declare methods that accept any parameters. For our
+      # purposes, accepting any argument is equivalent to `...`
+      if HAS_UNTYPED_FUNCTION && function.is_a?(RBS::Types::UntypedFunction)
+        [Entry::ForwardingParameter.new]
+      else
+        []
+      end
     end
 
     sig { params(function: RBS::Types::Function).returns(T::Array[Entry::Parameter]) }
@@ -245,6 +267,7 @@ module RubyIndexer
         file_path,
         to_ruby_indexer_location(declaration.location),
         comments_to_string(declaration),
+        @index.configuration.encoding,
       ))
     end
 
@@ -260,6 +283,7 @@ module RubyIndexer
         file_path,
         to_ruby_indexer_location(member.location),
         comments,
+        @index.configuration.encoding,
       )
 
       @index.add(entry)