ruby-lsp 0.19.1 → 0.20.1

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

@@ -31,30 +31,16 @@ module RubyIndexer
       params(
         name: String,
         file_path: String,
-        location: T.any(Prism::Location, RubyIndexer::Location),
+        location: Location,
         comments: T.nilable(String),
-        encoding: Encoding,
       ).void
     end
-    def initialize(name, file_path, location, comments, encoding)
+    def initialize(name, file_path, location, comments)
       @name = name
       @file_path = file_path
       @comments = comments
       @visibility = T.let(Visibility::PUBLIC, Visibility)
-
-      @location = T.let(
-        if location.is_a?(Prism::Location)
-          Location.new(
-            location.start_line,
-            location.end_line,
-            location.start_code_units_column(encoding),
-            location.end_code_units_column(encoding),
-          )
-        else
-          location
-        end,
-        RubyIndexer::Location,
-      )
+      @location = location
     end
 
     sig { returns(T::Boolean) }
@@ -152,32 +138,19 @@ module RubyIndexer
         params(
           nesting: T::Array[String],
           file_path: String,
-          location: T.any(Prism::Location, RubyIndexer::Location),
-          name_location: T.any(Prism::Location, Location),
+          location: Location,
+          name_location: Location,
           comments: T.nilable(String),
-          encoding: Encoding,
         ).void
       end
-      def initialize(nesting, file_path, location, name_location, comments, encoding) # rubocop:disable Metrics/ParameterLists
+      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, 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_code_units_column(encoding),
-              name_location.end_code_units_column(encoding),
-            )
-          else
-            name_location
-          end,
-          RubyIndexer::Location,
-        )
+        super(@name, file_path, location, comments)
+
+        @name_location = name_location
       end
 
       sig { returns(T::Array[String]) }
@@ -214,15 +187,14 @@ module RubyIndexer
         params(
           nesting: T::Array[String],
           file_path: String,
-          location: T.any(Prism::Location, RubyIndexer::Location),
-          name_location: T.any(Prism::Location, Location),
+          location: Location,
+          name_location:  Location,
           comments: T.nilable(String),
-          encoding: Encoding,
           parent_class: T.nilable(String),
         ).void
       end
-      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)
+      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
 
@@ -237,26 +209,14 @@ module RubyIndexer
 
       sig do
         params(
-          location: Prism::Location,
-          name_location: Prism::Location,
+          location: Location,
+          name_location: 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_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_code_units_column(encoding),
-          name_location.end_code_units_column(encoding),
-        )
+      def update_singleton_information(location, name_location, comments)
+        @location = location
+        @name_location = name_location
         (@comments ||= +"") << comments if comments
       end
     end
@@ -373,15 +333,14 @@ module RubyIndexer
         params(
           name: String,
           file_path: String,
-          location: T.any(Prism::Location, RubyIndexer::Location),
+          location: Location,
           comments: T.nilable(String),
-          encoding: Encoding,
           visibility: Visibility,
           owner: T.nilable(Entry::Namespace),
         ).void
       end
-      def initialize(name, file_path, location, comments, encoding, visibility, owner) # rubocop:disable Metrics/ParameterLists
-        super(name, file_path, location, comments, encoding)
+      def initialize(name, file_path, location, comments, visibility, owner) # rubocop:disable Metrics/ParameterLists
+        super(name, file_path, location, comments)
         @visibility = visibility
         @owner = owner
       end
@@ -441,31 +400,18 @@ module RubyIndexer
         params(
           name: String,
           file_path: String,
-          location: T.any(Prism::Location, RubyIndexer::Location),
-          name_location: T.any(Prism::Location, Location),
+          location: Location,
+          name_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, encoding, signatures, visibility, owner) # rubocop:disable Metrics/ParameterLists
-        super(name, file_path, location, comments, encoding, visibility, owner)
+      def initialize(name, file_path, location, name_location, comments, signatures, visibility, owner) # rubocop:disable Metrics/ParameterLists
+        super(name, file_path, location, comments, 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_code_units_column(encoding),
-              name_location.end_code_units_column(encoding),
-            )
-          else
-            name_location
-          end,
-          RubyIndexer::Location,
-        )
+        @name_location = name_location
       end
     end
 
@@ -494,13 +440,12 @@ module RubyIndexer
           nesting: T::Array[String],
           name: String,
           file_path: String,
-          location: T.any(Prism::Location, RubyIndexer::Location),
+          location: Location,
           comments: T.nilable(String),
-          encoding: Encoding,
         ).void
       end
-      def initialize(target, nesting, name, file_path, location, comments, encoding) # rubocop:disable Metrics/ParameterLists
-        super(name, file_path, location, comments, encoding)
+      def initialize(target, nesting, name, file_path, location, comments) # rubocop:disable Metrics/ParameterLists
+        super(name, file_path, location, comments)
 
         @target = target
         @nesting = nesting
@@ -514,14 +459,13 @@ module RubyIndexer
       sig { returns(String) }
       attr_reader :target
 
-      sig { params(target: String, unresolved_alias: UnresolvedConstantAlias, encoding: Encoding).void }
-      def initialize(target, unresolved_alias, encoding)
+      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,
-          encoding
         )
 
         @visibility = unresolved_alias.visibility
@@ -541,14 +485,13 @@ module RubyIndexer
         params(
           name: String,
           file_path: String,
-          location: T.any(Prism::Location, RubyIndexer::Location),
+          location: Location,
           comments: T.nilable(String),
-          encoding: Encoding,
           owner: T.nilable(Entry::Namespace),
         ).void
       end
-      def initialize(name, file_path, location, comments, encoding, owner) # rubocop:disable Metrics/ParameterLists
-        super(name, file_path, location, comments, encoding)
+      def initialize(name, file_path, location, comments, owner)
+        super(name, file_path, location, comments)
         @owner = owner
       end
     end
@@ -571,13 +514,12 @@ module RubyIndexer
           old_name: String,
           owner: T.nilable(Entry::Namespace),
           file_path: String,
-          location: T.any(Prism::Location, RubyIndexer::Location),
+          location: Location,
           comments: T.nilable(String),
-          encoding: Encoding,
         ).void
       end
-      def initialize(new_name, old_name, owner, file_path, location, comments, encoding) # rubocop:disable Metrics/ParameterLists
-        super(new_name, file_path, location, comments, encoding)
+      def initialize(new_name, old_name, owner, file_path, location, comments) # rubocop:disable Metrics/ParameterLists
+        super(new_name, file_path, location, comments)
 
         @new_name = new_name
         @old_name = old_name
@@ -596,9 +538,9 @@ module RubyIndexer
       attr_reader :owner
 
       sig do
-        params(target: T.any(Member, MethodAlias), unresolved_alias: UnresolvedMethodAlias, encoding: Encoding).void
+        params(target: T.any(Member, MethodAlias), unresolved_alias: UnresolvedMethodAlias).void
       end
-      def initialize(target, unresolved_alias, encoding)
+      def initialize(target, unresolved_alias)
         full_comments = +"Alias for #{target.name}\n"
         full_comments << "#{unresolved_alias.comments}\n"
         full_comments << target.comments
@@ -608,7 +550,6 @@ module RubyIndexer
           unresolved_alias.file_path,
           unresolved_alias.location,
           full_comments,
-          encoding
         )
 
         @target = target

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

@@ -665,7 +665,6 @@ module RubyIndexer
           attached_ancestor.location,
           attached_ancestor.name_location,
           nil,
-          @configuration.encoding,
           nil,
         )
         add(singleton, skip_prefix_tree: true)
@@ -859,7 +858,7 @@ module RubyIndexer
       return entry unless target
 
       target_name = T.must(target.first).name
-      resolved_alias = Entry::ConstantAlias.new(target_name, entry, @configuration.encoding)
+      resolved_alias = Entry::ConstantAlias.new(target_name, entry)
 
       # 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])
@@ -981,29 +980,23 @@ module RubyIndexer
     # nesting
     sig { params(name: String, nesting: T::Array[String]).returns(String) }
     def build_non_redundant_full_name(name, nesting)
+      # If there's no nesting, then we can just return the name as is
       return name if nesting.empty?
 
-      namespace = nesting.join("::")
-
       # If the name is not qualified, we can just concatenate the nesting and the name
-      return "#{namespace}::#{name}" unless name.include?("::")
+      return "#{nesting.join("::")}::#{name}" unless name.include?("::")
 
       name_parts = name.split("::")
+      first_redundant_part = nesting.index(name_parts[0])
 
-      # Find the first part of the name that is not in the nesting
-      index = name_parts.index { |part| !nesting.include?(part) }
+      # If there are no redundant parts between the name and the nesting, then the full name is both combined
+      return "#{nesting.join("::")}::#{name}" unless first_redundant_part
 
-      if index.nil?
-        # All parts of the nesting are redundant because they are already present in the name. We can return the name
-        # directly
-        name
-      elsif index == 0
-        # No parts of the nesting are in the name, we can concatenate the namespace and the name
-        "#{namespace}::#{name}"
-      else
-        # The name includes some parts of the nesting. We need to remove the redundant parts
-        "#{namespace}::#{T.must(name_parts[index..-1]).join("::")}"
-      end
+      # Otherwise, push all of the leading parts of the nesting that aren't redundant into the name. For example, if we
+      # have a reference to `Foo::Bar` inside the `[Namespace, Foo]` nesting, then only the `Foo` part is redundant, but
+      # we still need to include the `Namespace` part
+      T.unsafe(name_parts).unshift(*nesting[0...first_redundant_part])
+      name_parts.join("::")
     end
 
     sig do
@@ -1050,7 +1043,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, @configuration.encoding)
+      resolved_alias = Entry::MethodAlias.new(T.must(target_method_entries.first), entry)
       original_entries = T.must(@entries[new_name])
       original_entries.delete(entry)
       original_entries << resolved_alias

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

@@ -5,6 +5,28 @@ 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
+      def from_prism_location(prism_location, code_units_cache)
+        new(
+          prism_location.start_line,
+          prism_location.end_line,
+          prism_location.cached_start_code_units_column(code_units_cache),
+          prism_location.cached_end_code_units_column(code_units_cache),
+        )
+      end
+    end
+
     sig { returns(Integer) }
     attr_reader :start_line, :end_line, :start_column, :end_column
 

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

@@ -61,9 +61,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, @index.configuration.encoding, parent_class)
+        Entry::Class.new(nesting, file_path, location, location, comments, parent_class)
       else
-        Entry::Module.new(nesting, file_path, location, location, comments, @index.configuration.encoding)
+        Entry::Module.new(nesting, file_path, location, location, comments)
       end
       add_declaration_mixins_to_entry(declaration, entry)
       @index.add(entry)
@@ -136,7 +136,6 @@ module RubyIndexer
         location,
         location,
         comments,
-        @index.configuration.encoding,
         signatures,
         visibility,
         real_owner,
@@ -269,7 +268,6 @@ module RubyIndexer
         file_path,
         to_ruby_indexer_location(declaration.location),
         comments_to_string(declaration),
-        @index.configuration.encoding,
       ))
     end
 
@@ -279,14 +277,12 @@ module RubyIndexer
       file_path = pathname.to_s
       location = to_ruby_indexer_location(declaration.location)
       comments = comments_to_string(declaration)
-      encoding = @index.configuration.encoding
 
       @index.add(Entry::GlobalVariable.new(
         name,
         file_path,
         location,
         comments,
-        encoding,
       ))
     end
 
@@ -302,7 +298,6 @@ module RubyIndexer
         file_path,
         to_ruby_indexer_location(member.location),
         comments,
-        @index.configuration.encoding,
       )
 
       @index.add(entry)

data/lib/ruby_indexer/test/enhancements_test.rb

@@ -9,14 +9,14 @@ module RubyIndexer
       enhancement_class = Class.new do
         include Enhancement
 
-        def on_call_node(index, owner, node, file_path)
+        def on_call_node(index, owner, node, file_path, code_units_cache)
           return unless owner
           return unless node.name == :extend
 
           arguments = node.arguments&.arguments
           return unless arguments
 
-          location = node.location
+          location = Location.from_prism_location(node.location, code_units_cache)
 
           arguments.each do |node|
             next unless node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
@@ -39,7 +39,6 @@ module RubyIndexer
               location,
               location,
               nil,
-              index.configuration.encoding,
               [Entry::Signature.new([Entry::RequiredParameter.new(name: :a)])],
               Entry::Visibility::PUBLIC,
               owner,
@@ -102,7 +101,7 @@ module RubyIndexer
       enhancement_class = Class.new do
         include Enhancement
 
-        def on_call_node(index, owner, node, file_path)
+        def on_call_node(index, owner, node, file_path, code_units_cache)
           return unless owner
 
           name = node.name
@@ -114,7 +113,7 @@ module RubyIndexer
           association_name = arguments.first
           return unless association_name.is_a?(Prism::SymbolNode)
 
-          location = association_name.location
+          location = Location.from_prism_location(association_name.location, code_units_cache)
 
           index.add(Entry::Method.new(
             T.must(association_name.value),
@@ -122,7 +121,6 @@ module RubyIndexer
             location,
             location,
             nil,
-            index.configuration.encoding,
             [],
             Entry::Visibility::PUBLIC,
             owner,
@@ -166,7 +164,7 @@ module RubyIndexer
       enhancement_class = Class.new do
         include Enhancement
 
-        def on_call_node(index, owner, node, file_path)
+        def on_call_node(index, owner, node, file_path, code_units_cache)
           raise "Error"
         end
 

data/lib/ruby_indexer/test/global_variable_test.rb

@@ -0,0 +1,49 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "test_case"
+
+module RubyIndexer
+  class GlobalVariableTest < TestCase
+    def test_global_variable_and_write
+      index(<<~RUBY)
+        $foo &&= 1
+      RUBY
+
+      assert_entry("$foo", Entry::GlobalVariable, "/fake/path/foo.rb:0-0:0-4")
+    end
+
+    def test_global_variable_operator_write
+      index(<<~RUBY)
+        $foo += 1
+      RUBY
+
+      assert_entry("$foo", Entry::GlobalVariable, "/fake/path/foo.rb:0-0:0-4")
+    end
+
+    def test_global_variable_or_write
+      index(<<~RUBY)
+        $foo ||= 1
+      RUBY
+
+      assert_entry("$foo", Entry::GlobalVariable, "/fake/path/foo.rb:0-0:0-4")
+    end
+
+    def test_global_variable_target_node
+      index(<<~RUBY)
+        $foo, $bar = 1
+      RUBY
+
+      assert_entry("$foo", Entry::GlobalVariable, "/fake/path/foo.rb:0-0:0-4")
+      assert_entry("$bar", Entry::GlobalVariable, "/fake/path/foo.rb:0-6:0-10")
+    end
+
+    def test_global_variable_write
+      index(<<~RUBY)
+        $foo = 1
+      RUBY
+
+      assert_entry("$foo", Entry::GlobalVariable, "/fake/path/foo.rb:0-0:0-4")
+    end
+  end
+end

data/lib/ruby_indexer/test/index_test.rb

@@ -1934,5 +1934,94 @@ module RubyIndexer
       real_namespace = @index.follow_aliased_namespace("Namespace::Second")
       assert_equal("First::Second", real_namespace)
     end
+
+    def test_resolving_alias_to_non_existing_namespace
+      index(<<~RUBY)
+        module Namespace
+          class Foo
+            module InnerNamespace
+              Constants = Namespace::Foo::Constants
+            end
+          end
+        end
+      RUBY
+
+      entry = @index.resolve("Constants", ["Namespace", "Foo", "InnerNamespace"])&.first
+      assert_instance_of(Entry::UnresolvedConstantAlias, entry)
+
+      entry = @index.resolve("Namespace::Foo::Constants", ["Namespace", "Foo", "InnerNamespace"])&.first
+      assert_nil(entry)
+    end
+
+    def test_resolving_alias_to_existing_constant_from_inner_namespace
+      index(<<~RUBY)
+        module Parent
+          CONST = 123
+        end
+
+        module First
+          module Namespace
+            class Foo
+              include Parent
+
+              module InnerNamespace
+                Constants = Namespace::Foo::CONST
+              end
+            end
+          end
+        end
+      RUBY
+
+      entry = @index.resolve("Namespace::Foo::CONST", ["First", "Namespace", "Foo", "InnerNamespace"])&.first
+      assert_equal("Parent::CONST", entry.name)
+      assert_instance_of(Entry::Constant, entry)
+    end
+
+    def test_build_non_redundant_name
+      assert_equal(
+        "Namespace::Foo::Constants",
+        @index.send(
+          :build_non_redundant_full_name,
+          "Namespace::Foo::Constants",
+          ["Namespace", "Foo", "InnerNamespace"],
+        ),
+      )
+
+      assert_equal(
+        "Namespace::Foo::Constants",
+        @index.send(
+          :build_non_redundant_full_name,
+          "Namespace::Foo::Constants",
+          ["Namespace", "Foo"],
+        ),
+      )
+
+      assert_equal(
+        "Namespace::Foo::Constants",
+        @index.send(
+          :build_non_redundant_full_name,
+          "Foo::Constants",
+          ["Namespace", "Foo"],
+        ),
+      )
+
+      assert_equal(
+        "Bar::Namespace::Foo::Constants",
+        @index.send(
+          :build_non_redundant_full_name,
+          "Namespace::Foo::Constants",
+          ["Bar"],
+        ),
+      )
+
+      assert_equal(
+        "First::Namespace::Foo::Constants",
+        @index.send(
+          :build_non_redundant_full_name,
+          "Namespace::Foo::Constants",
+          ["First", "Namespace", "Foo", "InnerNamespace"],
+        ),
+      )
+    end
   end
 end

data/lib/ruby_lsp/erb_document.rb

@@ -6,10 +6,18 @@ module RubyLsp
     extend T::Sig
     extend T::Generic
 
+    ParseResultType = type_member { { fixed: Prism::ParseResult } }
+
     sig { returns(String) }
     attr_reader :host_language_source
 
-    ParseResultType = type_member { { fixed: Prism::ParseResult } }
+    sig do
+      returns(T.any(
+        T.proc.params(arg0: Integer).returns(Integer),
+        Prism::CodeUnitsCache,
+      ))
+    end
+    attr_reader :code_units_cache
 
     sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
     def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
@@ -17,6 +25,10 @@ module RubyLsp
       # overrides this with the proper virtual host language source
       @host_language_source = T.let("", String)
       super
+      @code_units_cache = T.let(@parse_result.code_units_cache(@encoding), T.any(
+        T.proc.params(arg0: Integer).returns(Integer),
+        Prism::CodeUnitsCache,
+      ))
     end
 
     sig { override.returns(T::Boolean) }
@@ -30,6 +42,7 @@ module RubyLsp
       # Use partial script to avoid syntax errors in ERB files where keywords may be used without the full context in
       # which they will be evaluated
       @parse_result = Prism.parse(scanner.ruby, partial_script: true)
+      @code_units_cache = @parse_result.code_units_cache(@encoding)
       true
     end
 
@@ -53,8 +66,8 @@ module RubyLsp
       RubyDocument.locate(
         @parse_result.value,
         create_scanner.find_char_position(position),
+        code_units_cache: @code_units_cache,
         node_types: node_types,
-        encoding: @encoding,
       )
     end