ruby-lsp 0.26.9 → 0.27.0.beta1

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