ruby-lsp 0.16.5 → 0.16.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bcd4426f17d6d429be733a9adcdf799e23c29689ad5fb69f9b9f7b3cd334bf9b
-  data.tar.gz: 071d5c37e1acf83c07a5b48e85a3bc4a18fb63a20b54ff191158799cf4320803
+  metadata.gz: ebc166637de670ea02144e74ccb2e99ae1a9824c9f99995380d81bed99ff6a29
+  data.tar.gz: 48b7ef9364f4d1a8044042c8476414e87da5b38ca4871683c16d06636fc8e411
 SHA512:
-  metadata.gz: 9edc44ec74f5f5d9b5f15fb7d22501126eb8f6bec3d9a69b3061946b369ecb0e453e45e9a0dc9df1482117dc738f7bd66005e2dcd0cd46e3aaad6f6658283766
-  data.tar.gz: c4f9ddb4da9373544b2456632a0fb76bdbca5e5ddf5e874b0e6ab4f6aae13ad8b17ef9482873b37ae33bc7ec797faebde76bf5a6e9d86e6a4ddf798b4eb9f0df
+  metadata.gz: 80c4f791e7dfef66623f5190eaba4dc76c745a27f74238d912c34711c408803ec952d5ec3e8041ebb6410b99c74d2f3d8274db5dffa8f187e48a7032a3960086
+  data.tar.gz: 941209321fb263b9a22cbe27102e8761c6ef127902e2b74f760fec1a8701d96e5bcef5f01c704e7215e061437cac2577c38e100464cccfe03909aa42ee1e318e

data/README.md

@@ -33,7 +33,7 @@ The Ruby LSP features include
 - Completion for classes, modules, constants and require paths
 - Fuzzy search classes, modules and constants anywhere in the project and its dependencies (workspace symbol)
 
-Adding method support for definition, completion, hover and workspace symbol is planned, but not yet completed.
+Adding method support for definition, completion, hover and workspace symbol is partially supported, but not yet complete. Follow progress in https://github.com/Shopify/ruby-lsp/issues/899
 
 See complete information about features [here](https://shopify.github.io/ruby-lsp/RubyLsp/Requests.html).
 

data/VERSION

@@ -1 +1 @@
-0.16.5
+0.16.7

data/exe/ruby-lsp

@@ -18,6 +18,10 @@ parser = OptionParser.new do |opts|
     options[:debug] = true
   end
 
+  opts.on("--time-index", "Measure the time it takes to index the project") do
+    options[:time_index] = true
+  end
+
   opts.on(
     "--branch [BRANCH]",
     "Launch the Ruby LSP using the specified branch rather than the release version",
@@ -75,15 +79,32 @@ require "ruby_lsp/internal"
 
 if options[:debug]
   if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
-    puts "Debugging is not supported on Windows"
+    $stderr.puts "Debugging is not supported on Windows"
     exit 1
   end
 
   begin
+    ENV.delete("RUBY_DEBUG_IRB_CONSOLE")
     require "debug/open_nonstop"
   rescue LoadError
-    warn("You need to install the debug gem to use the --debug flag")
+    $stderr.puts("You need to install the debug gem to use the --debug flag")
   end
 end
 
+if options[:time_index]
+  require "benchmark"
+
+  index = RubyIndexer::Index.new
+
+  result = Benchmark.realtime { index.index_all }
+  entries = index.instance_variable_get(:@entries)
+  entries_by_entry_type = entries.values.flatten.group_by(&:class)
+
+  puts <<~MSG
+    Ruby LSP v#{RubyLsp::VERSION}: Indexing took #{result.round(5)} seconds and generated:
+    - #{entries_by_entry_type.map { |k, v| "#{k.name.split("::").last}: #{v.size}" }.join("\n- ")}
+  MSG
+  return
+end
+
 RubyLsp::Server.new.start

data/exe/ruby-lsp-check

@@ -47,9 +47,7 @@ index = RubyIndexer::Index.new
 indexables = RubyIndexer.configuration.indexables
 
 indexables.each_with_index do |indexable, i|
-  result = Prism.parse(File.read(indexable.full_path))
-  collector = RubyIndexer::Collector.new(index, result, indexable.full_path)
-  collector.collect(result.value)
+  index.index_single(indexable)
 rescue => e
   errors[indexable.full_path] = e
 ensure

data/exe/ruby-lsp-doctor

@@ -19,8 +19,5 @@ puts "Globbing for indexable files"
 
 RubyIndexer.configuration.indexables.each do |indexable|
   puts "indexing: #{indexable.full_path}"
-  content = File.read(indexable.full_path)
-  result = Prism.parse(content)
-  collector = RubyIndexer::Collector.new(index, result, indexable.full_path)
-  collector.collect(result.value)
+  index.index_single(indexable)
 end

data/lib/core_ext/uri.rb

@@ -11,6 +11,9 @@ module URI
         # On Windows, if the path begins with the disk name, we need to add a leading slash to make it a valid URI
         escaped_path = if /^[A-Z]:/i.match?(path)
           DEFAULT_PARSER.escape("/#{path}")
+        elsif path.start_with?("//?/")
+          # Some paths on Windows start with "//?/". This is a special prefix that allows for long file paths
+          DEFAULT_PARSER.escape(path.delete_prefix("//?"))
         else
           DEFAULT_PARSER.escape(path)
         end

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -56,6 +56,7 @@ module RubyIndexer
         load_path_entry = T.let(nil, T.nilable(String))
 
         Dir.glob(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB).map! do |path|
+          path = File.expand_path(path)
           # All entries for the same pattern match the same $LOAD_PATH entry. Since searching the $LOAD_PATH for every
           # entry is expensive, we memoize it until we find a path that doesn't belong to that $LOAD_PATH. This happens
           # on repositories that define multiple gems, like Rails. All frameworks are defined inside the Dir.pwd, but

data/lib/ruby_indexer/lib/ruby_indexer/{collector.rb → declaration_listener.rb}

@@ -2,79 +2,103 @@
 # frozen_string_literal: true
 
 module RubyIndexer
-  class Collector
+  class DeclarationListener
     extend T::Sig
 
-    LEAVE_EVENT = T.let(Object.new.freeze, Object)
-
-    sig { params(index: Index, parse_result: Prism::ParseResult, file_path: String).void }
-    def initialize(index, parse_result, file_path)
+    sig do
+      params(index: Index, dispatcher: Prism::Dispatcher, parse_result: Prism::ParseResult, file_path: String).void
+    end
+    def initialize(index, dispatcher, parse_result, file_path)
       @index = index
       @file_path = file_path
-      @stack = T.let([], T::Array[String])
       @comments_by_line = T.let(
         parse_result.comments.to_h do |c|
           [c.location.start_line, c]
         end,
         T::Hash[Integer, Prism::Comment],
       )
-      @queue = T.let([], T::Array[Object])
-      @current_owner = T.let(nil, T.nilable(Entry::Namespace))
+      @inside_def = T.let(false, T::Boolean)
+
+      # The nesting stack we're currently inside. Used to determine the fully qualified name of constants, but only
+      # stored by unresolved aliases which need the original nesting to be lazily resolved
+      @stack = T.let([], T::Array[String])
 
-      super()
+      # A stack of namespace entries that represent where we currently are. Used to properly assign methods to an owner
+      @owner_stack = T.let([], T::Array[Entry::Namespace])
+
+      dispatcher.register(
+        self,
+        :on_class_node_enter,
+        :on_class_node_leave,
+        :on_module_node_enter,
+        :on_module_node_leave,
+        :on_def_node_enter,
+        :on_def_node_leave,
+        :on_call_node_enter,
+        :on_multi_write_node_enter,
+        :on_constant_path_write_node_enter,
+        :on_constant_path_or_write_node_enter,
+        :on_constant_path_operator_write_node_enter,
+        :on_constant_path_and_write_node_enter,
+        :on_constant_or_write_node_enter,
+        :on_constant_write_node_enter,
+        :on_constant_or_write_node_enter,
+        :on_constant_and_write_node_enter,
+        :on_constant_operator_write_node_enter,
+      )
     end
 
-    sig { params(node: Prism::Node).void }
-    def collect(node)
-      @queue = [node]
-
-      until @queue.empty?
-        node_or_event = @queue.shift
-
-        case node_or_event
-        when Prism::ProgramNode
-          @queue << node_or_event.statements
-        when Prism::StatementsNode
-          T.unsafe(@queue).prepend(*node_or_event.body)
-        when Prism::ClassNode
-          add_class_entry(node_or_event)
-        when Prism::ModuleNode
-          add_module_entry(node_or_event)
-        when Prism::MultiWriteNode
-          handle_multi_write_node(node_or_event)
-        when Prism::ConstantPathWriteNode
-          handle_constant_path_write_node(node_or_event)
-        when Prism::ConstantPathOrWriteNode
-          handle_constant_path_or_write_node(node_or_event)
-        when Prism::ConstantPathOperatorWriteNode
-          handle_constant_path_operator_write_node(node_or_event)
-        when Prism::ConstantPathAndWriteNode
-          handle_constant_path_and_write_node(node_or_event)
-        when Prism::ConstantWriteNode
-          handle_constant_write_node(node_or_event)
-        when Prism::ConstantOrWriteNode
-          name = fully_qualify_name(node_or_event.name.to_s)
-          add_constant(node_or_event, name)
-        when Prism::ConstantAndWriteNode
-          name = fully_qualify_name(node_or_event.name.to_s)
-          add_constant(node_or_event, name)
-        when Prism::ConstantOperatorWriteNode
-          name = fully_qualify_name(node_or_event.name.to_s)
-          add_constant(node_or_event, name)
-        when Prism::CallNode
-          handle_call_node(node_or_event)
-        when Prism::DefNode
-          handle_def_node(node_or_event)
-        when LEAVE_EVENT
-          @stack.pop
-        end
+    sig { params(node: Prism::ClassNode).void }
+    def on_class_node_enter(node)
+      name = node.constant_path.location.slice
+
+      comments = collect_comments(node)
+
+      superclass = node.superclass
+      parent_class = case superclass
+      when Prism::ConstantReadNode, Prism::ConstantPathNode
+        superclass.slice
       end
+
+      entry = Entry::Class.new(
+        fully_qualify_name(name),
+        @file_path,
+        node.location,
+        comments,
+        parent_class,
+      )
+
+      @owner_stack << entry
+      @index << entry
+      @stack << name
     end
 
-    private
+    sig { params(node: Prism::ClassNode).void }
+    def on_class_node_leave(node)
+      @stack.pop
+      @owner_stack.pop
+    end
+
+    sig { params(node: Prism::ModuleNode).void }
+    def on_module_node_enter(node)
+      name = node.constant_path.location.slice
+
+      comments = collect_comments(node)
+      entry = Entry::Module.new(fully_qualify_name(name), @file_path, node.location, comments)
+
+      @owner_stack << entry
+      @index << entry
+      @stack << name
+    end
+
+    sig { params(node: Prism::ModuleNode).void }
+    def on_module_node_leave(node)
+      @stack.pop
+      @owner_stack.pop
+    end
 
     sig { params(node: Prism::MultiWriteNode).void }
-    def handle_multi_write_node(node)
+    def on_multi_write_node_enter(node)
       value = node.value
       values = value.is_a?(Prism::ArrayNode) && value.opening_loc ? value.elements : []
 
@@ -94,7 +118,7 @@ module RubyIndexer
     end
 
     sig { params(node: Prism::ConstantPathWriteNode).void }
-    def handle_constant_path_write_node(node)
+    def on_constant_path_write_node_enter(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -104,7 +128,7 @@ module RubyIndexer
     end
 
     sig { params(node: Prism::ConstantPathOrWriteNode).void }
-    def handle_constant_path_or_write_node(node)
+    def on_constant_path_or_write_node_enter(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -114,7 +138,7 @@ module RubyIndexer
     end
 
     sig { params(node: Prism::ConstantPathOperatorWriteNode).void }
-    def handle_constant_path_operator_write_node(node)
+    def on_constant_path_operator_write_node_enter(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -124,7 +148,7 @@ module RubyIndexer
     end
 
     sig { params(node: Prism::ConstantPathAndWriteNode).void }
-    def handle_constant_path_and_write_node(node)
+    def on_constant_path_and_write_node_enter(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -134,13 +158,31 @@ module RubyIndexer
     end
 
     sig { params(node: Prism::ConstantWriteNode).void }
-    def handle_constant_write_node(node)
+    def on_constant_write_node_enter(node)
+      name = fully_qualify_name(node.name.to_s)
+      add_constant(node, name)
+    end
+
+    sig { params(node: Prism::ConstantOrWriteNode).void }
+    def on_constant_or_write_node_enter(node)
+      name = fully_qualify_name(node.name.to_s)
+      add_constant(node, name)
+    end
+
+    sig { params(node: Prism::ConstantAndWriteNode).void }
+    def on_constant_and_write_node_enter(node)
+      name = fully_qualify_name(node.name.to_s)
+      add_constant(node, name)
+    end
+
+    sig { params(node: Prism::ConstantOperatorWriteNode).void }
+    def on_constant_operator_write_node_enter(node)
       name = fully_qualify_name(node.name.to_s)
       add_constant(node, name)
     end
 
     sig { params(node: Prism::CallNode).void }
-    def handle_call_node(node)
+    def on_call_node_enter(node)
       message = node.name
 
       case message
@@ -153,14 +195,15 @@ module RubyIndexer
       when :attr_accessor
         handle_attribute(node, reader: true, writer: true)
       when :include
-        handle_include(node)
+        handle_module_operation(node, :included_modules)
       when :prepend
-        handle_prepend(node)
+        handle_module_operation(node, :prepended_modules)
       end
     end
 
     sig { params(node: Prism::DefNode).void }
-    def handle_def_node(node)
+    def on_def_node_enter(node)
+      @inside_def = true
       method_name = node.name.to_s
       comments = collect_comments(node)
       case node.receiver
@@ -171,7 +214,7 @@ module RubyIndexer
           node.location,
           comments,
           node.parameters,
-          @current_owner,
+          @owner_stack.last,
         )
       when Prism::SelfNode
         @index << Entry::SingletonMethod.new(
@@ -180,11 +223,18 @@ module RubyIndexer
           node.location,
           comments,
           node.parameters,
-          @current_owner,
+          @owner_stack.last,
         )
       end
     end
 
+    sig { params(node: Prism::DefNode).void }
+    def on_def_node_leave(node)
+      @inside_def = false
+    end
+
+    private
+
     sig { params(node: Prism::CallNode).void }
     def handle_private_constant(node)
       arguments = node.arguments&.arguments
@@ -240,62 +290,16 @@ module RubyIndexer
 
         # If the right hand side is another constant assignment, we need to visit it because that constant has to be
         # indexed too
-        @queue.prepend(value)
         Entry::UnresolvedAlias.new(value.name.to_s, @stack.dup, name, @file_path, node.location, comments)
       when Prism::ConstantPathWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode,
         Prism::ConstantPathAndWriteNode
 
-        @queue.prepend(value)
         Entry::UnresolvedAlias.new(value.target.slice, @stack.dup, name, @file_path, node.location, comments)
       else
         Entry::Constant.new(name, @file_path, node.location, comments)
       end
     end
 
-    sig { params(node: Prism::ModuleNode).void }
-    def add_module_entry(node)
-      name = node.constant_path.location.slice
-      unless /^[A-Z:]/.match?(name)
-        @queue << node.body
-        return
-      end
-
-      comments = collect_comments(node)
-      @current_owner = Entry::Module.new(fully_qualify_name(name), @file_path, node.location, comments)
-      @index << @current_owner
-      @stack << name
-      @queue.prepend(node.body, LEAVE_EVENT)
-    end
-
-    sig { params(node: Prism::ClassNode).void }
-    def add_class_entry(node)
-      name = node.constant_path.location.slice
-
-      unless /^[A-Z:]/.match?(name)
-        @queue << node.body
-        return
-      end
-
-      comments = collect_comments(node)
-
-      superclass = node.superclass
-      parent_class = case superclass
-      when Prism::ConstantReadNode, Prism::ConstantPathNode
-        superclass.slice
-      end
-
-      @current_owner = Entry::Class.new(
-        fully_qualify_name(name),
-        @file_path,
-        node.location,
-        comments,
-        parent_class,
-      )
-      @index << @current_owner
-      @stack << name
-      @queue.prepend(node.body, LEAVE_EVENT)
-    end
-
     sig { params(node: Prism::Node).returns(T::Array[String]) }
     def collect_comments(node)
       comments = []
@@ -350,24 +354,17 @@ module RubyIndexer
 
         next unless name && loc
 
-        @index << Entry::Accessor.new(name, @file_path, loc, comments, @current_owner) if reader
-        @index << Entry::Accessor.new("#{name}=", @file_path, loc, comments, @current_owner) if writer
+        @index << Entry::Accessor.new(name, @file_path, loc, comments, @owner_stack.last) if reader
+        @index << Entry::Accessor.new("#{name}=", @file_path, loc, comments, @owner_stack.last) if writer
       end
     end
 
-    sig { params(node: Prism::CallNode).void }
-    def handle_include(node)
-      handle_module_operation(node, :included_modules)
-    end
-
-    sig { params(node: Prism::CallNode).void }
-    def handle_prepend(node)
-      handle_module_operation(node, :prepended_modules)
-    end
-
     sig { params(node: Prism::CallNode, operation: Symbol).void }
     def handle_module_operation(node, operation)
-      return unless @current_owner
+      return if @inside_def
+
+      owner = @owner_stack.last
+      return unless owner
 
       arguments = node.arguments&.arguments
       return unless arguments
@@ -381,7 +378,7 @@ module RubyIndexer
         # If a constant path reference is dynamic or missing parts, we can't
         # index it
       end
-      collection = operation == :included_modules ? @current_owner.included_modules : @current_owner.prepended_modules
+      collection = operation == :included_modules ? owner.included_modules : owner.prepended_modules
       collection.concat(names)
     end
   end

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

@@ -61,28 +61,13 @@ module RubyIndexer
       abstract!
 
       sig { returns(T::Array[String]) }
-      attr_accessor :included_modules
-
-      sig { returns(T::Array[String]) }
-      attr_accessor :prepended_modules
-
-      sig do
-        params(
-          name: String,
-          file_path: String,
-          location: T.any(Prism::Location, RubyIndexer::Location),
-          comments: T::Array[String],
-        ).void
-      end
-      def initialize(name, file_path, location, comments)
-        super(name, file_path, location, comments)
-        @included_modules = T.let([], T::Array[String])
-        @prepended_modules = T.let([], T::Array[String])
+      def included_modules
+        @included_modules ||= T.let([], T.nilable(T::Array[String]))
       end
 
-      sig { returns(String) }
-      def short_name
-        T.must(@name.split("::").last)
+      sig { returns(T::Array[String]) }
+      def prepended_modules
+        @prepended_modules ||= T.let([], T.nilable(T::Array[String]))
       end
     end
 

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

@@ -185,9 +185,11 @@ module RubyIndexer
     sig { params(indexable_path: IndexablePath, source: T.nilable(String)).void }
     def index_single(indexable_path, source = nil)
       content = source || File.read(indexable_path.full_path)
+      dispatcher = Prism::Dispatcher.new
+
       result = Prism.parse(content)
-      collector = Collector.new(self, result, indexable_path.full_path)
-      collector.collect(result.value)
+      DeclarationListener.new(self, dispatcher, result, indexable_path.full_path)
+      dispatcher.dispatch(result.value)
 
       require_path = indexable_path.require_path
       @require_paths_tree.insert(require_path, indexable_path) if require_path

data/lib/ruby_indexer/ruby_indexer.rb

@@ -5,7 +5,7 @@ require "yaml"
 require "did_you_mean"
 
 require "ruby_indexer/lib/ruby_indexer/indexable_path"
-require "ruby_indexer/lib/ruby_indexer/collector"
+require "ruby_indexer/lib/ruby_indexer/declaration_listener"
 require "ruby_indexer/lib/ruby_indexer/index"
 require "ruby_indexer/lib/ruby_indexer/entry"
 require "ruby_indexer/lib/ruby_indexer/configuration"

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -14,6 +14,15 @@ module RubyIndexer
       assert_entry("Foo", Entry::Class, "/fake/path/foo.rb:0-0:1-3")
     end
 
+    def test_conditional_class
+      index(<<~RUBY)
+        class Foo
+        end if condition
+      RUBY
+
+      assert_entry("Foo", Entry::Class, "/fake/path/foo.rb:0-0:1-3")
+    end
+
     def test_class_with_statements
       index(<<~RUBY)
         class Foo
@@ -60,7 +69,23 @@ module RubyIndexer
         end
       RUBY
 
+      assert_entry("self::Bar", Entry::Class, "/fake/path/foo.rb:0-0:1-3")
+    end
+
+    def test_dynamically_namespaced_class_doesnt_affect_other_classes
+      index(<<~RUBY)
+        class Foo
+          class self::Bar
+          end
+
+          class Bar
+          end
+        end
+      RUBY
+
       refute_entry("self::Bar")
+      assert_entry("Foo", Entry::Class, "/fake/path/foo.rb:0-0:6-3")
+      assert_entry("Foo::Bar", Entry::Class, "/fake/path/foo.rb:4-2:5-5")
     end
 
     def test_empty_statements_module
@@ -72,6 +97,15 @@ module RubyIndexer
       assert_entry("Foo", Entry::Module, "/fake/path/foo.rb:0-0:1-3")
     end
 
+    def test_conditional_module
+      index(<<~RUBY)
+        module Foo
+        end if condition
+      RUBY
+
+      assert_entry("Foo", Entry::Module, "/fake/path/foo.rb:0-0:1-3")
+    end
+
     def test_module_with_statements
       index(<<~RUBY)
         module Foo
@@ -106,7 +140,23 @@ module RubyIndexer
         end
       RUBY
 
-      refute_entry("self::Bar")
+      assert_entry("self::Bar", Entry::Module, "/fake/path/foo.rb:0-0:1-3")
+    end
+
+    def test_dynamically_namespaced_module_doesnt_affect_other_modules
+      index(<<~RUBY)
+        module Foo
+          class self::Bar
+          end
+
+          module Bar
+          end
+        end
+      RUBY
+
+      assert_entry("Foo::self::Bar", Entry::Class, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("Foo", Entry::Module, "/fake/path/foo.rb:0-0:6-3")
+      assert_entry("Foo::Bar", Entry::Module, "/fake/path/foo.rb:4-2:5-5")
     end
 
     def test_nested_modules_and_classes

data/lib/ruby_indexer/test/configuration_test.rb

@@ -20,6 +20,14 @@ module RubyIndexer
       assert(indexables.none? { |indexable| indexable.full_path == __FILE__ })
     end
 
+    def test_indexables_have_expanded_full_paths
+      @config.apply_config({ "included_patterns" => ["**/*.rb"] })
+      indexables = @config.indexables
+
+      # All paths should be expanded
+      assert(indexables.none? { |indexable| indexable.full_path.start_with?("lib/") })
+    end
+
     def test_indexables_only_includes_gem_require_paths
       indexables = @config.indexables
 

data/lib/ruby_indexer/test/constant_test.rb

@@ -12,10 +12,13 @@ module RubyIndexer
         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_or_writes