ruby-lsp 0.23.14 → 0.23.16

data/lib/ruby_indexer/test/method_test.rb

@@ -47,9 +47,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
 
-      entry = T.must(@index["bar"].first)
-      owner = T.must(entry.owner)
-      assert_equal("Foo::<Class:Foo>", owner.name)
+      entry = @index["bar"]&.first #: as Entry::Method
+      owner = entry.owner
+      assert_equal("Foo::<Class:Foo>", owner&.name)
       assert_instance_of(Entry::SingletonClass, owner)
     end
 
@@ -79,11 +79,11 @@ module RubyIndexer
         end
       RUBY
 
-      assert_equal(2, @index["bar"].length)
-      first_entry = T.must(@index["bar"].first)
-      assert_equal("Foo::self::Bar", first_entry.owner.name)
-      second_entry = T.must(@index["bar"].last)
-      assert_equal("Bar", second_entry.owner.name)
+      assert_equal(2, @index["bar"]&.length)
+      first_entry = @index["bar"]&.first #: as Entry::Method
+      assert_equal("Foo::self::Bar", first_entry.owner&.name)
+      second_entry = @index["bar"]&.last #: as Entry::Method
+      assert_equal("Bar", second_entry.owner&.name)
     end
 
     def test_visibility_tracking
@@ -135,19 +135,19 @@ module RubyIndexer
       RUBY
 
       ["foo", "bar"].each do |keyword|
-        entries = T.must(@index[keyword])
+        entries = @index[keyword] #: as Array[Entry::Method]
         # should receive two entries because module_function creates a singleton method
         # for the Test module and a private method for classes include the Test module
         assert_equal(entries.size, 2)
         first_entry, second_entry = *entries
         # The first entry points to the location of the module_function call
-        assert_equal("Test", first_entry.owner.name)
-        assert_instance_of(Entry::Module, first_entry.owner)
+        assert_equal("Test", first_entry&.owner&.name)
+        assert_instance_of(Entry::Module, first_entry&.owner)
         assert_predicate(first_entry, :private?)
         # The second entry points to the public singleton method
-        assert_equal("Test::<Class:Test>", second_entry.owner.name)
-        assert_instance_of(Entry::SingletonClass, second_entry.owner)
-        assert_equal(Entry::Visibility::PUBLIC, second_entry.visibility)
+        assert_equal("Test::<Class:Test>", second_entry&.owner&.name)
+        assert_instance_of(Entry::SingletonClass, second_entry&.owner)
+        assert_equal(Entry::Visibility::PUBLIC, second_entry&.visibility)
       end
     end
 
@@ -168,13 +168,13 @@ module RubyIndexer
       RUBY
 
       ["foo", "bar"].each do |keyword|
-        entries = T.must(@index[keyword])
+        entries = @index[keyword] #: as Array[Entry::Method]
         assert_equal(1, entries.size)
         entry = entries.first
         assert_predicate(entry, :private?)
       end
 
-      entries = T.must(@index["baz"])
+      entries = @index["baz"] #: as Array[Entry::Method]
       assert_equal(1, entries.size)
       entry = entries.first
       assert_predicate(entry, :public?)
@@ -197,13 +197,13 @@ module RubyIndexer
       RUBY
 
       ["foo", "bar"].each do |keyword|
-        entries = T.must(@index[keyword])
+        entries = @index[keyword] #: as Array[Entry::Method]
         assert_equal(1, entries.size)
         entry = entries.first
         assert_predicate(entry, :private?)
       end
 
-      entries = T.must(@index["baz"])
+      entries = @index["baz"] #: as Array[Entry::Method]
       assert_equal(1, entries.size)
       entry = entries.first
       assert_predicate(entry, :public?)
@@ -220,12 +220,12 @@ module RubyIndexer
         end
       RUBY
 
-      entries = T.must(@index["foo"])
+      entries = @index["foo"] #: as Array[Entry::Method]
       assert_equal(1, entries.size)
       entry = entries.first
       assert_predicate(entry, :private?)
 
-      entries = T.must(@index["bar"])
+      entries = @index["bar"] #: as Array[Entry::Method]
       assert_equal(1, entries.size)
       entry = entries.first
       assert_predicate(entry, :public?)
@@ -251,17 +251,17 @@ module RubyIndexer
         end
       RUBY
 
-      foo_comment = @index["Foo"].first.comments
-      assert_equal("Documentation for Foo", foo_comment)
+      foo = @index["Foo"]&.first #: as !nil
+      assert_equal("Documentation for Foo", foo.comments)
 
-      bar_comment = @index["bar"].first.comments
-      assert_equal("####################\nDocumentation for bar\n####################\n", bar_comment)
+      bar = @index["bar"]&.first #: as !nil
+      assert_equal("####################\nDocumentation for bar\n####################\n", bar.comments)
 
-      baz_comment = @index["baz"].first.comments
-      assert_equal("Documentation for baz", baz_comment)
+      baz = @index["baz"]&.first #: as !nil
+      assert_equal("Documentation for baz", baz.comments)
 
-      ban_comment = @index["ban"].first.comments
-      assert_empty(ban_comment)
+      ban = @index["ban"]&.first #: as !nil
+      assert_empty(ban.comments)
     end
 
     def test_method_with_parameters
@@ -273,11 +273,11 @@ module RubyIndexer
       RUBY
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = T.must(@index["bar"].first)
-      parameters = entry.signatures.first.parameters
+      entry = @index["bar"]&.first #: as Entry::Method
+      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
       assert_equal(1, parameters.length)
       parameter = parameters.first
-      assert_equal(:a, parameter.name)
+      assert_equal(:a, parameter&.name)
       assert_instance_of(Entry::RequiredParameter, parameter)
     end
 
@@ -290,11 +290,11 @@ module RubyIndexer
       RUBY
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = T.must(@index["bar"].first)
-      parameters = entry.signatures.first.parameters
+      entry = @index["bar"]&.first #: as Entry::Method
+      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
       assert_equal(1, parameters.length)
       parameter = parameters.first
-      assert_equal(:"(a, (b, ))", parameter.name)
+      assert_equal(:"(a, (b, ))", parameter&.name)
       assert_instance_of(Entry::RequiredParameter, parameter)
     end
 
@@ -307,11 +307,11 @@ module RubyIndexer
       RUBY
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = T.must(@index["bar"].first)
-      parameters = entry.signatures.first.parameters
+      entry = @index["bar"]&.first #: as Entry::Method
+      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
       assert_equal(1, parameters.length)
       parameter = parameters.first
-      assert_equal(:a, parameter.name)
+      assert_equal(:a, parameter&.name)
       assert_instance_of(Entry::OptionalParameter, parameter)
     end
 
@@ -324,15 +324,15 @@ module RubyIndexer
       RUBY
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = T.must(@index["bar"].first)
-      parameters = entry.signatures.first.parameters
+      entry = @index["bar"]&.first #: as Entry::Method
+      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
       assert_equal(2, parameters.length)
       a, b = parameters
 
-      assert_equal(:a, a.name)
+      assert_equal(:a, a&.name)
       assert_instance_of(Entry::KeywordParameter, a)
 
-      assert_equal(:b, b.name)
+      assert_equal(:b, b&.name)
       assert_instance_of(Entry::OptionalKeywordParameter, b)
     end
 
@@ -345,15 +345,15 @@ module RubyIndexer
       RUBY
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = T.must(@index["bar"].first)
-      parameters = entry.signatures.first.parameters
+      entry = @index["bar"]&.first #: as Entry::Method
+      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
       assert_equal(2, parameters.length)
       a, b = parameters
 
-      assert_equal(:a, a.name)
+      assert_equal(:a, a&.name)
       assert_instance_of(Entry::RestParameter, a)
 
-      assert_equal(:b, b.name)
+      assert_equal(:b, b&.name)
       assert_instance_of(Entry::KeywordRestParameter, b)
     end
 
@@ -371,34 +371,34 @@ module RubyIndexer
       RUBY
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = T.must(@index["bar"].first)
-      parameters = entry.signatures.first.parameters
+      entry = @index["bar"]&.first #: as Entry::Method
+      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
       assert_equal(2, parameters.length)
       a, b = parameters
 
-      assert_equal(:a, a.name)
+      assert_equal(:a, a&.name)
       assert_instance_of(Entry::RestParameter, a)
 
-      assert_equal(:b, b.name)
+      assert_equal(:b, b&.name)
       assert_instance_of(Entry::RequiredParameter, b)
 
-      entry = T.must(@index["baz"].first)
-      parameters = entry.signatures.first.parameters
+      entry = @index["baz"]&.first #: as Entry::Method
+      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
       assert_equal(2, parameters.length)
       a, b = parameters
 
-      assert_equal(:a, a.name)
+      assert_equal(:a, a&.name)
       assert_instance_of(Entry::KeywordRestParameter, a)
 
-      assert_equal(:b, b.name)
+      assert_equal(:b, b&.name)
       assert_instance_of(Entry::RequiredParameter, b)
 
-      entry = T.must(@index["qux"].first)
-      parameters = entry.signatures.first.parameters
+      entry = @index["qux"]&.first #: as Entry::Method
+      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
       assert_equal(2, parameters.length)
       _a, second = parameters
 
-      assert_equal(:"(b, c)", second.name)
+      assert_equal(:"(b, c)", second&.name)
       assert_instance_of(Entry::RequiredParameter, second)
     end
 
@@ -411,10 +411,10 @@ module RubyIndexer
       RUBY
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = T.must(@index["bar"].first)
-      parameters = entry.signatures.first.parameters
+      entry = @index["bar"]&.first #: as Entry::Method
+      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
       assert_equal(1, parameters.length)
-      param = parameters.first
+      param = parameters.first #: as Entry::Parameter
 
       assert_equal(:"(a, *b)", param.name)
       assert_instance_of(Entry::RequiredParameter, param)
@@ -431,17 +431,17 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["bar"].first)
-      parameters = entry.signatures.first.parameters
-      param = parameters.first
+      entry = @index["bar"]&.first #: as Entry::Method
+      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
+      param = parameters.first #: as Entry::Parameter
       assert_equal(:block, param.name)
       assert_instance_of(Entry::BlockParameter, param)
 
-      entry = T.must(@index["baz"].first)
-      parameters = entry.signatures.first.parameters
+      entry = @index["baz"]&.first #: as Entry::Method
+      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
       assert_equal(1, parameters.length)
 
-      param = parameters.first
+      param = parameters.first #: as Entry::Parameter
       assert_equal(Entry::BlockParameter::DEFAULT_NAME, param.name)
       assert_instance_of(Entry::BlockParameter, param)
     end
@@ -455,15 +455,15 @@ module RubyIndexer
       RUBY
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = T.must(@index["bar"].first)
-      parameters = entry.signatures.first.parameters
+      entry = @index["bar"]&.first #: as Entry::Method
+      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
       assert_equal(2, parameters.length)
       first, second = parameters
 
-      assert_equal(Entry::RestParameter::DEFAULT_NAME, first.name)
+      assert_equal(Entry::RestParameter::DEFAULT_NAME, first&.name)
       assert_instance_of(Entry::RestParameter, first)
 
-      assert_equal(Entry::KeywordRestParameter::DEFAULT_NAME, second.name)
+      assert_equal(Entry::KeywordRestParameter::DEFAULT_NAME, second&.name)
       assert_instance_of(Entry::KeywordRestParameter, second)
     end
 
@@ -476,8 +476,8 @@ module RubyIndexer
       RUBY
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = T.must(@index["bar"].first)
-      parameters = entry.signatures.first.parameters
+      entry = @index["bar"]&.first #: as Entry::Method
+      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
       assert_empty(parameters)
     end
 
@@ -492,17 +492,17 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["bar"].first)
+      entry = @index["bar"]&.first #: as Entry::Method
       assert_instance_of(Entry::Method, entry, "Expected `bar` to be indexed")
 
-      parameters = entry.signatures.first.parameters
+      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
       assert_equal(1, parameters.length)
       assert_instance_of(Entry::ForwardingParameter, parameters.first)
 
-      entry = T.must(@index["baz"].first)
+      entry = @index["baz"]&.first #: as Entry::Method
       assert_instance_of(Entry::Method, entry, "Expected `baz` to be indexed")
 
-      parameters = entry.signatures.first.parameters
+      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
       assert_equal(2, parameters.length)
       assert_instance_of(Entry::RequiredParameter, parameters[0])
       assert_instance_of(Entry::ForwardingParameter, parameters[1])
@@ -516,8 +516,8 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["bar"].first)
-      owner_name = T.must(entry.owner).name
+      entry = @index["bar"]&.first #: as Entry::Method
+      owner_name = entry.owner&.name
 
       assert_equal("Foo", owner_name)
     end
@@ -533,9 +533,9 @@ module RubyIndexer
       RUBY
 
       assert_entry("bar", Entry::Accessor, "/fake/path/foo.rb:2-15:2-18")
-      assert_equal("Hello there", @index["bar"].first.comments)
+      assert_equal("Hello there", @index["bar"]&.first&.comments)
       assert_entry("other", Entry::Accessor, "/fake/path/foo.rb:2-21:2-26")
-      assert_equal("Hello there", @index["other"].first.comments)
+      assert_equal("Hello there", @index["other"]&.first&.comments)
       assert_entry("baz=", Entry::Accessor, "/fake/path/foo.rb:3-15:3-18")
       assert_entry("qux", Entry::Accessor, "/fake/path/foo.rb:4-17:4-20")
       assert_entry("qux=", Entry::Accessor, "/fake/path/foo.rb:4-17:4-20")
@@ -565,14 +565,14 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.cast(@index["first_method"]&.first, Entry::Method)
-      assert_equal("Foo", T.must(entry.owner).name)
+      entry = @index["first_method"]&.first #: as Entry::Method
+      assert_equal("Foo", entry.owner&.name)
 
-      entry = T.cast(@index["second_method"]&.first, Entry::Method)
-      assert_equal("Foo::Bar", T.must(entry.owner).name)
+      entry = @index["second_method"]&.first #: as Entry::Method
+      assert_equal("Foo::Bar", entry.owner&.name)
 
-      entry = T.cast(@index["third_method"]&.first, Entry::Method)
-      assert_equal("Foo", T.must(entry.owner).name)
+      entry = @index["third_method"]&.first #: as Entry::Method
+      assert_equal("Foo", entry.owner&.name)
     end
 
     def test_keeps_track_of_aliases
@@ -609,15 +609,15 @@ module RubyIndexer
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:1-19")
       assert_entry("baz", Entry::Method, "/fake/path/foo.rb:4-4:4-16")
 
-      bar_owner = T.must(T.must(@index["bar"].first).owner)
-      baz_owner = T.must(T.must(@index["baz"].first).owner)
+      bar = @index["bar"]&.first #: as Entry::Method
+      baz = @index["baz"]&.first #: as Entry::Method
 
-      assert_instance_of(Entry::SingletonClass, bar_owner)
-      assert_instance_of(Entry::SingletonClass, baz_owner)
+      assert_instance_of(Entry::SingletonClass, bar.owner)
+      assert_instance_of(Entry::SingletonClass, baz.owner)
 
       # Regardless of whether the method was added through `self.something` or `class << self`, the owner object must be
       # the exact same
-      assert_same(bar_owner, baz_owner)
+      assert_same(bar.owner, baz.owner)
     end
 
     def test_name_location_points_to_method_identifier_location
@@ -630,7 +630,7 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["bar"].first)
+      entry = @index["bar"]&.first #: as Entry::Method
       refute_equal(entry.location, entry.name_location)
 
       name_location = entry.name_location
@@ -648,7 +648,7 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["bar"].first)
+      entry = @index["bar"]&.first #: as Entry::Method
 
       # Matching calls
       assert_signature_matches(entry, "bar()")
@@ -682,7 +682,7 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["bar"].first)
+      entry = @index["bar"]&.first #: as Entry::Method
 
       # All calls match a forwarding parameter
       assert_signature_matches(entry, "bar(1)")
@@ -708,7 +708,7 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["bar"].first)
+      entry = @index["bar"]&.first #: as Entry::Method
 
       # All calls with at least one positional argument match
       assert_signature_matches(entry, "bar(1)")
@@ -734,7 +734,7 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["bar"].first)
+      entry = @index["bar"]&.first #: as Entry::Method
 
       # All calls with at least one positional argument match
       assert_signature_matches(entry, "bar()")
@@ -762,7 +762,7 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["bar"].first)
+      entry = @index["bar"]&.first #: as Entry::Method
 
       # All calls with at least one positional argument match
       assert_signature_matches(entry, "bar(1)")
@@ -789,7 +789,7 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["bar"].first)
+      entry = @index["bar"]&.first #: as Entry::Method
 
       assert_signature_matches(entry, "bar(...)")
       assert_signature_matches(entry, "bar()")
@@ -817,7 +817,7 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["bar"].first)
+      entry = @index["bar"]&.first #: as Entry::Method
 
       assert_signature_matches(entry, "bar(...)")
       assert_signature_matches(entry, "bar()")
@@ -841,10 +841,10 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["bar"].first)
+      entry = @index["bar"]&.first #: as Entry::Method
       assert_signature_matches(entry, "bar(a: 1)")
 
-      entry = T.must(@index["baz"].first)
+      entry = @index["baz"]&.first #: as Entry::Method
       assert_signature_matches(entry, "baz(1)")
     end
 
@@ -864,27 +864,27 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["bar"].first)
+      entry = @index["bar"]&.first #: as Entry::Method
       assert_predicate(entry, :public?)
-      assert_equal("Foo", T.must(entry.owner).name)
+      assert_equal("Foo", entry.owner&.name)
 
-      instance_baz, singleton_baz = T.must(@index["baz"])
+      instance_baz, singleton_baz = @index["baz"] #: as Array[Entry::Method]
       assert_predicate(instance_baz, :private?)
-      assert_equal("Foo", T.must(instance_baz.owner).name)
+      assert_equal("Foo", instance_baz&.owner&.name)
 
       assert_predicate(singleton_baz, :public?)
-      assert_equal("Foo::<Class:Foo>", T.must(singleton_baz.owner).name)
+      assert_equal("Foo::<Class:Foo>", singleton_baz&.owner&.name)
 
       # After invoking `public`, the state of `module_function` is reset
-      instance_qux, singleton_qux = T.must(@index["qux"])
+      instance_qux, singleton_qux = @index["qux"] #: as Array[Entry::Method]
       assert_nil(singleton_qux)
       assert_predicate(instance_qux, :public?)
-      assert_equal("Foo", T.must(instance_baz.owner).name)
+      assert_equal("Foo", instance_baz&.owner&.name)
 
       # Attributes are not turned into class methods, they do become private
-      instance_attribute, singleton_attribute = @index["attribute"]
+      instance_attribute, singleton_attribute = @index["attribute"] #: as Array[Entry::Method]
       assert_nil(singleton_attribute)
-      assert_equal("Foo", T.must(instance_attribute.owner).name)
+      assert_equal("Foo", instance_attribute&.owner&.name)
       assert_predicate(instance_attribute, :private?)
     end
 
@@ -900,13 +900,13 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["bar"].first)
+      entry = @index["bar"]&.first #: as Entry::Method
       assert_predicate(entry, :public?)
-      assert_equal("Foo", T.must(entry.owner).name)
+      assert_equal("Foo", entry.owner&.name)
 
-      entry = T.must(@index["baz"].first)
+      entry = @index["baz"]&.first #: as Entry::Method
       assert_predicate(entry, :public?)
-      assert_equal("Foo", T.must(entry.owner).name)
+      assert_equal("Foo", entry.owner&.name)
     end
 
     def test_making_several_class_methods_private
@@ -940,13 +940,13 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["bar"].first)
+      entry = @index["bar"]&.first #: as Entry::Method
       assert_predicate(entry, :private?)
 
-      entry = T.must(@index["baz"].first)
+      entry = @index["baz"]&.first #: as Entry::Method
       assert_predicate(entry, :protected?)
 
-      entry = T.must(@index["qux"].first)
+      entry = @index["qux"]&.first #: as Entry::Method
       assert_predicate(entry, :public?)
     end
 
@@ -954,14 +954,14 @@ module RubyIndexer
 
     #: (Entry::Method entry, String call_string) -> void
     def assert_signature_matches(entry, call_string)
-      sig = T.must(entry.signatures.first)
+      sig = entry.signatures.first #: as !nil
       arguments = parse_prism_args(call_string)
       assert(sig.matches?(arguments), "Expected #{call_string} to match #{entry.name}#{entry.decorated_parameters}")
     end
 
     #: (Entry::Method entry, String call_string) -> void
     def refute_signature_matches(entry, call_string)
-      sig = T.must(entry.signatures.first)
+      sig = entry.signatures.first #: as !nil
       arguments = parse_prism_args(call_string)
       refute(sig.matches?(arguments), "Expected #{call_string} to not match #{entry.name}#{entry.decorated_parameters}")
     end

data/lib/ruby_indexer/test/prefix_tree_test.rb

@@ -25,10 +25,10 @@ module RubyIndexer
       tree = PrefixTree[String].new
       ["foo", "bar", "baz"].each { |item| tree.insert(item, item) }
 
-      assert_equal(["foo", "bar", "baz"], tree.search(""))
-      assert_equal(["bar", "baz"], tree.search("b"))
+      assert_equal(["baz", "bar", "foo"], tree.search(""))
+      assert_equal(["baz", "bar"], tree.search("b"))
       assert_equal(["foo"], tree.search("fo"))
-      assert_equal(["bar", "baz"], tree.search("ba"))
+      assert_equal(["baz", "bar"], tree.search("ba"))
       assert_equal(["baz"], tree.search("baz"))
       assert_empty(tree.search("qux"))
     end
@@ -80,17 +80,17 @@ module RubyIndexer
 
       assert_equal(
         [
-          "foo/bar/support/selection",
-          "foo/bar/support/semantic",
-          "foo/bar/support/syntax",
-          "foo/bar/support/source",
+          "foo/bar/support/formatting",
+          "foo/bar/support/prefix",
+          "foo/bar/support/highlight",
+          "foo/bar/support/diagnostic",
+          "foo/bar/support/rails",
           "foo/bar/support/runner",
           "foo/bar/support/runner2",
-          "foo/bar/support/rails",
-          "foo/bar/support/diagnostic",
-          "foo/bar/support/highlight",
-          "foo/bar/support/prefix",
-          "foo/bar/support/formatting",
+          "foo/bar/support/source",
+          "foo/bar/support/syntax",
+          "foo/bar/support/semantic",
+          "foo/bar/support/selection",
         ],
         tree.search("foo/bar/support"),
       )
@@ -99,7 +99,7 @@ module RubyIndexer
     def test_deletion
       tree = PrefixTree[String].new
       ["foo/bar", "foo/baz"].each { |item| tree.insert(item, item) }
-      assert_equal(["foo/bar", "foo/baz"], tree.search("foo"))
+      assert_equal(["foo/baz", "foo/bar"], tree.search("foo"))
 
       tree.delete("foo/bar")
       assert_empty(tree.search("foo/bar"))