ruby-lsp 0.23.14 → 0.23.16

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -223,10 +223,12 @@ module RubyIndexer
         class Bar; end
       RUBY
 
-      foo_entry = @index["Foo"].first
+      foo_entry = @index["Foo"] #: as !nil
+        .first #: as !nil
       assert_equal("This is a Foo comment\nThis is another Foo comment", foo_entry.comments)
 
-      bar_entry = @index["Bar"].first
+      bar_entry = @index["Bar"] #: as !nil
+        .first #: as !nil
       assert_equal("This Bar comment has 1 line padding", bar_entry.comments)
     end
 
@@ -236,7 +238,7 @@ module RubyIndexer
         class Foo
         end
       RUBY
-      assert(@index["Foo"].first)
+      assert(@index["Foo"]&.first)
     end
 
     def test_comments_can_be_attached_to_a_namespaced_class
@@ -249,10 +251,12 @@ module RubyIndexer
         end
       RUBY
 
-      foo_entry = @index["Foo"].first
+      foo_entry = @index["Foo"] #: as !nil
+        .first #: as !nil
       assert_equal("This is a Foo comment\nThis is another Foo comment", foo_entry.comments)
 
-      bar_entry = @index["Foo::Bar"].first
+      bar_entry = @index["Foo::Bar"] #: as !nil
+        .first #: as !nil
       assert_equal("This is a Bar comment", bar_entry.comments)
     end
 
@@ -265,11 +269,9 @@ module RubyIndexer
         class Foo; end
       RUBY
 
-      first_foo_entry = @index["Foo"][0]
-      assert_equal("This is a Foo comment", first_foo_entry.comments)
-
-      second_foo_entry = @index["Foo"][1]
-      assert_equal("This is another Foo comment", second_foo_entry.comments)
+      first_foo_entry, second_foo_entry = @index["Foo"] #: as !nil
+      assert_equal("This is a Foo comment", first_foo_entry&.comments)
+      assert_equal("This is another Foo comment", second_foo_entry&.comments)
     end
 
     def test_comments_removes_the_leading_pound_and_space
@@ -281,10 +283,12 @@ module RubyIndexer
         class Bar; end
       RUBY
 
-      first_foo_entry = @index["Foo"][0]
+      first_foo_entry = @index["Foo"] #: as !nil
+        .first #: as !nil
       assert_equal("This is a Foo comment", first_foo_entry.comments)
 
-      second_foo_entry = @index["Bar"][0]
+      second_foo_entry = @index["Bar"] #: as !nil
+        .first #: as !nil
       assert_equal("This is a Bar comment", second_foo_entry.comments)
     end
 
@@ -301,14 +305,17 @@ module RubyIndexer
         end
       RUBY
 
-      b_const = @index["A::B"].first
+      b_const = @index["A::B"] #: as !nil
+        .first
       assert_predicate(b_const, :private?)
 
-      c_const = @index["A::C"].first
+      c_const = @index["A::C"] #: as !nil
+        .first
       assert_predicate(c_const, :private?)
 
-      d_const = @index["A::D"].first
-      assert_equal(Entry::Visibility::PUBLIC, d_const.visibility)
+      d_const = @index["A::D"] #: as !nil
+        .first
+      assert_predicate(d_const, :public?)
     end
 
     def test_keeping_track_of_super_classes
@@ -331,16 +338,20 @@ module RubyIndexer
         end
       RUBY
 
-      foo = T.must(@index["Foo"].first)
+      foo = @index["Foo"] #: as !nil
+        .first #: as Entry::Class
       assert_equal("Bar", foo.parent_class)
 
-      baz = T.must(@index["Baz"].first)
+      baz = @index["Baz"] #: as !nil
+        .first #: as Entry::Class
       assert_equal("::Object", baz.parent_class)
 
-      qux = T.must(@index["Something::Qux"].first)
+      qux = @index["Something::Qux"] #: as !nil
+        .first #: as Entry::Class
       assert_equal("::Baz", qux.parent_class)
 
-      final_thing = T.must(@index["FinalThing"].first)
+      final_thing = @index["FinalThing"] #: as !nil
+        .first #: as Entry::Class
       assert_equal("Something::Baz", final_thing.parent_class)
     end
 
@@ -380,13 +391,16 @@ module RubyIndexer
         end
       RUBY
 
-      foo = T.must(@index["Foo"][0])
+      foo = @index["Foo"] #: as !nil
+        .first #: as Entry::Class
       assert_equal(["A1", "A2", "A3", "A4", "A5", "A6"], foo.mixin_operation_module_names)
 
-      qux = T.must(@index["Foo::Qux"][0])
+      qux = @index["Foo::Qux"] #: as !nil
+        .first #: as Entry::Class
       assert_equal(["Corge", "Corge", "Baz"], qux.mixin_operation_module_names)
 
-      constant_path_references = T.must(@index["ConstantPathReferences"][0])
+      constant_path_references = @index["ConstantPathReferences"] #: as !nil
+        .first #: as Entry::Class
       assert_equal(["Foo::Bar", "Foo::Bar2"], constant_path_references.mixin_operation_module_names)
     end
 
@@ -426,13 +440,16 @@ module RubyIndexer
         end
       RUBY
 
-      foo = T.must(@index["Foo"][0])
+      foo = @index["Foo"] #: as !nil
+        .first #: as Entry::Class
       assert_equal(["A1", "A2", "A3", "A4", "A5", "A6"], foo.mixin_operation_module_names)
 
-      qux = T.must(@index["Foo::Qux"][0])
+      qux = @index["Foo::Qux"] #: as !nil
+        .first #: as Entry::Class
       assert_equal(["Corge", "Corge", "Baz"], qux.mixin_operation_module_names)
 
-      constant_path_references = T.must(@index["ConstantPathReferences"][0])
+      constant_path_references = @index["ConstantPathReferences"] #: as !nil
+        .first #: as Entry::Class
       assert_equal(["Foo::Bar", "Foo::Bar2"], constant_path_references.mixin_operation_module_names)
     end
 
@@ -472,13 +489,16 @@ module RubyIndexer
         end
       RUBY
 
-      foo = T.must(@index["Foo::<Class:Foo>"][0])
+      foo = @index["Foo::<Class:Foo>"] #: as !nil
+        .first #: as Entry::Class
       assert_equal(["A1", "A2", "A3", "A4", "A5", "A6"], foo.mixin_operation_module_names)
 
-      qux = T.must(@index["Foo::Qux::<Class:Qux>"][0])
+      qux = @index["Foo::Qux::<Class:Qux>"] #: as !nil
+        .first #: as Entry::Class
       assert_equal(["Corge", "Corge", "Baz"], qux.mixin_operation_module_names)
 
-      constant_path_references = T.must(@index["ConstantPathReferences::<Class:ConstantPathReferences>"][0])
+      constant_path_references = @index["ConstantPathReferences::<Class:ConstantPathReferences>"] #: as !nil
+        .first #: as Entry::Class
       assert_equal(["Foo::Bar", "Foo::Bar2"], constant_path_references.mixin_operation_module_names)
     end
 
@@ -492,7 +512,8 @@ module RubyIndexer
         end
       RUBY
 
-      foo = T.must(@index["Foo::<Class:Foo>"].first)
+      foo = @index["Foo::<Class:Foo>"] #: as !nil
+        .first #: as Entry::SingletonClass
       assert_equal(4, foo.location.start_line)
       assert_equal("Some extra comments", foo.comments)
     end
@@ -506,7 +527,8 @@ module RubyIndexer
         end
       RUBY
 
-      singleton = T.must(@index["Foo::<Class:bar>"].first)
+      singleton = @index["Foo::<Class:bar>"] #: as !nil
+        .first #: as Entry::SingletonClass
 
       # Even though this is not correct, we consider any dynamic singleton class block as a regular singleton class.
       # That pattern cannot be properly analyzed statically and assuming that it's always a regular singleton simplifies
@@ -539,7 +561,8 @@ module RubyIndexer
         end
       RUBY
 
-      foo = T.must(@index["Foo"].first)
+      foo = @index["Foo"] #: as !nil
+        .first #: as Entry::Class
       refute_equal(foo.location, foo.name_location)
 
       name_location = foo.name_location
@@ -548,7 +571,8 @@ module RubyIndexer
       assert_equal(6, name_location.start_column)
       assert_equal(9, name_location.end_column)
 
-      bar = T.must(@index["Bar"].first)
+      bar = @index["Bar"] #: as !nil
+        .first #: as Entry::Module
       refute_equal(bar.location, bar.name_location)
 
       name_location = bar.name_location
@@ -625,7 +649,8 @@ module RubyIndexer
 
       @index.index_file(uri, collect_comments: false)
 
-      entry = @index["RubyLsp::NodeContext"].first
+      entry = @index["RubyLsp::NodeContext"] #: as !nil
+        .first #: as !nil
 
       assert_equal(<<~COMMENTS.chomp, entry.comments)
         This class allows listeners to access contextual information about a node in the AST, such as its parent,
@@ -644,7 +669,7 @@ module RubyIndexer
         end
       RUBY
 
-      entry = @index["Foo"].first
+      entry = @index["Foo"]&.first #: as !nil
       assert_empty(entry.comments)
     end
 
@@ -663,8 +688,8 @@ module RubyIndexer
       # Verify we indexed the correct name
       assert_entry("Foo::Bar::<Class:Bar>", Entry::SingletonClass, "/fake/path/foo.rb:1-2:3-5")
 
-      method = @index["baz"]&.first
-      assert_equal("Foo::Bar::<Class:Bar>", method.owner.name)
+      method = @index["baz"]&.first #: as Entry::Method
+      assert_equal("Foo::Bar::<Class:Bar>", method.owner&.name)
     end
 
     def test_lazy_comments_with_spaces_are_properly_attributed
@@ -681,7 +706,7 @@ module RubyIndexer
       File.write(path, source)
       @index.index_single(URI::Generic.from_path(path: path), source, collect_comments: false)
 
-      entry = @index["Foo"].first
+      entry = @index["Foo"]&.first #: as !nil
 
       begin
         assert_equal(<<~COMMENTS.chomp, entry.comments)
@@ -706,7 +731,7 @@ module RubyIndexer
       File.write(path, source)
       @index.index_single(URI::Generic.from_path(path: path), source, collect_comments: false)
 
-      entry = @index["Foo"].first
+      entry = @index["Foo"]&.first #: as !nil
 
       begin
         assert_equal(<<~COMMENTS.chomp, entry.comments)
@@ -733,7 +758,7 @@ module RubyIndexer
       File.write(path, source)
       @index.index_single(URI::Generic.from_path(path: path), source, collect_comments: false)
 
-      entry = @index["Foo"].first
+      entry = @index["Foo"]&.first #: as !nil
 
       begin
         assert_empty(entry.comments)

data/lib/ruby_indexer/test/configuration_test.rb

@@ -97,10 +97,12 @@ module RubyIndexer
       path = Pathname.new(RbConfig::CONFIG["rubylibdir"]).join("extra_file.txt").to_s
       FileUtils.touch(path)
 
-      uris = @config.indexable_uris
-      assert(uris.none? { |uri| uri.full_path == path })
-    ensure
-      FileUtils.rm(T.must(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

data/lib/ruby_indexer/test/constant_test.rb

@@ -94,17 +94,17 @@ module RubyIndexer
         A::BAZ = 1
       RUBY
 
-      foo_comment = @index["FOO"].first.comments
-      assert_equal("FOO comment", foo_comment)
+      foo = @index["FOO"]&.first #: as !nil
+      assert_equal("FOO comment", foo.comments)
 
-      a_foo_comment = @index["A::FOO"].first.comments
-      assert_equal("A::FOO comment", a_foo_comment)
+      a_foo = @index["A::FOO"]&.first #: as !nil
+      assert_equal("A::FOO comment", a_foo.comments)
 
-      bar_comment = @index["BAR"].first.comments
-      assert_equal("::BAR comment", bar_comment)
+      bar = @index["BAR"]&.first #: as !nil
+      assert_equal("::BAR comment", bar.comments)
 
-      a_baz_comment = @index["A::BAZ"].first.comments
-      assert_equal("A::BAZ comment", a_baz_comment)
+      a_baz = @index["A::BAZ"]&.first #: as !nil
+      assert_equal("A::BAZ comment", a_baz.comments)
     end
 
     def test_variable_path_constants_are_ignored
@@ -129,13 +129,13 @@ module RubyIndexer
         end
       RUBY
 
-      b_const = @index["A::B"].first
+      b_const = @index["A::B"]&.first #: as !nil
       assert_predicate(b_const, :private?)
 
-      c_const = @index["A::C"].first
+      c_const = @index["A::C"]&.first #: as !nil
       assert_predicate(c_const, :private?)
 
-      d_const = @index["A::D"].first
+      d_const = @index["A::D"]&.first #: as !nil
       assert_predicate(d_const, :public?)
     end
 
@@ -162,13 +162,13 @@ module RubyIndexer
         end
       RUBY
 
-      a_const = @index["A::B::CONST_A"].first
+      a_const = @index["A::B::CONST_A"]&.first #: as !nil
       assert_predicate(a_const, :private?)
 
-      b_const = @index["A::B::CONST_B"].first
+      b_const = @index["A::B::CONST_B"]&.first #: as !nil
       assert_predicate(b_const, :private?)
 
-      c_const = @index["A::B::CONST_C"].first
+      c_const = @index["A::B::CONST_C"]&.first #: as !nil
       assert_predicate(c_const, :private?)
     end
 
@@ -186,10 +186,10 @@ module RubyIndexer
         A::B.private_constant(:CONST_B)
       RUBY
 
-      a_const = @index["A::B::CONST_A"].first
+      a_const = @index["A::B::CONST_A"]&.first #: as !nil
       assert_predicate(a_const, :private?)
 
-      b_const = @index["A::B::CONST_B"].first
+      b_const = @index["A::B::CONST_B"]&.first #: as !nil
       assert_predicate(b_const, :private?)
     end
 
@@ -207,12 +207,12 @@ module RubyIndexer
         SECOND = A::FIRST
       RUBY
 
-      unresolve_entry = @index["A::FIRST"].first
+      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
+      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
@@ -233,25 +233,25 @@ module RubyIndexer
         end
       RUBY
 
-      unresolve_entry = @index["A::ALIAS"].first
+      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
+      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
+      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
+      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
+      resolved_entry = @index.resolve("Other::ONE_MORE::C", [])&.first
       assert_instance_of(Entry::Module, resolved_entry)
     end
 
@@ -266,55 +266,55 @@ module RubyIndexer
       RUBY
 
       # B and C
-      unresolve_entry = @index["A::B"].first
+      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
+      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
+      constant = @index["A::C"]&.first #: as Entry::Constant
       assert_instance_of(Entry::Constant, constant)
 
       # D and E
-      unresolve_entry = @index["A::D"].first
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      constant = @index["A::M"]&.first
       assert_instance_of(Entry::Constant, constant)
     end
 

data/lib/ruby_indexer/test/enhancements_test.rb

@@ -108,7 +108,7 @@ module RubyIndexer
           return unless association_name.is_a?(Prism::SymbolNode)
 
           @listener.add_method(
-            T.must(association_name.value),
+            association_name.value, #: as !nil
             association_name.location,
             [],
           )