ruby-lsp 0.17.3 → 0.17.5

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -461,14 +461,90 @@ module RubyIndexer
         end
       RUBY
 
-      foo = T.must(@index["Foo"][0])
+      foo = T.must(@index["Foo::<Class:Foo>"][0])
       assert_equal(["A1", "A2", "A3", "A4", "A5", "A6"], foo.mixin_operation_module_names)
 
-      qux = T.must(@index["Foo::Qux"][0])
+      qux = T.must(@index["Foo::Qux::<Class:Qux>"][0])
       assert_equal(["Corge", "Corge", "Baz"], qux.mixin_operation_module_names)
 
-      constant_path_references = T.must(@index["ConstantPathReferences"][0])
+      constant_path_references = T.must(@index["ConstantPathReferences::<Class:ConstantPathReferences>"][0])
       assert_equal(["Foo::Bar", "Foo::Bar2"], constant_path_references.mixin_operation_module_names)
     end
+
+    def test_tracking_singleton_classes
+      index(<<~RUBY)
+        class Foo; end
+        class Foo
+          # Some extra comments
+          class << self
+          end
+        end
+      RUBY
+
+      foo = T.must(@index["Foo::<Class:Foo>"].first)
+      assert_equal(4, foo.location.start_line)
+      assert_equal("Some extra comments", foo.comments.join("\n"))
+    end
+
+    def test_dynamic_singleton_class_blocks
+      index(<<~RUBY)
+        class Foo
+          # Some extra comments
+          class << bar
+          end
+        end
+      RUBY
+
+      singleton = T.must(@index["Foo::<Class:bar>"].first)
+
+      # 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
+      # the implementation considerably.
+      assert_equal(3, singleton.location.start_line)
+      assert_equal("Some extra comments", singleton.comments.join("\n"))
+    end
+
+    def test_namespaces_inside_singleton_blocks
+      index(<<~RUBY)
+        class Foo
+          class << self
+            class Bar
+            end
+          end
+        end
+      RUBY
+
+      assert_entry("Foo::<Class:Foo>::Bar", Entry::Class, "/fake/path/foo.rb:2-4:3-7")
+    end
+
+    def test_name_location_points_to_constant_path_location
+      index(<<~RUBY)
+        class Foo
+          def foo; end
+        end
+
+        module Bar
+          def bar; end
+        end
+      RUBY
+
+      foo = T.must(@index["Foo"].first)
+      refute_equal(foo.location, foo.name_location)
+
+      name_location = foo.name_location
+      assert_equal(1, name_location.start_line)
+      assert_equal(1, name_location.end_line)
+      assert_equal(6, name_location.start_column)
+      assert_equal(9, name_location.end_column)
+
+      bar = T.must(@index["Bar"].first)
+      refute_equal(bar.location, bar.name_location)
+
+      name_location = bar.name_location
+      assert_equal(5, name_location.start_line)
+      assert_equal(5, name_location.end_line)
+      assert_equal(7, name_location.start_column)
+      assert_equal(10, name_location.end_column)
+    end
   end
 end