Infer types for method calls on immediately instantiated objects (#3007)

### Motivation

Closes #2994

This PR adds inference for methods invoked directly on an object instantiation. It's fairly easy to add, so I think it's worth getting it done.

### Implementation

When the receiver of a method call is another method call using `new`, we infer the type of the constant receiver and then return the attached version of it. For example:

```ruby
# In this case, `Foo::<Class:Foo>` is the receiver of `new`, but new will return an
# object. Thus the right type is the attached class, which is `Foo`
Foo.new.something
```

The only exception is if the method `new` was overridden, which is valid in Ruby. We cannot guarantee that the override actually returns a new object of the class, so it's better to not infer anything in those cases.

### Automated Tests

Added tests.

Author: vinistock

jekyll/index.markdown

@@ -169,6 +169,14 @@ It also allows developers to discover constants or methods that are available to
 Sorry, your browser doesn't support embedded videos. This video illustrates the completion feature, providing completion candidates as the user types.
 </video>
 
+{: .note }
+Completion for method calls can only be provided when the type of the receiver is known. For example, when typing `foo.`
+it's only possible to show method completion candidates if know the type of `foo`. Since the Ruby LSP does not require
+users to adopt a type system, completion for methods ends up being available only when types can be determined even
+without annotations (e.g.: methods invoked on literals, constants, direct instantiations of objects using `new`).<br><br>
+If you would like to have more accurate completion, consider adopting a
+[type system](design-and-roadmap#accuracy-correctness-and-type-checking).
+
 ### Signature Help
 
 Signature help often appears right after users finish typing a method, providing hints about the method's parameters. This feature is invaluable for understanding the expected arguments and improving code accuracy.

lib/ruby_lsp/type_inferrer.rb

@@ -91,29 +91,45 @@ def infer_receiver_for_call_node(node, node_context)
         return Type.new("#{last}::<Class:#{last}>") if parts.empty?
 
         Type.new("#{parts.join("::")}::#{last}::<Class:#{last}>")
-      else
+      when Prism::CallNode
+        raw_receiver = receiver.message
 
-        raw_receiver = if receiver.is_a?(Prism::CallNode)
-          receiver.message
-        else
-          receiver.slice
-        end
+        if raw_receiver == "new"
+          # 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)
 
-        if raw_receiver
-          guessed_name = raw_receiver
-            .delete_prefix("@")
-            .delete_prefix("@@")
-            .split("_")
-            .map(&:capitalize)
-            .join
-
-          entries = @index.resolve(guessed_name, node_context.nesting) || @index.first_unqualified_const(guessed_name)
-          name = entries&.first&.name
-          GuessedType.new(name) if name
+          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"
+
+          type.attached
+        elsif raw_receiver
+          guess_type(raw_receiver, node_context.nesting)
         end
+      else
+        guess_type(receiver.slice, node_context.nesting)
       end
     end
 
+    sig { params(raw_receiver: String, nesting: T::Array[String]).returns(T.nilable(GuessedType)) }
+    def guess_type(raw_receiver, nesting)
+      guessed_name = raw_receiver
+        .delete_prefix("@")
+        .delete_prefix("@@")
+        .split("_")
+        .map(&:capitalize)
+        .join
+
+      entries = @index.resolve(guessed_name, nesting) || @index.first_unqualified_const(guessed_name)
+      name = entries&.first&.name
+      return unless name
+
+      GuessedType.new(name)
+    end
+
     sig { params(node_context: NodeContext).returns(Type) }
     def self_receiver_handling(node_context)
       nesting = node_context.nesting
@@ -176,6 +192,12 @@ class Type
       def initialize(name)
         @name = name
       end
+
+      # Returns the attached version of this type by removing the `<Class:...>` part from its name
+      sig { returns(Type) }
+      def attached
+        Type.new(T.must(@name.split("::")[..-2]).join("::"))
+      end
     end
 
     # A type that was guessed based on the receiver raw name

test/type_inferrer_test.rb

@@ -471,6 +471,31 @@ def test_infer_top_level_class_variables
       assert_equal("Object", @type_inferrer.infer_receiver_type(node_context).name)
     end
 
+    def test_infer_object_instantiation_receiver
+      node_context = index_and_locate(<<~RUBY, { line: 1, character: 8 })
+        class Foo; end
+        Foo.new.bar
+      RUBY
+
+      assert_equal("Foo", @type_inferrer.infer_receiver_type(node_context).name)
+    end
+
+    def test_infer_object_instantiation_receiver_is_ignored_if_new_is_overridden
+      node_context = index_and_locate(<<~RUBY, { line: 8, character: 8 })
+        module Bar
+          def new; end
+        end
+
+        class Foo
+          extend Bar
+        end
+
+        Foo.new.bar
+      RUBY
+
+      assert_nil(@type_inferrer.infer_receiver_type(node_context))
+    end
+
     private
 
     def index_and_locate(source, position)