ruby-lsp 0.26.11 → 0.27.0.beta1

data/lib/ruby_lsp/rubydex/definition.rb

@@ -0,0 +1,200 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Rubydex
+  # @abstract
+  class Definition
+    #: () -> RubyLsp::Interface::LocationLink
+    def to_lsp_location_link
+      selection_range = to_lsp_selection_range
+
+      RubyLsp::Interface::LocationLink.new(
+        target_uri: location.uri,
+        target_range: selection_range,
+        target_selection_range: to_lsp_name_range || selection_range,
+      )
+    end
+
+    # @abstract
+    #: () -> Integer
+    def to_lsp_kind
+      raise RubyLsp::AbstractMethodInvokedError
+    end
+
+    #: (String name) -> RubyLsp::Interface::WorkspaceSymbol
+    def to_lsp_workspace_symbol(name)
+      # We use the namespace as the container name, but we also use the full name as the regular name. The reason we do
+      # this is to allow people to search for fully qualified names (e.g.: `Foo::Bar`). If we only included the short
+      # name `Bar`, then searching for `Foo::Bar` would not return any results
+      *container, _short_name = name.split("::")
+      container_name = container.join("::")
+
+      RubyLsp::Interface::WorkspaceSymbol.new(
+        name: name,
+        container_name: container_name,
+        kind: to_lsp_kind,
+        location: to_lsp_selection_location,
+      )
+    end
+
+    #: () -> RubyLsp::Interface::Range
+    def to_lsp_selection_range
+      loc = location
+
+      RubyLsp::Interface::Range.new(
+        start: RubyLsp::Interface::Position.new(line: loc.start_line, character: loc.start_column),
+        end: RubyLsp::Interface::Position.new(line: loc.end_line, character: loc.end_column),
+      )
+    end
+
+    #: () -> RubyLsp::Interface::Location
+    def to_lsp_selection_location
+      location = self.location
+
+      RubyLsp::Interface::Location.new(
+        uri: location.uri,
+        range: RubyLsp::Interface::Range.new(
+          start: RubyLsp::Interface::Position.new(line: location.start_line, character: location.start_column),
+          end: RubyLsp::Interface::Position.new(line: location.end_line, character: location.end_column),
+        ),
+      )
+    end
+
+    #: () -> RubyLsp::Interface::Range?
+    def to_lsp_name_range
+      loc = name_location
+      return unless loc
+
+      RubyLsp::Interface::Range.new(
+        start: RubyLsp::Interface::Position.new(line: loc.start_line, character: loc.start_column),
+        end: RubyLsp::Interface::Position.new(line: loc.end_line, character: loc.end_column),
+      )
+    end
+
+    #: () -> RubyLsp::Interface::Location?
+    def to_lsp_name_location
+      location = name_location
+      return unless location
+
+      RubyLsp::Interface::Location.new(
+        uri: location.uri,
+        range: RubyLsp::Interface::Range.new(
+          start: RubyLsp::Interface::Position.new(line: location.start_line, character: location.start_column),
+          end: RubyLsp::Interface::Position.new(line: location.end_line, character: location.end_column),
+        ),
+      )
+    end
+  end
+
+  class ClassDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::CLASS
+    end
+  end
+
+  class ModuleDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::NAMESPACE
+    end
+  end
+
+  class SingletonClassDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::CLASS
+    end
+  end
+
+  class ConstantDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::CONSTANT
+    end
+  end
+
+  class ConstantAliasDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::CONSTANT
+    end
+  end
+
+  class MethodDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      name == "initialize()" ? RubyLsp::Constant::SymbolKind::CONSTRUCTOR : RubyLsp::Constant::SymbolKind::METHOD
+    end
+  end
+
+  class MethodAliasDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::METHOD
+    end
+  end
+
+  class AttrReaderDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::PROPERTY
+    end
+  end
+
+  class AttrWriterDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::PROPERTY
+    end
+  end
+
+  class AttrAccessorDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::PROPERTY
+    end
+  end
+
+  class InstanceVariableDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::FIELD
+    end
+  end
+
+  class ClassVariableDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::FIELD
+    end
+  end
+
+  class GlobalVariableDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::VARIABLE
+    end
+  end
+
+  class GlobalVariableAliasDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::VARIABLE
+    end
+  end
+end

data/lib/ruby_lsp/rubydex/reference.rb

@@ -0,0 +1,16 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Rubydex
+  class ConstantReference
+    #: () -> RubyLsp::Interface::Range
+    def to_lsp_range
+      loc = location
+
+      RubyLsp::Interface::Range.new(
+        start: RubyLsp::Interface::Position.new(line: loc.start_line, character: loc.start_column),
+        end: RubyLsp::Interface::Position.new(line: loc.end_line, character: loc.end_column),
+      )
+    end
+  end
+end

data/lib/ruby_lsp/server.rb

@@ -3,11 +3,7 @@
 
 module RubyLsp
   class Server < BaseServer
-    NON_REPORTABLE_SETUP_ERRORS = [
-      Bundler::GemNotFound,
-      Bundler::GitError,
-      Bundler::Dsl::DSLError,
-    ].freeze #: Array[singleton(StandardError)]
+    NON_REPORTABLE_SETUP_ERRORS = [Bundler::GemNotFound, Bundler::GitError].freeze #: Array[singleton(StandardError)]
 
     # Only for testing
     #: GlobalState
@@ -124,16 +120,6 @@ module RubyLsp
         @global_state.synchronize { @cancelled_requests << message[:params][:id] }
       when nil
         process_response(message) if message[:result]
-      else
-        id = message[:id]
-
-        if id
-          send_message(Error.new(
-            id: id,
-            code: Constant::ErrorCodes::METHOD_NOT_FOUND,
-            message: "Method not found: #{message[:method]}",
-          ))
-        end
       end
     rescue DelegateRequestError
       send_message(Error.new(id: message[:id], code: DelegateRequestError::CODE, message: "DELEGATE_REQUEST"))
@@ -429,7 +415,16 @@ module RubyLsp
       params = message[:params]
       text_document = params[:textDocument]
 
-      @store.push_edits(uri: text_document[:uri], edits: params[:contentChanges], version: text_document[:version])
+      document = @store.get(text_document[:uri])
+      document.push_edits(params[:contentChanges], version: text_document[:version])
+
+      language_id = document.language_id
+
+      if [:ruby, :rbs].include?(language_id)
+        graph = @global_state.graph
+        graph.index_source(text_document[:uri].to_s, document.source, language_id.to_s)
+        graph.resolve
+      end
     end
 
     #: (Hash[Symbol, untyped] message) -> void
@@ -1047,6 +1042,23 @@ module RubyLsp
       # is fine, but we shouldn't process the same file changes more than once
       changes.uniq!
 
+      graph = @global_state.graph
+
+      # Handle deletions and accumulate additions and changes for indexing
+      additions_and_changes = changes.each_with_object([]) do |change, acc|
+        if change[:type] == Constant::FileChangeType::DELETED
+          graph.delete_document(change[:uri])
+        else
+          path = URI(change[:uri]).to_standardized_path
+          next if path.nil?
+          next unless File.directory?(path) || [".rb", ".rbs"].include?(File.extname(path))
+
+          acc << path
+        end
+      end
+      graph.index_all(additions_and_changes)
+      graph.resolve
+
       index = @global_state.index
       changes.each do |change|
         # File change events include folders, but we're only interested in files
@@ -1242,12 +1254,18 @@ module RubyLsp
 
     #: -> void
     def perform_initial_indexing
+      progress("indexing-progress", message: "Indexing workspace...")
+      @global_state.graph.index_workspace
+
+      progress("indexing-progress", message: "Resolving graph...")
+      @global_state.graph.resolve
+
       # The begin progress invocation happens during `initialize`, so that the notification is sent before we are
       # stuck indexing files
       Thread.new do
         begin
           @global_state.index.index_all do |percentage|
-            progress("indexing-progress", percentage)
+            progress("indexing-progress", percentage: percentage)
             true
           rescue ClosedQueueError
             # Since we run indexing on a separate thread, it's possible to kill the server before indexing is complete.
@@ -1301,11 +1319,13 @@ module RubyLsp
       send_message(Notification.progress_begin(id, title, percentage: percentage, message: "#{percentage}% completed"))
     end
 
-    #: (String id, Integer percentage) -> void
-    def progress(id, percentage)
+    #: (String, ?message: String?, ?percentage: Integer?) -> void
+    def progress(id, message: nil, percentage: nil)
       return unless @global_state.client_capabilities.supports_progress
 
-      send_message(Notification.progress_report(id, percentage: percentage, message: "#{percentage}% completed"))
+      message ||= "#{percentage}% completed" if percentage
+
+      send_message(Notification.progress_report(id, percentage: percentage, message: message))
     end
 
     #: (String id) -> void

data/lib/ruby_lsp/setup_bundler.rb

@@ -191,11 +191,7 @@ module RubyLsp
       end
 
       if @rails_app && !@dependencies["ruby-lsp-rails"]
-        parts << if @beta
-          'gem "ruby-lsp-rails", ">= 0.a", require: false, group: :development'
-        else
-          'gem "ruby-lsp-rails", require: false, group: :development'
-        end
+        parts << 'gem "ruby-lsp-rails", require: false, group: :development'
       end
 
       content = parts.join("\n")
@@ -449,7 +445,7 @@ module RubyLsp
       requirement = Gem::Requirement.new(@bundler_version.to_s)
       return if Gem::Specification.any? { |s| s.name == "bundler" && requirement =~ s.version }
 
-      Gem.install("bundler", @bundler_version.to_s, env_shebang: true)
+      Gem.install("bundler", @bundler_version.to_s)
     end
 
     #: -> bool

data/lib/ruby_lsp/store.rb

@@ -53,12 +53,6 @@ module RubyLsp
       end
     end
 
-    #: (uri: URI::Generic, edits: Array[Hash[Symbol, untyped]], version: Integer) -> void
-    def push_edits(uri:, edits:, version:)
-      @state[uri.to_s] #: as !nil
-        .push_edits(edits, version: version)
-    end
-
     #: -> void
     def clear
       @state.clear

data/lib/ruby_lsp/test_helper.rb

@@ -30,6 +30,9 @@ module RubyLsp
         })
 
         server.global_state.index.index_single(uri, source)
+        graph = server.global_state.graph
+        graph.index_source(uri.to_s, source, "ruby")
+        graph.resolve
       end
 
       server.load_addons(include_project_addons: false) if load_addons

data/lib/ruby_lsp/type_inferrer.rb

@@ -5,9 +5,9 @@ module RubyLsp
   # A minimalistic type checker to try to resolve types that can be inferred without requiring a type system or
   # annotations
   class TypeInferrer
-    #: (RubyIndexer::Index index) -> void
-    def initialize(index)
-      @index = index
+    #: (Rubydex::Graph) -> void
+    def initialize(graph)
+      @graph = graph
     end
 
     #: (NodeContext node_context) -> Type?
@@ -81,14 +81,13 @@ module RubyLsp
         receiver_name = RubyIndexer::Index.constant_name(receiver)
         return unless receiver_name
 
-        resolved_receiver = @index.resolve(receiver_name, node_context.nesting)
-        name = resolved_receiver&.first&.name
-        return unless name
+        resolved_receiver = @graph.resolve_constant(receiver_name, node_context.nesting)
+        return unless resolved_receiver
 
-        *parts, last = name.split("::")
-        return Type.new("#{last}::<Class:#{last}>") if parts.empty?
+        *parts, last = resolved_receiver.name.split("::")
+        return Type.new("#{last}::<#{last}>") if parts.empty?
 
-        Type.new("#{parts.join("::")}::#{last}::<Class:#{last}>")
+        Type.new("#{parts.join("::")}::#{last}::<#{last}>")
       when Prism::CallNode
         raw_receiver = receiver.message
 
@@ -96,12 +95,14 @@ module RubyLsp
           # When invoking `new`, we recursively infer the type of the receiver to get the class type its being invoked
           # on and then return the attached version of that type, since it's being instantiated.
           type = infer_receiver_for_call_node(receiver, node_context)
-
           return unless type
 
           # If the method `new` was overridden, then we cannot assume that it will return a new instance of the class
-          new_method = @index.resolve_method("new", type.name)&.first
-          return if new_method && new_method.owner&.name != "Class"
+          declaration = @graph[type.name] #: as Rubydex::Namespace?
+          return unless declaration
+
+          new_method = declaration.find_member("new()")
+          return if new_method && new_method.owner.name != "Class"
 
           type.attached
         elsif raw_receiver
@@ -121,11 +122,11 @@ module RubyLsp
         .map(&:capitalize)
         .join
 
-      entries = @index.resolve(guessed_name, nesting) || @index.first_unqualified_const(guessed_name)
-      name = entries&.first&.name
-      return unless name
+      declaration = @graph.resolve_constant(guessed_name, nesting)
+      declaration ||= @graph.search(guessed_name).first
+      return unless declaration
 
-      GuessedType.new(name)
+      GuessedType.new(declaration.name)
     end
 
     #: (NodeContext node_context) -> Type
@@ -142,24 +143,25 @@ module RubyLsp
       # If the class/module definition is using compact style (e.g.: `class Foo::Bar`), then we need to split the name
       # into its individual parts to build the correct singleton name
       parts = nesting.flat_map { |part| part.split("::") }
-      Type.new("#{parts.join("::")}::<Class:#{parts.last}>")
+      Type.new("#{parts.join("::")}::<#{parts.last}>")
     end
 
     #: (NodeContext node_context) -> Type?
     def infer_receiver_for_class_variables(node_context)
       nesting_parts = node_context.nesting.dup
-
       return Type.new("Object") if nesting_parts.empty?
 
       nesting_parts.reverse_each do |part|
-        break unless part.include?("<Class:")
+        break unless part.start_with?("<")
 
         nesting_parts.pop
       end
 
-      receiver_name = nesting_parts.join("::")
-      resolved_receiver = @index.resolve(receiver_name, node_context.nesting)&.first
-      return unless resolved_receiver&.name
+      resolved_receiver = @graph.resolve_constant(
+        nesting_parts.last, #: as !nil
+        nesting_parts[0...-1], #: as !nil
+      )
+      return unless resolved_receiver
 
       Type.new(resolved_receiver.name)
     end
@@ -174,7 +176,7 @@ module RubyLsp
         @name = name
       end
 
-      # Returns the attached version of this type by removing the `<Class:...>` part from its name
+      # Returns the attached version of this type by removing the `<...>` part from its name
       #: -> Type
       def attached
         Type.new(

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.26.11
+  version: 0.27.0.beta1
 platform: ruby
 authors:
 - Shopify
@@ -63,6 +63,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '5'
+- !ruby/object:Gem::Dependency
+  name: rubydex
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0.beta1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0.beta1
 description: An opinionated language server for Ruby
 email:
 - ruby@shopify.com
@@ -168,6 +182,8 @@ files:
 - lib/ruby_lsp/response_builders/signature_help.rb
 - lib/ruby_lsp/response_builders/test_collection.rb
 - lib/ruby_lsp/ruby_document.rb
+- lib/ruby_lsp/rubydex/definition.rb
+- lib/ruby_lsp/rubydex/reference.rb
 - lib/ruby_lsp/scope.rb
 - lib/ruby_lsp/scripts/compose_bundle.rb
 - lib/ruby_lsp/scripts/compose_bundle_windows.rb
@@ -203,7 +219,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.3
 specification_version: 4
 summary: An opinionated language server for Ruby
 test_files: []