ruby-lsp 0.23.15 → 0.26.9

data/lib/ruby_indexer/test/configuration_test.rb

@@ -1,280 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "test_helper"
-
-module RubyIndexer
-  class ConfigurationTest < Minitest::Test
-    def setup
-      @config = Configuration.new
-      @workspace_path = File.expand_path(File.join("..", "..", ".."), __dir__)
-      @config.workspace_path = @workspace_path
-    end
-
-    def test_load_configuration_executes_configure_block
-      @config.apply_config({ "excluded_patterns" => ["**/fixtures/**/*"] })
-      uris = @config.indexable_uris
-
-      bundle_path = Bundler.bundle_path.join("gems")
-
-      assert(uris.none? { |uri| uri.full_path.include?("test/fixtures") })
-      assert(uris.none? { |uri| uri.full_path.include?(bundle_path.join("minitest-reporters").to_s) })
-      assert(uris.none? { |uri| uri.full_path.include?(bundle_path.join("ansi").to_s) })
-      assert(uris.any? { |uri| uri.full_path.include?(bundle_path.join("sorbet-runtime").to_s) })
-      assert(uris.none? { |uri| uri.full_path == __FILE__ })
-    end
-
-    def test_indexable_uris_have_expanded_full_paths
-      @config.apply_config({ "included_patterns" => ["**/*.rb"] })
-      uris = @config.indexable_uris
-
-      # All paths should be expanded
-      assert(uris.all? { |uri| File.absolute_path?(uri.full_path) })
-    end
-
-    def test_indexable_uris_only_includes_gem_require_paths
-      uris = @config.indexable_uris
-
-      Bundler.locked_gems.specs.each do |lazy_spec|
-        next if lazy_spec.name == "ruby-lsp"
-
-        spec = Gem::Specification.find_by_name(lazy_spec.name)
-
-        test_uris = uris.select do |uri|
-          File.fnmatch?(File.join(spec.full_gem_path, "test/**/*"), uri.full_path, File::Constants::FNM_PATHNAME)
-        end
-        assert_empty(test_uris)
-      rescue Gem::MissingSpecError
-        # Transitive dependencies might be missing when running tests on Windows
-      end
-    end
-
-    def test_indexable_uris_does_not_include_default_gem_path_when_in_bundle
-      uris = @config.indexable_uris
-      assert(uris.none? { |uri| uri.full_path.start_with?("#{RbConfig::CONFIG["rubylibdir"]}/psych") })
-    end
-
-    def test_indexable_uris_includes_default_gems
-      paths = @config.indexable_uris.map(&:full_path)
-
-      assert_includes(paths, "#{RbConfig::CONFIG["rubylibdir"]}/pathname.rb")
-      assert_includes(paths, "#{RbConfig::CONFIG["rubylibdir"]}/ipaddr.rb")
-      assert_includes(paths, "#{RbConfig::CONFIG["rubylibdir"]}/erb.rb")
-    end
-
-    def test_indexable_uris_includes_project_files
-      paths = @config.indexable_uris.map(&:full_path)
-
-      Dir.glob("#{Dir.pwd}/lib/**/*.rb").each do |path|
-        next if path.end_with?("_test.rb")
-
-        assert_includes(paths, path)
-      end
-    end
-
-    def test_indexable_uris_avoids_duplicates_if_bundle_path_is_inside_project
-      Bundler.settings.temporary(path: "vendor/bundle") do
-        config = Configuration.new
-
-        assert_includes(config.instance_variable_get(:@excluded_patterns), "vendor/bundle/**/*.rb")
-      end
-    end
-
-    def test_indexable_uris_does_not_include_gems_own_installed_files
-      uris = @config.indexable_uris
-      uris_inside_bundled_lsp = uris.select do |uri|
-        uri.full_path.start_with?(Bundler.bundle_path.join("gems", "ruby-lsp").to_s)
-      end
-
-      assert_empty(
-        uris_inside_bundled_lsp,
-        "Indexable URIs should not include files from the gem currently being worked on. " \
-          "Included: #{uris_inside_bundled_lsp.map(&:full_path)}",
-      )
-    end
-
-    def test_indexable_uris_does_not_include_non_ruby_files_inside_rubylibdir
-      path = Pathname.new(RbConfig::CONFIG["rubylibdir"]).join("extra_file.txt").to_s
-      FileUtils.touch(path)
-
-      begin
-        uris = @config.indexable_uris
-        assert(uris.none? { |uri| uri.full_path == path })
-      ensure
-        FileUtils.rm(path)
-      end
-    end
-
-    def test_paths_are_unique
-      uris = @config.indexable_uris
-      assert_equal(uris.uniq.length, uris.length)
-    end
-
-    def test_configuration_raises_for_unknown_keys
-      assert_raises(ArgumentError) do
-        @config.apply_config({ "unknown_config" => 123 })
-      end
-    end
-
-    def test_magic_comments_regex
-      regex = @config.magic_comment_regex
-
-      [
-        "# frozen_string_literal:",
-        "# typed:",
-        "# compiled:",
-        "# encoding:",
-        "# shareable_constant_value:",
-        "# warn_indent:",
-        "# rubocop:",
-        "# nodoc:",
-        "# doc:",
-        "# coding:",
-        "# warn_past_scope:",
-      ].each do |comment|
-        assert_match(regex, comment)
-      end
-    end
-
-    def test_indexable_uris_respect_given_workspace_path
-      Dir.mktmpdir do |dir|
-        FileUtils.mkdir(File.join(dir, "ignore"))
-        FileUtils.touch(File.join(dir, "ignore", "file0.rb"))
-        FileUtils.touch(File.join(dir, "file1.rb"))
-        FileUtils.touch(File.join(dir, "file2.rb"))
-
-        @config.apply_config({ "excluded_patterns" => ["ignore/**/*.rb"] })
-        @config.workspace_path = dir
-
-        uris = @config.indexable_uris
-        assert(uris.none? { |uri| uri.full_path.start_with?(File.join(dir, "ignore")) })
-
-        # The regular default gem path is ~/.rubies/3.4.1/lib/ruby/3.4.0
-        # The alternative default gem path is ~/.rubies/3.4.1/lib/ruby/gems/3.4.0
-        # Here part_1 contains ~/.rubies/3.4.1/lib/ruby/ and part_2 contains 3.4.0, so that we can turn it into the
-        # alternative path
-        part_1, part_2 = Pathname.new(RbConfig::CONFIG["rubylibdir"]).split
-        other_default_gem_dir = part_1.join("gems").join(part_2).to_s
-
-        # After switching the workspace path, all indexable URIs will be found in one of these places:
-        # - The new workspace path
-        # - The Ruby LSP's own code (because Bundler is requiring the dependency from source)
-        # - Bundled gems
-        # - Default gems
-        # - Other default gem directory
-        assert(
-          uris.all? do |u|
-            u.full_path.start_with?(dir) ||
-            u.full_path.start_with?(File.join(Dir.pwd, "lib")) ||
-            u.full_path.start_with?(Bundler.bundle_path.to_s) ||
-            u.full_path.start_with?(RbConfig::CONFIG["rubylibdir"]) ||
-            u.full_path.start_with?(other_default_gem_dir)
-          end,
-        )
-      end
-    end
-
-    def test_includes_top_level_files
-      Dir.mktmpdir do |dir|
-        FileUtils.touch(File.join(dir, "find_me.rb"))
-        @config.workspace_path = dir
-
-        uris = @config.indexable_uris
-        assert(uris.find { |u| File.basename(u.full_path) == "find_me.rb" })
-      end
-    end
-
-    def test_transitive_dependencies_for_non_dev_gems_are_not_excluded
-      Dir.mktmpdir do |dir|
-        Dir.chdir(dir) do
-          # Both IRB and debug depend on reline. Since IRB is in the default group, reline should not be excluded
-          File.write(File.join(dir, "Gemfile"), <<~RUBY)
-            source "https://rubygems.org"
-            gem "irb"
-            gem "ruby-lsp", path: "#{Bundler.root}"
-
-            group :development do
-              gem "debug"
-            end
-          RUBY
-
-          Bundler.with_unbundled_env do
-            capture_subprocess_io do
-              system("bundle install")
-            end
-
-            stdout, _stderr = capture_subprocess_io do
-              script = [
-                "require \"ruby_lsp/internal\"",
-                "print RubyIndexer::Configuration.new.instance_variable_get(:@excluded_gems).join(\",\")",
-              ].join(";")
-              system("bundle exec ruby -e '#{script}'")
-            end
-
-            excluded_gems = stdout.split(",")
-            assert_includes(excluded_gems, "debug")
-            refute_includes(excluded_gems, "reline")
-            refute_includes(excluded_gems, "irb")
-          end
-        end
-      end
-    end
-
-    def test_does_not_fail_if_there_are_missing_specs_due_to_platform_constraints
-      Dir.mktmpdir do |dir|
-        Dir.chdir(dir) do
-          File.write(File.join(dir, "Gemfile"), <<~RUBY)
-            source "https://rubygems.org"
-            gem "ruby-lsp", path: "#{Bundler.root}"
-
-            platforms :windows do
-              gem "tzinfo"
-              gem "tzinfo-data"
-            end
-          RUBY
-
-          Bundler.with_unbundled_env do
-            capture_subprocess_io { system("bundle install") }
-
-            _stdout, stderr = capture_subprocess_io do
-              script = [
-                "require \"ruby_lsp/internal\"",
-                "RubyIndexer::Configuration.new.indexable_uris",
-              ].join(";")
-
-              system("bundle exec ruby -e '#{script}'")
-            end
-
-            assert_empty(stderr)
-          end
-        end
-      end
-    end
-
-    def test_indexables_include_non_test_files_in_test_directories
-      # In order to linearize test parent classes and accurately detect the framework being used, then intermediate
-      # parent classes _must_ also be indexed. Otherwise, we have no way of linearizing the rest of the ancestors to
-      # determine what the test class ultimately inherits from.
-      #
-      # Therefore, we need to ensure that test files are excluded, but non test files inside test directories have to be
-      # indexed
-      FileUtils.touch("test/test_case.rb")
-
-      uris = @config.indexable_uris
-      project_paths = uris.filter_map do |uri|
-        path = uri.full_path
-        next if path.start_with?(Bundler.bundle_path.to_s) || path.start_with?(RbConfig::CONFIG["rubylibdir"])
-
-        Pathname.new(path).relative_path_from(Dir.pwd).to_s
-      end
-
-      begin
-        assert_includes(project_paths, "test/requests/support/expectations_test_runner.rb")
-        assert_includes(project_paths, "test/test_helper.rb")
-        assert_includes(project_paths, "test/test_case.rb")
-      ensure
-        FileUtils.rm("test/test_case.rb")
-      end
-    end
-  end
-end

data/lib/ruby_indexer/test/constant_test.rb

@@ -1,402 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require_relative "test_case"
-
-module RubyIndexer
-  class ConstantTest < TestCase
-    def test_constant_writes
-      index(<<~RUBY)
-        FOO = 1
-
-        class ::Bar
-          FOO = 2
-        end
-
-        BAR = 3 if condition
-      RUBY
-
-      assert_entry("FOO", Entry::Constant, "/fake/path/foo.rb:0-0:0-7")
-      assert_entry("Bar::FOO", Entry::Constant, "/fake/path/foo.rb:3-2:3-9")
-      assert_entry("BAR", Entry::Constant, "/fake/path/foo.rb:6-0:6-7")
-    end
-
-    def test_constant_with_multibyte_characters
-      index(<<~RUBY)
-        CONST_💎 = "Ruby"
-      RUBY
-
-      assert_entry("CONST_💎", Entry::Constant, "/fake/path/foo.rb:0-0:0-16")
-    end
-
-    def test_constant_or_writes
-      index(<<~RUBY)
-        FOO ||= 1
-
-        class ::Bar
-          FOO ||= 2
-        end
-      RUBY
-
-      assert_entry("FOO", Entry::Constant, "/fake/path/foo.rb:0-0:0-9")
-      assert_entry("Bar::FOO", Entry::Constant, "/fake/path/foo.rb:3-2:3-11")
-    end
-
-    def test_constant_path_writes
-      index(<<~RUBY)
-        class A
-          FOO = 1
-          ::BAR = 1
-
-          module B
-            FOO = 1
-          end
-        end
-
-        A::BAZ = 1
-      RUBY
-
-      assert_entry("A::FOO", Entry::Constant, "/fake/path/foo.rb:1-2:1-9")
-      assert_entry("BAR", Entry::Constant, "/fake/path/foo.rb:2-2:2-11")
-      assert_entry("A::B::FOO", Entry::Constant, "/fake/path/foo.rb:5-4:5-11")
-      assert_entry("A::BAZ", Entry::Constant, "/fake/path/foo.rb:9-0:9-10")
-    end
-
-    def test_constant_path_or_writes
-      index(<<~RUBY)
-        class A
-          FOO ||= 1
-          ::BAR ||= 1
-        end
-
-        A::BAZ ||= 1
-      RUBY
-
-      assert_entry("A::FOO", Entry::Constant, "/fake/path/foo.rb:1-2:1-11")
-      assert_entry("BAR", Entry::Constant, "/fake/path/foo.rb:2-2:2-13")
-      assert_entry("A::BAZ", Entry::Constant, "/fake/path/foo.rb:5-0:5-12")
-    end
-
-    def test_comments_for_constants
-      index(<<~RUBY)
-        # FOO comment
-        FOO = 1
-
-        class A
-          # A::FOO comment
-          FOO = 1
-
-          # ::BAR comment
-          ::BAR = 1
-        end
-
-        # A::BAZ comment
-        A::BAZ = 1
-      RUBY
-
-      foo = @index["FOO"]&.first #: as !nil
-      assert_equal("FOO comment", foo.comments)
-
-      a_foo = @index["A::FOO"]&.first #: as !nil
-      assert_equal("A::FOO comment", a_foo.comments)
-
-      bar = @index["BAR"]&.first #: as !nil
-      assert_equal("::BAR comment", bar.comments)
-
-      a_baz = @index["A::BAZ"]&.first #: as !nil
-      assert_equal("A::BAZ comment", a_baz.comments)
-    end
-
-    def test_variable_path_constants_are_ignored
-      index(<<~RUBY)
-        var::FOO = 1
-        self.class::FOO = 1
-      RUBY
-
-      assert_no_indexed_entries
-    end
-
-    def test_private_constant_indexing
-      index(<<~RUBY)
-        class A
-          B = 1
-          private_constant(:B)
-
-          C = 2
-          private_constant("C")
-
-          D = 1
-        end
-      RUBY
-
-      b_const = @index["A::B"]&.first #: as !nil
-      assert_predicate(b_const, :private?)
-
-      c_const = @index["A::C"]&.first #: as !nil
-      assert_predicate(c_const, :private?)
-
-      d_const = @index["A::D"]&.first #: as !nil
-      assert_predicate(d_const, :public?)
-    end
-
-    def test_marking_constants_as_private_reopening_namespaces
-      index(<<~RUBY)
-        module A
-          module B
-            CONST_A = 1
-            private_constant(:CONST_A)
-
-            CONST_B = 2
-            CONST_C = 3
-          end
-
-          module B
-            private_constant(:CONST_B)
-          end
-        end
-
-        module A
-          module B
-            private_constant(:CONST_C)
-          end
-        end
-      RUBY
-
-      a_const = @index["A::B::CONST_A"]&.first #: as !nil
-      assert_predicate(a_const, :private?)
-
-      b_const = @index["A::B::CONST_B"]&.first #: as !nil
-      assert_predicate(b_const, :private?)
-
-      c_const = @index["A::B::CONST_C"]&.first #: as !nil
-      assert_predicate(c_const, :private?)
-    end
-
-    def test_marking_constants_as_private_with_receiver
-      index(<<~RUBY)
-        module A
-          module B
-            CONST_A = 1
-            CONST_B = 2
-          end
-
-          B.private_constant(:CONST_A)
-        end
-
-        A::B.private_constant(:CONST_B)
-      RUBY
-
-      a_const = @index["A::B::CONST_A"]&.first #: as !nil
-      assert_predicate(a_const, :private?)
-
-      b_const = @index["A::B::CONST_B"]&.first #: as !nil
-      assert_predicate(b_const, :private?)
-    end
-
-    def test_indexing_constant_aliases
-      index(<<~RUBY)
-        module A
-          module B
-            module C
-            end
-          end
-
-          FIRST = B::C
-        end
-
-        SECOND = A::FIRST
-      RUBY
-
-      unresolve_entry = @index["A::FIRST"]&.first #: as Entry::UnresolvedConstantAlias
-      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
-      assert_equal(["A"], unresolve_entry.nesting)
-      assert_equal("B::C", unresolve_entry.target)
-
-      resolved_entry = @index.resolve("A::FIRST", [])&.first #: as Entry::ConstantAlias
-      assert_instance_of(Entry::ConstantAlias, resolved_entry)
-      assert_equal("A::B::C", resolved_entry.target)
-    end
-
-    def test_aliasing_namespaces
-      index(<<~RUBY)
-        module A
-          module B
-            module C
-            end
-          end
-
-          ALIAS = B
-        end
-
-        module Other
-          ONE_MORE = A::ALIAS
-        end
-      RUBY
-
-      unresolve_entry = @index["A::ALIAS"]&.first #: as Entry::UnresolvedConstantAlias
-      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
-      assert_equal(["A"], unresolve_entry.nesting)
-      assert_equal("B", unresolve_entry.target)
-
-      resolved_entry = @index.resolve("ALIAS", ["A"])&.first #: as Entry::ConstantAlias
-      assert_instance_of(Entry::ConstantAlias, resolved_entry)
-      assert_equal("A::B", resolved_entry.target)
-
-      resolved_entry = @index.resolve("ALIAS::C", ["A"])&.first #: as Entry::Module
-      assert_instance_of(Entry::Module, resolved_entry)
-      assert_equal("A::B::C", resolved_entry.name)
-
-      unresolve_entry = @index["Other::ONE_MORE"]&.first #: as Entry::UnresolvedConstantAlias
-      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
-      assert_equal(["Other"], unresolve_entry.nesting)
-      assert_equal("A::ALIAS", unresolve_entry.target)
-
-      resolved_entry = @index.resolve("Other::ONE_MORE::C", [])&.first
-      assert_instance_of(Entry::Module, resolved_entry)
-    end
-
-    def test_indexing_same_line_constant_aliases
-      index(<<~RUBY)
-        module A
-          B = C = 1
-          D = E ||= 1
-          F = G::H &&= 1
-          I::J = K::L = M = 1
-        end
-      RUBY
-
-      # B and C
-      unresolve_entry = @index["A::B"]&.first #: as Entry::UnresolvedConstantAlias
-      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
-      assert_equal(["A"], unresolve_entry.nesting)
-      assert_equal("C", unresolve_entry.target)
-
-      resolved_entry = @index.resolve("A::B", [])&.first #: as Entry::ConstantAlias
-      assert_instance_of(Entry::ConstantAlias, resolved_entry)
-      assert_equal("A::C", resolved_entry.target)
-
-      constant = @index["A::C"]&.first #: as Entry::Constant
-      assert_instance_of(Entry::Constant, constant)
-
-      # D and E
-      unresolve_entry = @index["A::D"]&.first #: as Entry::UnresolvedConstantAlias
-      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
-      assert_equal(["A"], unresolve_entry.nesting)
-      assert_equal("E", unresolve_entry.target)
-
-      resolved_entry = @index.resolve("A::D", [])&.first #: as Entry::ConstantAlias
-      assert_instance_of(Entry::ConstantAlias, resolved_entry)
-      assert_equal("A::E", resolved_entry.target)
-
-      # F and G::H
-      unresolve_entry = @index["A::F"]&.first #: as Entry::UnresolvedConstantAlias
-      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
-      assert_equal(["A"], unresolve_entry.nesting)
-      assert_equal("G::H", unresolve_entry.target)
-
-      resolved_entry = @index.resolve("A::F", [])&.first #: as Entry::ConstantAlias
-      assert_instance_of(Entry::ConstantAlias, resolved_entry)
-      assert_equal("A::G::H", resolved_entry.target)
-
-      # I::J, K::L and M
-      unresolve_entry = @index["A::I::J"]&.first #: as Entry::UnresolvedConstantAlias
-      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
-      assert_equal(["A"], unresolve_entry.nesting)
-      assert_equal("K::L", unresolve_entry.target)
-
-      resolved_entry = @index.resolve("A::I::J", [])&.first #: as Entry::ConstantAlias
-      assert_instance_of(Entry::ConstantAlias, resolved_entry)
-      assert_equal("A::K::L", resolved_entry.target)
-
-      # When we are resolving A::I::J, we invoke `resolve("K::L", ["A"])`, which recursively resolves A::K::L too.
-      # Therefore, both A::I::J and A::K::L point to A::M by the end of the previous resolve invocation
-      resolved_entry = @index["A::K::L"]&.first #: as Entry::ConstantAlias
-      assert_instance_of(Entry::ConstantAlias, resolved_entry)
-      assert_equal("A::M", resolved_entry.target)
-
-      constant = @index["A::M"]&.first
-      assert_instance_of(Entry::Constant, constant)
-    end
-
-    def test_indexing_or_and_operator_nodes
-      index(<<~RUBY)
-        A ||= 1
-        B &&= 2
-        C &= 3
-        D::E ||= 4
-        F::G &&= 5
-        H::I &= 6
-      RUBY
-
-      assert_entry("A", Entry::Constant, "/fake/path/foo.rb:0-0:0-7")
-      assert_entry("B", Entry::Constant, "/fake/path/foo.rb:1-0:1-7")
-      assert_entry("C", Entry::Constant, "/fake/path/foo.rb:2-0:2-6")
-      assert_entry("D::E", Entry::Constant, "/fake/path/foo.rb:3-0:3-10")
-      assert_entry("F::G", Entry::Constant, "/fake/path/foo.rb:4-0:4-10")
-      assert_entry("H::I", Entry::Constant, "/fake/path/foo.rb:5-0:5-9")
-    end
-
-    def test_indexing_constant_targets
-      index(<<~RUBY)
-        module A
-          B, C = [1, Y]
-          D::E, F::G = [Z, 4]
-          H, I::J = [5, B]
-          K, L = C
-        end
-
-        module Real
-          Z = 1
-          Y = 2
-        end
-      RUBY
-
-      assert_entry("A::B", Entry::Constant, "/fake/path/foo.rb:1-2:1-3")
-      assert_entry("A::C", Entry::UnresolvedConstantAlias, "/fake/path/foo.rb:1-5:1-6")
-      assert_entry("A::D::E", Entry::UnresolvedConstantAlias, "/fake/path/foo.rb:2-2:2-6")
-      assert_entry("A::F::G", Entry::Constant, "/fake/path/foo.rb:2-8:2-12")
-      assert_entry("A::H", Entry::Constant, "/fake/path/foo.rb:3-2:3-3")
-      assert_entry("A::I::J", Entry::UnresolvedConstantAlias, "/fake/path/foo.rb:3-5:3-9")
-      assert_entry("A::K", Entry::Constant, "/fake/path/foo.rb:4-2:4-3")
-      assert_entry("A::L", Entry::Constant, "/fake/path/foo.rb:4-5:4-6")
-    end
-
-    def test_indexing_constant_targets_with_splats
-      index(<<~RUBY)
-        A, *, B = baz
-        C, = bar
-        (D, E) = baz
-        F, G = *baz, qux
-        H, I = [baz, *qux]
-        J, L = [*something, String]
-        M = [String]
-      RUBY
-
-      assert_entry("A", Entry::Constant, "/fake/path/foo.rb:0-0:0-1")
-      assert_entry("B", Entry::Constant, "/fake/path/foo.rb:0-6:0-7")
-      assert_entry("D", Entry::Constant, "/fake/path/foo.rb:2-1:2-2")
-      assert_entry("E", Entry::Constant, "/fake/path/foo.rb:2-4:2-5")
-      assert_entry("F", Entry::Constant, "/fake/path/foo.rb:3-0:3-1")
-      assert_entry("G", Entry::Constant, "/fake/path/foo.rb:3-3:3-4")
-      assert_entry("H", Entry::Constant, "/fake/path/foo.rb:4-0:4-1")
-      assert_entry("I", Entry::Constant, "/fake/path/foo.rb:4-3:4-4")
-      assert_entry("J", Entry::Constant, "/fake/path/foo.rb:5-0:5-1")
-      assert_entry("L", Entry::Constant, "/fake/path/foo.rb:5-3:5-4")
-      assert_entry("M", Entry::Constant, "/fake/path/foo.rb:6-0:6-12")
-    end
-
-    def test_indexing_destructuring_an_array
-      index(<<~RUBY)
-        Baz = [1, 2]
-        Foo, Bar = Baz
-        This, That = foo, bar
-      RUBY
-
-      assert_entry("Baz", Entry::Constant, "/fake/path/foo.rb:0-0:0-12")
-      assert_entry("Foo", Entry::Constant, "/fake/path/foo.rb:1-0:1-3")
-      assert_entry("Bar", Entry::Constant, "/fake/path/foo.rb:1-5:1-8")
-      assert_entry("This", Entry::Constant, "/fake/path/foo.rb:2-0:2-4")
-      assert_entry("That", Entry::Constant, "/fake/path/foo.rb:2-6:2-10")
-    end
-  end
-end