ruby-lsp 0.26.8 → 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/scripts/compose_bundle_windows.rb

@@ -7,6 +7,4 @@ require_relative "compose_bundle"
 # invoke the compose method from inside a forked process
 options = {}
 options[:beta] = true if ARGV.include?("--beta")
-branch_index = ARGV.index("--branch")
-options[:branch] = ARGV[branch_index + 1] if branch_index
 compose(ARGV.first, **options)

data/lib/ruby_lsp/server.rb

@@ -3,6 +3,8 @@
 
 module RubyLsp
   class Server < BaseServer
+    NON_REPORTABLE_SETUP_ERRORS = [Bundler::GemNotFound, Bundler::GitError].freeze #: Array[singleton(StandardError)]
+
     # Only for testing
     #: GlobalState
     attr_reader :global_state
@@ -315,7 +317,7 @@ module RubyLsp
 
       global_state_notifications.each { |notification| send_message(notification) }
 
-      if @setup_error
+      if @setup_error && NON_REPORTABLE_SETUP_ERRORS.none? { |error_class| @setup_error.is_a?(error_class) }
         send_message(Notification.telemetry(
           type: "error",
           errorMessage: @setup_error.message,
@@ -413,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
@@ -1031,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
@@ -1211,7 +1239,7 @@ module RubyLsp
             }
           end
         end
-      rescue Bundler::GemNotFound, Bundler::GemfileNotFound
+      rescue Bundler::GemNotFound, Bundler::GemfileNotFound, Errno::ENOENT
         []
       end
 
@@ -1226,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.
@@ -1285,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

@@ -39,7 +39,6 @@ module RubyLsp
     #: (String project_path, **untyped options) -> void
     def initialize(project_path, **options)
       @project_path = project_path
-      @branch = options[:branch] #: String?
       @launcher = options[:launcher] #: bool?
       @beta = options[:beta] #: bool?
       force_output_to_stderr! if @launcher
@@ -178,9 +177,7 @@ module RubyLsp
 
       unless @dependencies["ruby-lsp"]
         version = @beta ? "0.a" : RUBY_LSP_MIN_VERSION
-        ruby_lsp_entry = +"gem \"ruby-lsp\", \">= #{version}\", require: false, group: :development"
-        ruby_lsp_entry << ", github: \"Shopify/ruby-lsp\", branch: \"#{@branch}\"" if @branch
-        parts << ruby_lsp_entry
+        parts << "gem \"ruby-lsp\", \">= #{version}\", require: false, group: :development"
       end
 
       unless @dependencies["debug"]

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.8
+  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