ruby-lsp 0.27.0.beta2 → 0.27.0.beta4

data/lib/ruby_lsp/type_inferrer.rb

@@ -20,13 +20,67 @@ module RubyLsp
       when Prism::InstanceVariableReadNode, Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableWriteNode,
         Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableTargetNode,
         Prism::SuperNode, Prism::ForwardingSuperNode, Prism::DefNode
-        self_receiver_handling(node_context)
+        infer_self_type(node_context)
       when Prism::ClassVariableAndWriteNode, Prism::ClassVariableWriteNode, Prism::ClassVariableOperatorWriteNode,
         Prism::ClassVariableOrWriteNode, Prism::ClassVariableReadNode, Prism::ClassVariableTargetNode
         infer_receiver_for_class_variables(node_context)
       end
     end
 
+    # Infers the type of `self` in the given context. Unlike `infer_receiver_type`, this does not depend on the node
+    # being completed — it's derived purely from the lexical nesting and the surrounding method's receiver. This matters
+    # because methods and instance variables are attached to the type of `self`, which doesn't always match the lexical
+    # scope (e.g. inside `def self.foo` or a class/module body).
+    #
+    #: (NodeContext node_context) -> Type?
+    def infer_self_type(node_context)
+      nesting = node_context.nesting
+      # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
+      # inherits from Object
+      return Type.new("Object") if nesting.empty?
+
+      surrounding_method = node_context.surrounding_method
+
+      if surrounding_method
+        receiver_name = surrounding_method.receiver
+
+        case receiver_name
+        when "self"
+          # `def self.foo` — self is the singleton of the enclosing class/module
+          return resolve_singleton_type_from_nesting(nesting)
+        when "none"
+          # Instance method — self is an instance of the enclosing class/module
+          return resolve_type_from_nesting(nesting)
+        when nil
+          # Dynamic receiver that we cannot handle
+          return
+        else
+          # Explicit constant receiver (e.g. `def Bar.baz`) — self is that constant's singleton class
+          resolved = resolve_receiver_singleton_type(receiver_name, nesting)
+          return resolved if resolved
+
+          return resolve_type_from_nesting(nesting)
+        end
+      end
+
+      # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
+      # context. Resolve through the graph to get the correct fully qualified name
+      resolve_singleton_type_from_nesting(nesting)
+    end
+
+    # The type of `self`, which may or may not match the current lexical scope. For example, if we have `def Bar.foo` or
+    # if something else mutates the type
+    #
+    #: (NodeContext) -> String?
+    def self_receiver_name(node_context)
+      return if node_context.nesting.empty?
+
+      name = infer_self_type(node_context)&.name
+      return unless name
+
+      name if @graph[name]
+    end
+
     private
 
     #: (Prism::CallNode node, NodeContext node_context) -> Type?
@@ -49,7 +103,7 @@ module RubyLsp
 
       case receiver
       when Prism::SelfNode, nil
-        self_receiver_handling(node_context)
+        infer_self_type(node_context)
       when Prism::StringNode
         Type.new("String")
       when Prism::SymbolNode
@@ -78,7 +132,7 @@ module RubyLsp
         # When the receiver is a constant reference, we have to try to resolve it to figure out the right
         # receiver. But since the invocation is directly on the constant, that's the singleton context of that
         # class/module
-        receiver_name = RubyIndexer::Index.constant_name(receiver)
+        receiver_name = Requests::Support::Common.constant_name(receiver)
         return unless receiver_name
 
         resolved_receiver = @graph.resolve_constant(receiver_name, node_context.nesting)
@@ -124,47 +178,11 @@ module RubyLsp
 
       declaration = @graph.resolve_constant(guessed_name, nesting)
       declaration ||= @graph.search(guessed_name).first
-      return unless declaration
+      return unless declaration.is_a?(Rubydex::Namespace)
 
       GuessedType.new(declaration.name)
     end
 
-    #: (NodeContext node_context) -> Type?
-    def self_receiver_handling(node_context)
-      nesting = node_context.nesting
-      # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
-      # inherits from Object
-      return Type.new("Object") if nesting.empty?
-
-      surrounding_method = node_context.surrounding_method
-
-      if surrounding_method
-        receiver_name = surrounding_method.receiver
-
-        case receiver_name
-        when "self"
-          # `def self.foo` — self is the singleton of the enclosing class/module
-          return resolve_singleton_type_from_nesting(nesting)
-        when "none"
-          # Instance method — self is an instance of the enclosing class/module
-          return resolve_type_from_nesting(nesting)
-        when nil
-          # Dynamic receiver that we cannot handle
-          return
-        else
-          # Explicit constant receiver (e.g. `def Bar.baz`) — self is that constant's singleton class
-          resolved = resolve_receiver_singleton_type(receiver_name, nesting)
-          return resolved if resolved
-
-          return resolve_type_from_nesting(nesting)
-        end
-      end
-
-      # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
-      # context. Resolve through the graph to get the correct fully qualified name
-      resolve_singleton_type_from_nesting(nesting)
-    end
-
     # Resolves the fully qualified name of the innermost constant from the nesting and returns it as a type.
     # For instance methods, the nesting won't have singleton markers, so the result is an instance type.
     # For `def self.` methods, the nesting includes a singleton marker, which is preserved in the result.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.27.0.beta2
+  version: 0.27.0.beta4
 platform: ruby
 authors:
 - Shopify
@@ -67,16 +67,22 @@ dependencies:
   name: rubydex
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.7
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.1.0.beta1
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.7
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.1.0.beta1
+        version: 0.3.0
 description: An opinionated language server for Ruby
 email:
 - ruby@shopify.com
@@ -98,17 +104,6 @@ files:
 - lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb
 - lib/rubocop/cop/ruby_lsp/use_register_with_handler_method.rb
 - lib/ruby-lsp.rb
-- lib/ruby_indexer/lib/ruby_indexer/configuration.rb
-- lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb
-- lib/ruby_indexer/lib/ruby_indexer/enhancement.rb
-- lib/ruby_indexer/lib/ruby_indexer/entry.rb
-- lib/ruby_indexer/lib/ruby_indexer/index.rb
-- lib/ruby_indexer/lib/ruby_indexer/location.rb
-- lib/ruby_indexer/lib/ruby_indexer/prefix_tree.rb
-- lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb
-- lib/ruby_indexer/lib/ruby_indexer/uri.rb
-- lib/ruby_indexer/lib/ruby_indexer/visibility_scope.rb
-- lib/ruby_indexer/ruby_indexer.rb
 - lib/ruby_lsp/addon.rb
 - lib/ruby_lsp/base_server.rb
 - lib/ruby_lsp/client_capabilities.rb
@@ -184,6 +179,7 @@ files:
 - lib/ruby_lsp/rubydex/declaration.rb
 - lib/ruby_lsp/rubydex/definition.rb
 - lib/ruby_lsp/rubydex/reference.rb
+- lib/ruby_lsp/rubydex/signature.rb
 - lib/ruby_lsp/scope.rb
 - lib/ruby_lsp/scripts/compose_bundle.rb
 - lib/ruby_lsp/scripts/compose_bundle_windows.rb
@@ -195,6 +191,7 @@ files:
 - lib/ruby_lsp/test_reporters/minitest_reporter.rb
 - lib/ruby_lsp/test_reporters/test_unit_reporter.rb
 - lib/ruby_lsp/type_inferrer.rb
+- lib/ruby_lsp/uri.rb
 - lib/ruby_lsp/utils.rb
 homepage: https://github.com/Shopify/ruby-lsp
 licenses:
@@ -216,7 +213,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.10
 specification_version: 4
 summary: An opinionated language server for Ruby
 test_files: []

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

@@ -1,276 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyIndexer
-  class Configuration
-    CONFIGURATION_SCHEMA = {
-      "excluded_gems" => Array,
-      "included_gems" => Array,
-      "excluded_patterns" => Array,
-      "included_patterns" => Array,
-      "excluded_magic_comments" => Array,
-    }.freeze #: Hash[String, untyped]
-
-    #: String
-    attr_writer :workspace_path
-
-    #: Encoding
-    attr_accessor :encoding
-
-    #: -> void
-    def initialize
-      @workspace_path = Dir.pwd #: String
-      @encoding = Encoding::UTF_8 #: Encoding
-      @excluded_gems = initial_excluded_gems #: Array[String]
-      @included_gems = [] #: Array[String]
-
-      @excluded_patterns = [
-        "**/{test,spec}/**/{*_test.rb,test_*.rb,*_spec.rb}",
-        "**/fixtures/**/*",
-      ] #: Array[String]
-
-      path = Bundler.settings["path"]
-      if path
-        # Substitute Windows backslashes into forward slashes, which are used in glob patterns
-        glob = path.gsub(/[\\]+/, "/")
-        glob.delete_suffix!("/")
-        @excluded_patterns << "#{glob}/**/*.rb"
-      end
-
-      # We start the included patterns with only the non excluded directories so that we can avoid paying the price of
-      # traversing large directories that don't include Ruby files like `node_modules`
-      @included_patterns = ["{#{top_level_directories.join(",")}}/**/*.rb", "*.rb"] #: Array[String]
-      @excluded_magic_comments = [
-        "frozen_string_literal:",
-        "typed:",
-        "compiled:",
-        "encoding:",
-        "shareable_constant_value:",
-        "warn_indent:",
-        "rubocop:",
-        "nodoc:",
-        "doc:",
-        "coding:",
-        "warn_past_scope:",
-      ] #: Array[String]
-    end
-
-    #: -> Array[URI::Generic]
-    def indexable_uris
-      excluded_gems = @excluded_gems - @included_gems
-      locked_gems = Bundler.locked_gems&.specs
-
-      # NOTE: indexing the patterns (both included and excluded) needs to happen before indexing gems, otherwise we risk
-      # having duplicates if BUNDLE_PATH is set to a folder inside the project structure
-
-      flags = File::FNM_PATHNAME | File::FNM_EXTGLOB
-
-      uris = @included_patterns.flat_map do |pattern|
-        load_path_entry = nil #: String?
-
-        Dir.glob(File.join(@workspace_path, pattern), flags).map! do |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 current
-          # workspace directory, but each one of them belongs to a different $LOAD_PATH entry
-          if load_path_entry.nil? || !path.start_with?(load_path_entry)
-            load_path_entry = $LOAD_PATH.find { |load_path| path.start_with?(load_path) }
-          end
-
-          URI::Generic.from_path(path: path, load_path_entry: load_path_entry)
-        end
-      end
-
-      # If the patterns are relative, we make it relative to the workspace path. If they are absolute, then we shouldn't
-      # concatenate anything
-      excluded_patterns = @excluded_patterns.map do |pattern|
-        if File.absolute_path?(pattern)
-          pattern
-        else
-          File.join(@workspace_path, pattern)
-        end
-      end
-
-      # Remove user specified patterns
-      bundle_path = Bundler.settings["path"]&.gsub(/[\\]+/, "/")
-      uris.reject! do |indexable|
-        path = indexable.full_path #: as !nil
-        next false if test_files_ignored_from_exclusion?(path, bundle_path)
-
-        excluded_patterns.any? { |pattern| File.fnmatch?(pattern, path, flags) }
-      end
-
-      # Add default gems to the list of files to be indexed
-      Dir.glob(File.join(RbConfig::CONFIG["rubylibdir"], "*")).each do |default_path|
-        # The default_path might be a Ruby file or a folder with the gem's name. For example:
-        #   bundler/
-        #   bundler.rb
-        #   psych/
-        #   psych.rb
-        pathname = Pathname.new(default_path)
-        short_name = pathname.basename.to_s.delete_suffix(".rb")
-
-        # If the gem name is excluded, then we skip it
-        next if excluded_gems.include?(short_name)
-
-        # If the default gem is also a part of the bundle, we skip indexing the default one and index only the one in
-        # the bundle, which won't be in `default_path`, but will be in `Bundler.bundle_path` instead
-        next if locked_gems&.any? do |locked_spec|
-          locked_spec.name == short_name &&
-            !Gem::Specification.find_by_name(short_name).full_gem_path.start_with?(RbConfig::CONFIG["rubylibprefix"])
-        rescue Gem::MissingSpecError
-          # If a default gem is scoped to a specific platform, then `find_by_name` will raise. We want to skip those
-          # cases
-          true
-        end
-
-        if pathname.directory?
-          # If the default_path is a directory, we index all the Ruby files in it
-          uris.concat(
-            Dir.glob(File.join(default_path, "**", "*.rb"), File::FNM_PATHNAME | File::FNM_EXTGLOB).map! do |path|
-              URI::Generic.from_path(path: path, load_path_entry: RbConfig::CONFIG["rubylibdir"])
-            end,
-          )
-        elsif pathname.extname == ".rb"
-          # If the default_path is a Ruby file, we index it
-          uris << URI::Generic.from_path(path: default_path, load_path_entry: RbConfig::CONFIG["rubylibdir"])
-        end
-      end
-
-      # Add the locked gems to the list of files to be indexed
-      locked_gems&.each do |lazy_spec|
-        next if excluded_gems.include?(lazy_spec.name)
-
-        spec = Gem::Specification.find_by_name(lazy_spec.name)
-
-        # When working on a gem, it will be included in the locked_gems list. Since these are the project's own files,
-        # we have already included and handled exclude patterns for it and should not re-include or it'll lead to
-        # duplicates or accidentally ignoring exclude patterns
-        next if spec.full_gem_path == @workspace_path
-
-        uris.concat(
-          spec.require_paths.flat_map do |require_path|
-            load_path_entry = File.join(spec.full_gem_path, require_path)
-            Dir.glob(File.join(load_path_entry, "**", "*.rb")).map! do |path|
-              URI::Generic.from_path(path: path, load_path_entry: load_path_entry)
-            end
-          end,
-        )
-      rescue Gem::MissingSpecError
-        # If a gem is scoped only to some specific platform, then its dependencies may not be installed either, but they
-        # are still listed in locked_gems. We can't index them because they are not installed for the platform, so we
-        # just ignore if they're missing
-      end
-
-      uris.uniq!(&:to_s)
-      uris
-    end
-
-    #: -> Regexp
-    def magic_comment_regex
-      @magic_comment_regex ||= /^#\s*#{@excluded_magic_comments.join("|")}/ #: Regexp?
-    end
-
-    #: (Hash[String, untyped] config) -> void
-    def apply_config(config)
-      validate_config!(config)
-
-      @excluded_gems.concat(config["excluded_gems"]) if config["excluded_gems"]
-      @included_gems.concat(config["included_gems"]) if config["included_gems"]
-      @excluded_patterns.concat(config["excluded_patterns"]) if config["excluded_patterns"]
-      @included_patterns.concat(config["included_patterns"]) if config["included_patterns"]
-      @excluded_magic_comments.concat(config["excluded_magic_comments"]) if config["excluded_magic_comments"]
-    end
-
-    private
-
-    #: (Hash[String, untyped] config) -> void
-    def validate_config!(config)
-      errors = config.filter_map do |key, value|
-        type = CONFIGURATION_SCHEMA[key]
-
-        if type.nil?
-          "Unknown configuration option: #{key}"
-        elsif !value.is_a?(type)
-          "Expected #{key} to be a #{type}, but got #{value.class}"
-        end
-      end
-
-      raise ArgumentError, errors.join("\n") if errors.any?
-    end
-
-    #: -> Array[String]
-    def initial_excluded_gems
-      excluded, others = Bundler.definition.dependencies.partition do |dependency|
-        dependency.groups == [:development]
-      end
-
-      # When working on a gem, we need to make sure that its gemspec dependencies can't be excluded. This is necessary
-      # because Bundler doesn't assign groups to gemspec dependencies
-      #
-      # If the dependency is prerelease, `to_spec` may return `nil` due to a bug in older version of Bundler/RubyGems:
-      # https://github.com/Shopify/ruby-lsp/issues/1246
-      this_gem = Bundler.definition.dependencies.find do |d|
-        d.to_spec&.full_gem_path == @workspace_path
-      rescue Gem::MissingSpecError
-        false
-      end
-
-      others.concat(this_gem.to_spec.dependencies) if this_gem
-      others.concat(
-        others.filter_map do |d|
-          d.to_spec&.dependencies
-        rescue Gem::MissingSpecError
-          nil
-        end.flatten,
-      )
-      others.uniq!
-      others.map!(&:name)
-
-      transitive_excluded = excluded.each_with_object([]) do |dependency, acc|
-        next unless dependency.runtime?
-
-        spec = dependency.to_spec
-        next unless spec
-
-        spec.dependencies.each do |transitive_dependency|
-          next if others.include?(transitive_dependency.name)
-
-          acc << transitive_dependency
-        end
-      rescue Gem::MissingSpecError
-        # If a gem is scoped only to some specific platform, then its dependencies may not be installed either, but they
-        # are still listed in dependencies. We can't index them because they are not installed for the platform, so we
-        # just ignore if they're missing
-      end
-
-      excluded.concat(transitive_excluded)
-      excluded.uniq!
-      excluded.map(&:name)
-    rescue Bundler::GemfileNotFound
-      []
-    end
-
-    # Checks if the test file is never supposed to be ignored from indexing despite matching exclusion patterns, like
-    # `test_helper.rb` or `test_case.rb`. Also takes into consideration the possibility of finding these files under
-    # fixtures or inside gem source code if the bundle path points to a directory inside the workspace
-    #: (String path, String? bundle_path) -> bool
-    def test_files_ignored_from_exclusion?(path, bundle_path)
-      ["test_case.rb", "test_helper.rb"].include?(File.basename(path)) &&
-        !File.fnmatch?("**/fixtures/**/*", path, File::FNM_PATHNAME | File::FNM_EXTGLOB) &&
-        (!bundle_path || !path.start_with?(bundle_path))
-    end
-
-    #: -> Array[String]
-    def top_level_directories
-      excluded_directories = ["tmp", "node_modules", "sorbet"]
-
-      Dir.glob("#{Dir.pwd}/*").filter_map do |path|
-        dir_name = File.basename(path)
-        next unless File.directory?(path) && !excluded_directories.include?(dir_name)
-
-        dir_name
-      end
-    end
-  end
-end