ruby-lsp 0.17.1 → 0.17.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61194ff211ddd14d6598752e0a60409c16c2c5460c4d007ac1e1bc7e56b50116
-  data.tar.gz: 29ed28f4392929f09a4ba4ea6a19612f9dfc3e2c0b2641c551627ac69a32b3c0
+  metadata.gz: c02fa9ec776002a86f4eeee4037132d8b0f9403f101ccff5c7a31c46385a2818
+  data.tar.gz: 3b788794763cee273e2ce677955c3750ebac90962c8d328946f91998a900eca5
 SHA512:
-  metadata.gz: 56420391d81fe9e9c06a7fda2a04b1f99ac6fbb10211f064bfd65f36dd9148658d47743be437eb40240d5522786ec0566d0cea763b964630fb5ea67fe552687b
-  data.tar.gz: f760fad5d7abf0d0071badf6dd04f82e2266a64b0122d3a08cd5c3c799be15e377c94da93a4e8164e1f6ae04350e5ca05b16afbb7a8e341a8e80590053728ed7
+  metadata.gz: e3e152e24d1dca4aca721537f64df9062ae48aeea65b361ffd80dc6710cd263b0e8d1181f970b6d06e6147882c1cad40ba91d25ef6f684e2f5374a9738e1fae9
+  data.tar.gz: 79c3eb785ac55de19c4e9031ed6c8ca0a9a6df27156244ba7ee3ca2109659f8f2b9ce6efe7259cfcd65922a0b8cefc384fca2215dbdffac41735d9149db651a0

data/README.md

@@ -48,6 +48,8 @@ If using VS Code, all you have to do is install the [Ruby LSP
 extension](https://marketplace.visualstudio.com/items?itemName=Shopify.ruby-lsp) to get the extra features in the
 editor. Do not install the `ruby-lsp` gem manually.
 
+For more information on using and configuring the extension, see [vscode/README.md](vscode/README.md).
+
 ### With other editors
 
 See [editors](EDITORS.md) for community instructions on setting up the Ruby LSP, which current includes Emacs, Neovim, Sublime Text, and Zed.

data/VERSION

@@ -1 +1 @@
-0.17.1
+0.17.3

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -52,6 +52,7 @@ module RubyIndexer
         :on_instance_variable_operator_write_node_enter,
         :on_instance_variable_or_write_node_enter,
         :on_instance_variable_target_node_enter,
+        :on_alias_method_node_enter,
       )
     end
 
@@ -66,6 +67,8 @@ module RubyIndexer
       parent_class = case superclass
       when Prism::ConstantReadNode, Prism::ConstantPathNode
         superclass.slice
+      else
+        "::Object"
       end
 
       nesting = name.start_with?("::") ? [name.delete_prefix("::")] : @stack + [name.delete_prefix("::")]
@@ -209,6 +212,8 @@ module RubyIndexer
         handle_attribute(node, reader: false, writer: true)
       when :attr_accessor
         handle_attribute(node, reader: true, writer: true)
+      when :alias_method
+        handle_alias_method(node)
       when :include, :prepend, :extend
         handle_module_operation(node, message)
       when :public
@@ -338,6 +343,20 @@ module RubyIndexer
       )
     end
 
+    sig { params(node: Prism::AliasMethodNode).void }
+    def on_alias_method_node_enter(node)
+      method_name = node.new_name.slice
+      comments = collect_comments(node)
+      @index << Entry::UnresolvedMethodAlias.new(
+        method_name,
+        node.old_name.slice,
+        @owner_stack.last,
+        @file_path,
+        node.new_name.location,
+        comments,
+      )
+    end
+
     private
 
     sig { params(node: Prism::CallNode).void }
@@ -365,6 +384,43 @@ module RubyIndexer
       entries&.each { |entry| entry.visibility = Entry::Visibility::PRIVATE }
     end
 
+    sig { params(node: Prism::CallNode).void }
+    def handle_alias_method(node)
+      arguments = node.arguments&.arguments
+      return unless arguments
+
+      new_name, old_name = arguments
+      return unless new_name && old_name
+
+      new_name_value = case new_name
+      when Prism::StringNode
+        new_name.content
+      when Prism::SymbolNode
+        new_name.value
+      end
+
+      return unless new_name_value
+
+      old_name_value = case old_name
+      when Prism::StringNode
+        old_name.content
+      when Prism::SymbolNode
+        old_name.value
+      end
+
+      return unless old_name_value
+
+      comments = collect_comments(node)
+      @index << Entry::UnresolvedMethodAlias.new(
+        new_name_value,
+        old_name_value,
+        @owner_stack.last,
+        @file_path,
+        new_name.location,
+        comments,
+      )
+    end
+
     sig do
       params(
         node: T.any(

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

@@ -469,5 +469,33 @@ module RubyIndexer
         @owner = owner
       end
     end
+
+    class UnresolvedMethodAlias < Entry
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :new_name, :old_name
+
+      sig { returns(T.nilable(Entry::Namespace)) }
+      attr_reader :owner
+
+      sig do
+        params(
+          new_name: String,
+          old_name: String,
+          owner: T.nilable(Entry::Namespace),
+          file_path: String,
+          location: Prism::Location,
+          comments: T::Array[String],
+        ).void
+      end
+      def initialize(new_name, old_name, owner, file_path, location, comments) # rubocop:disable Metrics/ParameterLists
+        super(new_name, file_path, location, comments)
+
+        @new_name = new_name
+        @old_name = old_name
+        @owner = owner
+      end
+    end
   end
 end

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

@@ -140,35 +140,48 @@ module RubyIndexer
       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
-    # 2. Foo::Baz
-    # 3. Baz
-    sig { params(name: String, nesting: T::Array[String]).returns(T.nilable(T::Array[Entry])) }
-    def resolve(name, nesting)
+    # Resolve a constant to its declaration based on its name and the nesting where the reference was found. Parameter
+    # documentation:
+    #
+    # name: the name of the reference how it was found in the source code (qualified or not)
+    # nesting: the nesting structure where the reference was found (e.g.: ["Foo", "Bar"])
+    # seen_names: this parameter should not be used by consumers of the api. It is used to avoid infinite recursion when
+    # resolving circular references
+    sig do
+      params(
+        name: String,
+        nesting: T::Array[String],
+        seen_names: T::Array[String],
+      ).returns(T.nilable(T::Array[Entry]))
+    end
+    def resolve(name, nesting, seen_names = [])
+      # If we have a top level reference, then we just search for it straight away ignoring the nesting
       if name.start_with?("::")
-        name = name.delete_prefix("::")
-        results = @entries[name] || @entries[follow_aliased_namespace(name)]
-        return results&.map { |e| e.is_a?(Entry::UnresolvedAlias) ? resolve_alias(e) : e }
+        entries = direct_or_aliased_constant(name.delete_prefix("::"), seen_names)
+        return entries if entries
       end
 
-      nesting.length.downto(0).each do |i|
-        namespace = T.must(nesting[0...i]).join("::")
-        full_name = namespace.empty? ? name : "#{namespace}::#{name}"
+      # Non qualified reference path
+      full_name = nesting.any? ? "#{nesting.join("::")}::#{name}" : name
 
-        # If we find an entry with `full_name` directly, then we can already return it, even if it contains aliases -
-        # because the user might be trying to jump to the alias definition.
-        #
-        # However, if we don't find it, then we need to search for possible aliases in the namespace. For example, in
-        # the LSP itself we alias `RubyLsp::Interface` to `LanguageServer::Protocol::Interface`, which means doing
-        # `RubyLsp::Interface::Location` is allowed. For these cases, we need some way to realize that the
-        # `RubyLsp::Interface` part is an alias, that has to be resolved
-        entries = @entries[full_name] || @entries[follow_aliased_namespace(full_name)]
-        return entries.map { |e| e.is_a?(Entry::UnresolvedAlias) ? resolve_alias(e) : e } if entries
-      end
+      # When the name is not qualified with any namespaces, Ruby will take several steps to try to the resolve the
+      # constant. First, it will try to find the constant in the exact namespace where the reference was found
+      entries = direct_or_aliased_constant(full_name, seen_names)
+      return entries if entries
 
-      nil
+      # If the constant is not found yet, then Ruby will try to find the constant in the enclosing lexical scopes,
+      # unwrapping each level one by one. Important note: the top level is not included because that's the fallback of
+      # the algorithm after every other possibility has been exhausted
+      entries = lookup_enclosing_scopes(name, nesting, seen_names)
+      return entries if entries
+
+      # If the constant does not exist in any enclosing scopes, then Ruby will search for it in the ancestors of the
+      # specific namespace where the reference was found
+      entries = lookup_ancestor_chain(name, nesting, seen_names)
+      return entries if entries
+
+      # Finally, as a fallback, Ruby will search for the constant in the top level namespace
+      search_top_level(name, seen_names)
     rescue UnresolvableAliasError
       nil
     end
@@ -222,8 +235,8 @@ module RubyIndexer
     # If we find an alias, then we want to follow its target. In the same example, if `Foo::Bar` is an alias to
     # `Something::Else`, then we first discover `Something::Else::Baz`. But `Something::Else::Baz` might contain other
     # aliases, so we have to invoke `follow_aliased_namespace` again to check until we only return a real name
-    sig { params(name: String).returns(String) }
-    def follow_aliased_namespace(name)
+    sig { params(name: String, seen_names: T::Array[String]).returns(String) }
+    def follow_aliased_namespace(name, seen_names = [])
       return name if @entries[name]
 
       parts = name.split("::")
@@ -236,16 +249,16 @@ module RubyIndexer
         case entry
         when Entry::Alias
           target = entry.target
-          return follow_aliased_namespace("#{target}::#{real_parts.join("::")}")
+          return follow_aliased_namespace("#{target}::#{real_parts.join("::")}", seen_names)
         when Entry::UnresolvedAlias
-          resolved = resolve_alias(entry)
+          resolved = resolve_alias(entry, seen_names)
 
           if resolved.is_a?(Entry::UnresolvedAlias)
             raise UnresolvableAliasError, "The constant #{resolved.name} is an alias to a non existing constant"
           end
 
           target = resolved.target
-          return follow_aliased_namespace("#{target}::#{real_parts.join("::")}")
+          return follow_aliased_namespace("#{target}::#{real_parts.join("::")}", seen_names)
         else
           real_parts.unshift(T.must(parts[i]))
         end
@@ -291,6 +304,10 @@ module RubyIndexer
       cached_ancestors = @ancestors[fully_qualified_name]
       return cached_ancestors if cached_ancestors
 
+      # If we don't have an entry for `name`, raise
+      entries = self[fully_qualified_name]
+      raise NonExistingNamespaceError, "No entry found for #{fully_qualified_name}" unless entries
+
       ancestors = [fully_qualified_name]
 
       # Cache the linearized ancestors array eagerly. This is important because we might have circular dependencies and
@@ -298,10 +315,6 @@ module RubyIndexer
       # 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
@@ -395,8 +408,8 @@ module RubyIndexer
       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 = entries.select { |e| ancestors.any?(e.owner&.name) }
+      variables.uniq!(&:name)
       variables
     end
 
@@ -434,22 +447,125 @@ module RubyIndexer
 
     # Attempts to resolve an UnresolvedAlias into a resolved Alias. If the unresolved alias is pointing to a constant
     # that doesn't exist, then we return the same UnresolvedAlias
-    sig { params(entry: Entry::UnresolvedAlias).returns(T.any(Entry::Alias, Entry::UnresolvedAlias)) }
-    def resolve_alias(entry)
-      target = resolve(entry.target, entry.nesting)
+    sig do
+      params(
+        entry: Entry::UnresolvedAlias,
+        seen_names: T::Array[String],
+      ).returns(T.any(Entry::Alias, Entry::UnresolvedAlias))
+    end
+    def resolve_alias(entry, seen_names)
+      alias_name = entry.name
+      return entry if seen_names.include?(alias_name)
+
+      seen_names << alias_name
+
+      target = resolve(entry.target, entry.nesting, seen_names)
       return entry unless target
 
       target_name = T.must(target.first).name
       resolved_alias = Entry::Alias.new(target_name, entry)
 
       # Replace the UnresolvedAlias by a resolved one so that we don't have to do this again later
-      original_entries = T.must(@entries[entry.name])
+      original_entries = T.must(@entries[alias_name])
       original_entries.delete(entry)
       original_entries << resolved_alias
 
-      @entries_tree.insert(entry.name, original_entries)
+      @entries_tree.insert(alias_name, original_entries)
 
       resolved_alias
     end
+
+    sig do
+      params(
+        name: String,
+        nesting: T::Array[String],
+        seen_names: T::Array[String],
+      ).returns(T.nilable(T::Array[Entry]))
+    end
+    def lookup_enclosing_scopes(name, nesting, seen_names)
+      nesting.length.downto(1).each do |i|
+        namespace = T.must(nesting[0...i]).join("::")
+
+        # If we find an entry with `full_name` directly, then we can already return it, even if it contains aliases -
+        # because the user might be trying to jump to the alias definition.
+        #
+        # However, if we don't find it, then we need to search for possible aliases in the namespace. For example, in
+        # the LSP itself we alias `RubyLsp::Interface` to `LanguageServer::Protocol::Interface`, which means doing
+        # `RubyLsp::Interface::Location` is allowed. For these cases, we need some way to realize that the
+        # `RubyLsp::Interface` part is an alias, that has to be resolved
+        entries = direct_or_aliased_constant("#{namespace}::#{name}", seen_names)
+        return entries if entries
+      end
+
+      nil
+    end
+
+    sig do
+      params(
+        name: String,
+        nesting: T::Array[String],
+        seen_names: T::Array[String],
+      ).returns(T.nilable(T::Array[Entry]))
+    end
+    def lookup_ancestor_chain(name, nesting, seen_names)
+      *nesting_parts, constant_name = build_non_redundant_full_name(name, nesting).split("::")
+      return if T.must(nesting_parts).empty?
+
+      namespace_entries = resolve(T.must(nesting_parts).join("::"), [], seen_names)
+      return unless namespace_entries
+
+      ancestors = T.must(nesting_parts).empty? ? [] : linearized_ancestors_of(T.must(namespace_entries.first).name)
+
+      ancestors.each do |ancestor_name|
+        entries = direct_or_aliased_constant("#{ancestor_name}::#{constant_name}", seen_names)
+        return entries if entries
+      end
+
+      nil
+    rescue NonExistingNamespaceError
+      nil
+    end
+
+    # Removes redudancy from a constant reference's full name. For example, if we find a reference to `A::B::Foo` inside
+    # of the ["A", "B"] nesting, then we should not concatenate the nesting with the name or else we'll end up with
+    # `A::B::A::B::Foo`. This method will remove any redundant parts from the final name based on the reference and the
+    # nesting
+    sig { params(name: String, nesting: T::Array[String]).returns(String) }
+    def build_non_redundant_full_name(name, nesting)
+      return name if nesting.empty?
+
+      namespace = nesting.join("::")
+
+      # If the name is not qualified, we can just concatenate the nesting and the name
+      return "#{namespace}::#{name}" unless name.include?("::")
+
+      name_parts = name.split("::")
+
+      # Find the first part of the name that is not in the nesting
+      index = name_parts.index { |part| !nesting.include?(part) }
+
+      if index.nil?
+        # All parts of the nesting are redundant because they are already present in the name. We can return the name
+        # directly
+        name
+      elsif index == 0
+        # No parts of the nesting are in the name, we can concatenate the namespace and the name
+        "#{namespace}::#{name}"
+      else
+        # The name includes some parts of the nesting. We need to remove the redundant parts
+        "#{namespace}::#{T.must(name_parts[index..-1]).join("::")}"
+      end
+    end
+
+    sig { params(full_name: String, seen_names: T::Array[String]).returns(T.nilable(T::Array[Entry])) }
+    def direct_or_aliased_constant(full_name, seen_names)
+      entries = @entries[full_name] || @entries[follow_aliased_namespace(full_name)]
+      entries&.map { |e| e.is_a?(Entry::UnresolvedAlias) ? resolve_alias(e, seen_names) : e }
+    end
+
+    sig { params(name: String, seen_names: T::Array[String]).returns(T.nilable(T::Array[Entry])) }
+    def search_top_level(name, seen_names)
+      @entries[name]&.map { |e| e.is_a?(Entry::UnresolvedAlias) ? resolve_alias(e, seen_names) : e }
+    end
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb

@@ -0,0 +1,99 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyIndexer
+  class RBSIndexer
+    extend T::Sig
+
+    sig { params(index: Index).void }
+    def initialize(index)
+      @index = index
+    end
+
+    sig { void }
+    def index_ruby_core
+      loader = RBS::EnvironmentLoader.new
+      RBS::Environment.from_loader(loader).resolve_type_names
+
+      loader.each_signature do |source, pathname, _buffer, declarations, _directives|
+        process_signature(source, pathname, declarations)
+      end
+    end
+
+    private
+
+    sig { params(source: T.untyped, pathname: Pathname, declarations: T::Array[RBS::AST::Declarations::Base]).void }
+    def process_signature(source, pathname, declarations)
+      declarations.each do |declaration|
+        process_declaration(declaration, pathname)
+      end
+    end
+
+    sig { params(declaration: RBS::AST::Declarations::Base, pathname: Pathname).void }
+    def process_declaration(declaration, pathname)
+      case declaration
+      when RBS::AST::Declarations::Class
+        handle_class_declaration(declaration, pathname)
+      when RBS::AST::Declarations::Module
+        handle_module_declaration(declaration, pathname)
+      else # rubocop:disable Style/EmptyElse
+        # Other kinds not yet handled
+      end
+    end
+
+    sig { params(declaration: RBS::AST::Declarations::Class, pathname: Pathname).void }
+    def handle_class_declaration(declaration, pathname)
+      nesting = [declaration.name.name.to_s]
+      file_path = pathname.to_s
+      location = to_ruby_indexer_location(declaration.location)
+      comments = Array(declaration.comment&.string)
+      parent_class = declaration.super_class&.name&.name&.to_s
+      class_entry = Entry::Class.new(nesting, file_path, location, comments, parent_class)
+      add_declaration_mixins_to_entry(declaration, class_entry)
+      @index << class_entry
+    end
+
+    sig { params(declaration: RBS::AST::Declarations::Module, pathname: Pathname).void }
+    def handle_module_declaration(declaration, pathname)
+      nesting = [declaration.name.name.to_s]
+      file_path = pathname.to_s
+      location = to_ruby_indexer_location(declaration.location)
+      comments = Array(declaration.comment&.string)
+      module_entry = Entry::Module.new(nesting, file_path, location, comments)
+      add_declaration_mixins_to_entry(declaration, module_entry)
+      @index << module_entry
+    end
+
+    sig { params(rbs_location: RBS::Location).returns(RubyIndexer::Location) }
+    def to_ruby_indexer_location(rbs_location)
+      RubyIndexer::Location.new(
+        rbs_location.start_line,
+        rbs_location.end_line,
+        rbs_location.start_column,
+        rbs_location.end_column,
+      )
+    end
+
+    sig do
+      params(
+        declaration: T.any(RBS::AST::Declarations::Class, RBS::AST::Declarations::Module),
+        entry: Entry::Namespace,
+      ).void
+    end
+    def add_declaration_mixins_to_entry(declaration, entry)
+      declaration.each_mixin do |mixin|
+        name = mixin.name.name.to_s
+        mixin_operation =
+          case mixin
+          when RBS::AST::Members::Include
+            Entry::Include.new(name)
+          when RBS::AST::Members::Extend
+            Entry::Extend.new(name)
+          when RBS::AST::Members::Prepend
+            Entry::Prepend.new(name)
+          end
+        entry.mixin_operations << mixin_operation if mixin_operation
+      end
+    end
+  end
+end

data/lib/ruby_indexer/ruby_indexer.rb

@@ -11,6 +11,7 @@ require "ruby_indexer/lib/ruby_indexer/entry"
 require "ruby_indexer/lib/ruby_indexer/configuration"
 require "ruby_indexer/lib/ruby_indexer/prefix_tree"
 require "ruby_indexer/lib/ruby_indexer/location"
+require "ruby_indexer/lib/ruby_indexer/rbs_indexer"
 
 module RubyIndexer
   @configuration = T.let(Configuration.new, Configuration)

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -191,7 +191,8 @@ module RubyIndexer
 
       @index.delete(IndexablePath.new(nil, "/fake/path/foo.rb"))
       refute_entry("Foo")
-      assert_empty(@index.instance_variable_get(:@files_to_entries))
+
+      assert_no_indexed_entries
     end
 
     def test_comments_can_be_attached_to_a_class
@@ -323,7 +324,7 @@ module RubyIndexer
       assert_equal("Bar", foo.parent_class)
 
       baz = T.must(@index["Baz"].first)
-      assert_nil(baz.parent_class)
+      assert_equal("::Object", baz.parent_class)
 
       qux = T.must(@index["Something::Qux"].first)
       assert_equal("::Baz", qux.parent_class)

data/lib/ruby_indexer/test/configuration_test.rb

@@ -54,7 +54,7 @@ module RubyIndexer
 
       assert_includes(indexables, "#{RbConfig::CONFIG["rubylibdir"]}/pathname.rb")
       assert_includes(indexables, "#{RbConfig::CONFIG["rubylibdir"]}/ipaddr.rb")
-      assert_includes(indexables, "#{RbConfig::CONFIG["rubylibdir"]}/abbrev.rb")
+      assert_includes(indexables, "#{RbConfig::CONFIG["rubylibdir"]}/erb.rb")
     end
 
     def test_indexables_includes_project_files

data/lib/ruby_indexer/test/constant_test.rb

@@ -105,7 +105,7 @@ module RubyIndexer
         self.class::FOO = 1
       RUBY
 
-      assert_no_entries
+      assert_no_indexed_entries
     end
 
     def test_private_constant_indexing