ruby-lsp 0.16.6 → 0.17.0

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

@@ -3,6 +3,14 @@
 
 module RubyIndexer
   class Entry
+    class Visibility < T::Enum
+      enums do
+        PUBLIC = new(:public)
+        PROTECTED = new(:protected)
+        PRIVATE = new(:private)
+      end
+    end
+
     extend T::Sig
 
     sig { returns(String) }
@@ -17,7 +25,7 @@ module RubyIndexer
     sig { returns(T::Array[String]) }
     attr_reader :comments
 
-    sig { returns(Symbol) }
+    sig { returns(Visibility) }
     attr_accessor :visibility
 
     sig do
@@ -32,7 +40,7 @@ module RubyIndexer
       @name = name
       @file_path = file_path
       @comments = comments
-      @visibility = T.let(:public, Symbol)
+      @visibility = T.let(Visibility::PUBLIC, Visibility)
 
       @location = T.let(
         if location.is_a?(Prism::Location)
@@ -49,11 +57,35 @@ module RubyIndexer
       )
     end
 
+    sig { returns(T::Boolean) }
+    def private?
+      visibility == Visibility::PRIVATE
+    end
+
     sig { returns(String) }
     def file_name
       File.basename(@file_path)
     end
 
+    class ModuleOperation
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { returns(String) }
+      attr_reader :module_name
+
+      sig { params(module_name: String).void }
+      def initialize(module_name)
+        @module_name = module_name
+      end
+    end
+
+    class Include < ModuleOperation; end
+    class Prepend < ModuleOperation; end
+    class Extend < ModuleOperation; end
+
     class Namespace < Entry
       extend T::Sig
       extend T::Helpers
@@ -61,13 +93,40 @@ module RubyIndexer
       abstract!
 
       sig { returns(T::Array[String]) }
-      def included_modules
-        @included_modules ||= T.let([], T.nilable(T::Array[String]))
+      attr_reader :nesting
+
+      sig do
+        params(
+          nesting: T::Array[String],
+          file_path: String,
+          location: T.any(Prism::Location, RubyIndexer::Location),
+          comments: T::Array[String],
+        ).void
+      end
+      def initialize(nesting, file_path, location, comments)
+        @name = T.let(nesting.join("::"), String)
+        # The original nesting where this namespace was discovered
+        @nesting = nesting
+
+        super(@name, file_path, location, comments)
       end
 
       sig { returns(T::Array[String]) }
-      def prepended_modules
-        @prepended_modules ||= T.let([], T.nilable(T::Array[String]))
+      def mixin_operation_module_names
+        mixin_operations.map(&:module_name)
+      end
+
+      # Stores all explicit prepend, include and extend operations in the exact order they were discovered in the source
+      # code. Maintaining the order is essential to linearize ancestors the right way when a module is both included
+      # and prepended
+      sig { returns(T::Array[ModuleOperation]) }
+      def mixin_operations
+        @mixin_operations ||= T.let([], T.nilable(T::Array[ModuleOperation]))
+      end
+
+      sig { returns(Integer) }
+      def ancestor_hash
+        mixin_operation_module_names.hash
       end
     end
 
@@ -84,17 +143,23 @@ module RubyIndexer
 
       sig do
         params(
-          name: String,
+          nesting: T::Array[String],
           file_path: String,
           location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T::Array[String],
           parent_class: T.nilable(String),
         ).void
       end
-      def initialize(name, file_path, location, comments, parent_class)
-        super(name, file_path, location, comments)
+      def initialize(nesting, file_path, location, comments, parent_class)
+        super(nesting, file_path, location, comments)
+
         @parent_class = T.let(parent_class, T.nilable(String))
       end
+
+      sig { override.returns(Integer) }
+      def ancestor_hash
+        [mixin_operation_module_names, @parent_class].hash
+      end
     end
 
     class Constant < Entry
@@ -188,11 +253,13 @@ module RubyIndexer
           file_path: String,
           location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T::Array[String],
+          visibility: Visibility,
           owner: T.nilable(Entry::Namespace),
         ).void
       end
-      def initialize(name, file_path, location, comments, owner)
+      def initialize(name, file_path, location, comments, visibility, owner) # rubocop:disable Metrics/ParameterLists
         super(name, file_path, location, comments)
+        @visibility = visibility
         @owner = owner
       end
 
@@ -227,11 +294,12 @@ module RubyIndexer
           location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T::Array[String],
           parameters_node: T.nilable(Prism::ParametersNode),
+          visibility: Visibility,
           owner: T.nilable(Entry::Namespace),
         ).void
       end
-      def initialize(name, file_path, location, comments, parameters_node, owner) # rubocop:disable Metrics/ParameterLists
-        super(name, file_path, location, comments, owner)
+      def initialize(name, file_path, location, comments, parameters_node, visibility, owner) # rubocop:disable Metrics/ParameterLists
+        super(name, file_path, location, comments, visibility, owner)
 
         @parameters = T.let(list_params(parameters_node), T::Array[Parameter])
       end
@@ -377,8 +445,29 @@ module RubyIndexer
       def initialize(target, unresolved_alias)
         super(unresolved_alias.name, unresolved_alias.file_path, unresolved_alias.location, unresolved_alias.comments)
 
+        @visibility = unresolved_alias.visibility
         @target = target
       end
     end
+
+    # Represents an instance variable e.g.: @a = 1
+    class InstanceVariable < Entry
+      sig { returns(T.nilable(Entry::Namespace)) }
+      attr_reader :owner
+
+      sig do
+        params(
+          name: String,
+          file_path: String,
+          location: T.any(Prism::Location, RubyIndexer::Location),
+          comments: T::Array[String],
+          owner: T.nilable(Entry::Namespace),
+        ).void
+      end
+      def initialize(name, file_path, location, comments, owner)
+        super(name, file_path, location, comments)
+        @owner = owner
+      end
+    end
   end
 end

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

@@ -6,6 +6,7 @@ module RubyIndexer
     extend T::Sig
 
     class UnresolvableAliasError < StandardError; end
+    class NonExistingNamespaceError < StandardError; end
 
     # The minimum Jaro-Winkler similarity score for an entry to be considered a match for a given fuzzy search query
     ENTRY_SIMILARITY_THRESHOLD = 0.7
@@ -31,6 +32,9 @@ module RubyIndexer
 
       # Holds all require paths for every indexed item so that we can provide autocomplete for requires
       @require_paths_tree = T.let(PrefixTree[IndexablePath].new, PrefixTree[IndexablePath])
+
+      # Holds the linearized ancestors list for every namespace
+      @ancestors = T.let({}, T::Hash[String, T::Array[String]])
     end
 
     sig { params(indexable: IndexablePath).void }
@@ -126,6 +130,16 @@ module RubyIndexer
       results.flat_map(&:first)
     end
 
+    sig { params(name: String, receiver_name: String).returns(T::Array[Entry]) }
+    def method_completion_candidates(name, receiver_name)
+      ancestors = linearized_ancestors_of(receiver_name)
+      candidates = prefix_search(name).flatten
+      candidates.select! do |entry|
+        entry.is_a?(RubyIndexer::Entry::Member) && ancestors.any?(entry.owner&.name)
+      end
+      candidates
+    end
+
     # Try to find the entry based on the nesting from the most specific to the least specific. For example, if we have
     # the nesting as ["Foo", "Bar"] and the name as "Baz", we will try to find it in this order:
     # 1. Foo::Bar::Baz
@@ -185,9 +199,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
@@ -243,16 +259,175 @@ module RubyIndexer
     sig { params(method_name: String, receiver_name: String).returns(T.nilable(T::Array[Entry::Member])) }
     def resolve_method(method_name, receiver_name)
       method_entries = self[method_name]
-      owner_entries = self[receiver_name]
-      return unless owner_entries && method_entries
-
-      owner_name = T.must(owner_entries.first).name
-      T.cast(
-        method_entries.grep(Entry::Member).select do |entry|
-          T.cast(entry, Entry::Member).owner&.name == owner_name
-        end,
-        T::Array[Entry::Member],
-      )
+      ancestors = linearized_ancestors_of(receiver_name.delete_prefix("::"))
+      return unless method_entries
+
+      ancestors.each do |ancestor|
+        found = method_entries.select do |entry|
+          next unless entry.is_a?(Entry::Member)
+
+          entry.owner&.name == ancestor
+        end
+
+        return T.cast(found, T::Array[Entry::Member]) if found.any?
+      end
+
+      nil
+    rescue NonExistingNamespaceError
+      nil
+    end
+
+    # Linearizes the ancestors for a given name, returning the order of namespaces in which Ruby will search for method
+    # or constant declarations.
+    #
+    # When we add an ancestor in Ruby, that namespace might have ancestors of its own. Therefore, we need to linearize
+    # everything recursively to ensure that we are placing ancestors in the right order. For example, if you include a
+    # module that prepends another module, then the prepend module appears before the included module.
+    #
+    # The order of ancestors is [linearized_prepends, self, linearized_includes, linearized_superclass]
+    sig { params(fully_qualified_name: String).returns(T::Array[String]) }
+    def linearized_ancestors_of(fully_qualified_name)
+      # If we already computed the ancestors for this namespace, return it straight away
+      cached_ancestors = @ancestors[fully_qualified_name]
+      return cached_ancestors if cached_ancestors
+
+      ancestors = [fully_qualified_name]
+
+      # Cache the linearized ancestors array eagerly. This is important because we might have circular dependencies and
+      # this will prevent us from falling into an infinite recursion loop. Because we mutate the ancestors array later,
+      # the cache will reflect the final result
+      @ancestors[fully_qualified_name] = ancestors
+
+      # If we don't have an entry for `name`, raise
+      entries = resolve(fully_qualified_name, [])
+      raise NonExistingNamespaceError, "No entry found for #{fully_qualified_name}" unless entries
+
+      # If none of the entries for `name` are namespaces, raise
+      namespaces = entries.filter_map do |entry|
+        case entry
+        when Entry::Namespace
+          entry
+        when Entry::Alias
+          self[entry.target]&.grep(Entry::Namespace)
+        end
+      end.flatten
+
+      raise NonExistingNamespaceError,
+        "None of the entries for #{fully_qualified_name} are modules or classes" if namespaces.empty?
+
+      mixin_operations = namespaces.flat_map(&:mixin_operations)
+      main_namespace_index = 0
+
+      # The original nesting where we discovered this namespace, so that we resolve the correct names of the
+      # included/prepended/extended modules and parent classes
+      nesting = T.must(namespaces.first).nesting
+
+      mixin_operations.each do |operation|
+        resolved_module = resolve(operation.module_name, nesting)
+        next unless resolved_module
+
+        module_fully_qualified_name = T.must(resolved_module.first).name
+
+        case operation
+        when Entry::Prepend
+          # When a module is prepended, Ruby checks if it hasn't been prepended already to prevent adding it in front of
+          # the actual namespace twice. However, it does not check if it has been included because you are allowed to
+          # prepend the same module after it has already been included
+          linearized_prepends = linearized_ancestors_of(module_fully_qualified_name)
+
+          # When there are duplicate prepended modules, we have to insert the new prepends after the existing ones. For
+          # example, if the current ancestors are `["A", "Foo"]` and we try to prepend `["A", "B"]`, then `"B"` has to
+          # be inserted after `"A`
+          uniq_prepends = linearized_prepends - T.must(ancestors[0...main_namespace_index])
+          insert_position = linearized_prepends.length - uniq_prepends.length
+
+          T.unsafe(ancestors).insert(
+            insert_position,
+            *(linearized_prepends - T.must(ancestors[0...main_namespace_index])),
+          )
+
+          main_namespace_index += linearized_prepends.length
+        when Entry::Include
+          # When including a module, Ruby will always prevent duplicate entries in case the module has already been
+          # prepended or included
+          linearized_includes = linearized_ancestors_of(module_fully_qualified_name)
+          T.unsafe(ancestors).insert(main_namespace_index + 1, *(linearized_includes - ancestors))
+        end
+      end
+
+      # Find the first class entry that has a parent class. Notice that if the developer makes a mistake and inherits
+      # from two diffent classes in different files, we simply ignore it
+      superclass = T.cast(namespaces.find { |n| n.is_a?(Entry::Class) && n.parent_class }, T.nilable(Entry::Class))
+
+      if superclass
+        # If the user makes a mistake and creates a class that inherits from itself, this method would throw a stack
+        # error. We need to ensure that this isn't the case
+        parent_class = T.must(superclass.parent_class)
+
+        resolved_parent_class = resolve(parent_class, nesting)
+        parent_class_name = resolved_parent_class&.first&.name
+
+        if parent_class_name && fully_qualified_name != parent_class_name
+          ancestors.concat(linearized_ancestors_of(parent_class_name))
+        end
+      end
+
+      ancestors
+    end
+
+    # Resolves an instance variable name for a given owner name. This method will linearize the ancestors of the owner
+    # and find inherited instance variables as well
+    sig { params(variable_name: String, owner_name: String).returns(T.nilable(T::Array[Entry::InstanceVariable])) }
+    def resolve_instance_variable(variable_name, owner_name)
+      entries = T.cast(self[variable_name], T.nilable(T::Array[Entry::InstanceVariable]))
+      return unless entries
+
+      ancestors = linearized_ancestors_of(owner_name)
+      return if ancestors.empty?
+
+      entries.select { |e| ancestors.include?(e.owner&.name) }
+    end
+
+    # Returns a list of possible candidates for completion of instance variables for a given owner name. The name must
+    # include the `@` prefix
+    sig { params(name: String, owner_name: String).returns(T::Array[Entry::InstanceVariable]) }
+    def instance_variable_completion_candidates(name, owner_name)
+      entries = T.cast(prefix_search(name).flatten, T::Array[Entry::InstanceVariable])
+      ancestors = linearized_ancestors_of(owner_name)
+
+      variables = entries.uniq(&:name)
+      variables.select! { |e| ancestors.any?(e.owner&.name) }
+      variables
+    end
+
+    # Synchronizes a change made to the given indexable path. This method will ensure that new declarations are indexed,
+    # removed declarations removed and that the ancestor linearization cache is cleared if necessary
+    sig { params(indexable: IndexablePath).void }
+    def handle_change(indexable)
+      original_entries = @files_to_entries[indexable.full_path]
+
+      delete(indexable)
+      index_single(indexable)
+
+      updated_entries = @files_to_entries[indexable.full_path]
+
+      return unless original_entries && updated_entries
+
+      # A change in one ancestor may impact several different others, which could be including that ancestor through
+      # indirect means like including a module that than includes the ancestor. Trying to figure out exactly which
+      # ancestors need to be deleted is too expensive. Therefore, if any of the namespace entries has a change to their
+      # ancestor hash, we clear all ancestors and start linearizing lazily again from scratch
+      original_map = T.cast(
+        original_entries.select { |e| e.is_a?(Entry::Namespace) },
+        T::Array[Entry::Namespace],
+      ).to_h { |e| [e.name, e.ancestor_hash] }
+
+      updated_map = T.cast(
+        updated_entries.select { |e| e.is_a?(Entry::Namespace) },
+        T::Array[Entry::Namespace],
+      ).to_h { |e| [e.name, e.ancestor_hash] }
+
+      @ancestors.clear if original_map.any? { |name, hash| updated_map[name] != hash }
     end
 
     private

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
@@ -240,13 +290,13 @@ module RubyIndexer
       RUBY
 
       b_const = @index["A::B"].first
-      assert_equal(:private, b_const.visibility)
+      assert_equal(Entry::Visibility::PRIVATE, b_const.visibility)
 
       c_const = @index["A::C"].first
-      assert_equal(:private, c_const.visibility)
+      assert_equal(Entry::Visibility::PRIVATE, c_const.visibility)
 
       d_const = @index["A::D"].first
-      assert_equal(:public, d_const.visibility)
+      assert_equal(Entry::Visibility::PUBLIC, d_const.visibility)
     end
 
     def test_keeping_track_of_super_classes
@@ -319,13 +369,13 @@ module RubyIndexer
       RUBY
 
       foo = T.must(@index["Foo"][0])
-      assert_equal(["A1", "A2", "A3", "A4", "A5", "A6"], foo.included_modules)
+      assert_equal(["A1", "A2", "A3", "A4", "A5", "A6"], foo.mixin_operation_module_names)
 
       qux = T.must(@index["Foo::Qux"][0])
-      assert_equal(["Corge", "Corge", "Baz"], qux.included_modules)
+      assert_equal(["Corge", "Corge", "Baz"], qux.mixin_operation_module_names)
 
       constant_path_references = T.must(@index["ConstantPathReferences"][0])
-      assert_equal(["Foo::Bar", "Foo::Bar2"], constant_path_references.included_modules)
+      assert_equal(["Foo::Bar", "Foo::Bar2"], constant_path_references.mixin_operation_module_names)
     end
 
     def test_keeping_track_of_prepended_modules
@@ -365,13 +415,59 @@ module RubyIndexer
       RUBY
 
       foo = T.must(@index["Foo"][0])
-      assert_equal(["A1", "A2", "A3", "A4", "A5", "A6"], foo.prepended_modules)
+      assert_equal(["A1", "A2", "A3", "A4", "A5", "A6"], foo.mixin_operation_module_names)
+
+      qux = T.must(@index["Foo::Qux"][0])
+      assert_equal(["Corge", "Corge", "Baz"], qux.mixin_operation_module_names)
+
+      constant_path_references = T.must(@index["ConstantPathReferences"][0])
+      assert_equal(["Foo::Bar", "Foo::Bar2"], constant_path_references.mixin_operation_module_names)
+    end
+
+    def test_keeping_track_of_extended_modules
+      index(<<~RUBY)
+        class Foo
+          # valid syntaxes that we can index
+          extend A1
+          self.extend A2
+          extend A3, A4
+          self.extend A5, A6
+
+          # valid syntaxes that we cannot index because of their dynamic nature
+          extend some_variable_or_method_call
+          self.extend some_variable_or_method_call
+
+          def something
+            extend A7 # We should not index this because of this dynamic nature
+          end
+
+          # Valid inner class syntax definition with its own modules prepended
+          class Qux
+            extend Corge
+            self.extend Corge
+            extend Baz
+
+            extend some_variable_or_method_call
+          end
+        end
+
+        class ConstantPathReferences
+          extend Foo::Bar
+          self.extend Foo::Bar2
+
+          extend dynamic::Bar
+          extend Foo::
+        end
+      RUBY
+
+      foo = T.must(@index["Foo"][0])
+      assert_equal(["A1", "A2", "A3", "A4", "A5", "A6"], foo.mixin_operation_module_names)
 
       qux = T.must(@index["Foo::Qux"][0])
-      assert_equal(["Corge", "Corge", "Baz"], qux.prepended_modules)
+      assert_equal(["Corge", "Corge", "Baz"], qux.mixin_operation_module_names)
 
       constant_path_references = T.must(@index["ConstantPathReferences"][0])
-      assert_equal(["Foo::Bar", "Foo::Bar2"], constant_path_references.prepended_modules)
+      assert_equal(["Foo::Bar", "Foo::Bar2"], constant_path_references.mixin_operation_module_names)
     end
   end
 end

data/lib/ruby_indexer/test/configuration_test.rb

@@ -68,12 +68,11 @@ module RubyIndexer
     end
 
     def test_indexables_avoids_duplicates_if_bundle_path_is_inside_project
-      Bundler.settings.set_global("path", "vendor/bundle")
-      config = Configuration.new
+      Bundler.settings.temporary(path: "vendor/bundle") do
+        config = Configuration.new
 
-      assert_includes(config.instance_variable_get(:@excluded_patterns), "#{Dir.pwd}/vendor/bundle/**/*.rb")
-    ensure
-      Bundler.settings.set_global("path", nil)
+        assert_includes(config.instance_variable_get(:@excluded_patterns), "#{Dir.pwd}/vendor/bundle/**/*.rb")
+      end
     end
 
     def test_indexables_does_not_include_gems_own_installed_files