solargraph 0.53.2 → 0.53.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd82572e0c8ca2d5e7477c4bbcd58fa66b318550a23b6944d8749f67913560e3
-  data.tar.gz: 79ba0becff2e00fbcc7139ec540e91db5dec195cf5ae557cdcf599026b11b964
+  metadata.gz: 82af0b18d57296a8eef96680e60f131bad23268e4043d49407d197fc378dd3d2
+  data.tar.gz: 10c5622ac74f0feef06033ed0b851268c876a68581d846b2874fe61a29612acb
 SHA512:
-  metadata.gz: 743c84f70a8d49f253f4fdf3e8b43a3061ad7cd6eec68fbbf592505d63d56666ae5654ca2664750a7963d43f5b131ff1c7bc52660266786d345c9a19b86856fa
-  data.tar.gz: 8accd71eec8ce6f5ccf3aa5efd692a3ff71ea35eabf125446fe533049df80bd84fb33bf73d0cdadd7914598d485ed1f013c7cc898575b1a34238c90e92d8318e
+  metadata.gz: 1671b54ae2c314d5c566629706b6de94ca5de0902d1d56e7b96853a889d54b0caef084a5c416222f6fe9f4d40387ea3b56d34b6af917a36855ae902f0b8acf0d
+  data.tar.gz: e7b24e7c08164da0a0b60fc8f04281bfceef59e95470d3f3e78193b024d615da2ae62f94712222ffac722623f7de8207f7af29013bdad6787c63716556ecaf43

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 0.53.4 - March 30, 2025
+- [regression] Restore 'Unresolved call' typecheck for stdlib objects (#849)
+- Lazy dynamic rebinding (#851)
+- Restore fill for Class#allocate (#848)
+- [regression] Ensure YardMap gems have return type for Class<T>.new (#850)
+- Create implicit .new pins in namespace method queries (#853)
+
+## 0.53.3 - March 29, 2025
+- Remove redundant core fills (#824, #841)
+- Resolve self type in variable assignments (#839)
+- Eliminate splat-related false-alarms in strict typechecking (#840)
+- Dynamic block binding with yieldreceiver (#842)
+- Resolve generics by descending through context type (#847)
+
 ## 0.53.2 - March 27, 2025
 - Fix a self-type-related false-positive in strict typechecking (#834)
 - DocMap fetches gem dependencies (#835)

data/lib/solargraph/api_map/source_to_yard.rb

@@ -6,10 +6,13 @@ module Solargraph
 
       # Get the YARD CodeObject at the specified path.
       #
+      # @generic T
       # @param path [String]
-      # @return [YARD::CodeObjects::Base]
-      def code_object_at path
-        code_object_map[path]
+      # @param klass [Class<generic<T>>]
+      # @return [generic<T>, nil]
+      def code_object_at path, klass = YARD::CodeObjects::Base
+        obj = code_object_map[path]
+        obj if obj&.is_a?(klass)
       end
 
       # @return [Array<String>]
@@ -41,11 +44,13 @@ module Solargraph
           end
           code_object_map[pin.path].docstring = pin.docstring
           store.get_includes(pin.path).each do |ref|
-            code_object_map[pin.path].instance_mixins.push code_object_map[ref] unless code_object_map[ref].nil? or code_object_map[pin.path].nil?
+            include_object = code_object_at(pin.path, YARD::CodeObjects::ClassObject)
+            include_object.instance_mixins.push code_object_map[ref] unless include_object.nil? or include_object.nil?
           end
           store.get_extends(pin.path).each do |ref|
-            code_object_map[pin.path].instance_mixins.push code_object_map[ref] unless code_object_map[ref].nil? or code_object_map[pin.path].nil?
-            code_object_map[pin.path].class_mixins.push code_object_map[ref] unless code_object_map[ref].nil? or code_object_map[pin.path].nil?
+            extend_object = code_object_at(pin.path, YARD::CodeObjects::ClassObject)
+            extend_object.instance_mixins.push code_object_map[ref] unless extend_object.nil? or extend_object.nil?
+            extend_object.class_mixins.push code_object_map[ref] unless extend_object.nil? or extend_object.nil?
           end
         end
         store.method_pins.each do |pin|
@@ -53,13 +58,15 @@ module Solargraph
             code_object_map[pin.path] ||= pin.code_object
             next
           end
-          code_object_map[pin.path] ||= YARD::CodeObjects::MethodObject.new(code_object_at(pin.namespace), pin.name, pin.scope) { |obj|
+
+          code_object_map[pin.path] ||= YARD::CodeObjects::MethodObject.new(code_object_at(pin.namespace, YARD::CodeObjects::NamespaceObject), pin.name, pin.scope) { |obj|
             next if pin.location.nil? || pin.location.filename.nil?
             obj.add_file pin.location.filename, pin.location.range.start.line
           }
-          code_object_map[pin.path].docstring = pin.docstring
-          code_object_map[pin.path].visibility = pin.visibility || :public
-          code_object_map[pin.path].parameters = pin.parameters.map do |p|
+          method_object = code_object_at(pin.path, YARD::CodeObjects::MethodObject)
+          method_object.docstring = pin.docstring
+          method_object.visibility = pin.visibility || :public
+          method_object.parameters = pin.parameters.map do |p|
             [p.name, p.asgn_code]
           end
         end

data/lib/solargraph/api_map.rb

@@ -68,8 +68,6 @@ module Solargraph
       @store = Store.new(@@core_map.pins + @doc_map.pins + implicit.pins + pins)
       @unresolved_requires = @doc_map.unresolved_requires
       @missing_docs = [] # @todo Implement missing docs
-      @rebindable_method_names = nil
-      store.block_pins.each { |blk| blk.rebind(self) }
       self
     end
 
@@ -154,17 +152,6 @@ module Solargraph
       store.pins
     end
 
-    # @return [Set<String>]
-    def rebindable_method_names
-      @rebindable_method_names ||= begin
-        result = ['instance_eval', 'instance_exec', 'class_eval', 'class_exec', 'module_eval', 'module_exec', 'define_method'].to_set
-        source_maps.each do |map|
-          result.merge map.rebindable_method_names
-        end
-        result
-      end
-    end
-
     # An array of pins based on Ruby keywords (`if`, `end`, etc.).
     #
     # @return [Enumerable<Solargraph::Pin::Keyword>]
@@ -324,6 +311,26 @@ module Solargraph
         result.concat inner_get_methods('Kernel', :instance, visibility, deep, skip)
       else
         result.concat inner_get_methods(rooted_tag, scope, visibility, deep, skip)
+        unless %w[Class Class<Class>].include?(rooted_tag)
+          result.map! do |pin|
+            next pin unless pin.path == 'Class#new'
+            init_pin = get_method_stack(rooted_tag, 'initialize').first
+            next pin unless init_pin
+
+            type = ComplexType.try_parse(ComplexType.try_parse(rooted_tag).namespace)
+            Pin::Method.new(
+              name: 'new',
+              scope: :class,
+              location: init_pin.location,
+              parameters: init_pin.parameters,
+              signatures: init_pin.signatures.map { |sig| sig.proxy(type) },
+              return_type: type,
+              comments: init_pin.comments,
+              closure: init_pin.closure
+            # @todo Hack to force TypeChecker#internal_or_core?
+            ).tap { |pin| pin.source = :rbs }
+          end
+        end
         result.concat inner_get_methods('Kernel', :instance, [:public], deep, skip) if visibility.include?(:private)
         result.concat inner_get_methods('Module', scope, visibility, deep, skip)
       end
@@ -737,23 +744,22 @@ module Solargraph
     # @param visibility [Enumerable<Symbol>]
     # @return [Array<Pin::Base>]
     def resolve_method_aliases pins, visibility = [:public, :private, :protected]
-      result = []
-      pins.each do |pin|
+      pins.map do |pin|
         resolved = resolve_method_alias(pin)
-        next if resolved.respond_to?(:visibility) && !visibility.include?(resolved.visibility)
-        result.push resolved
-      end
-      result
+        next pin if resolved.respond_to?(:visibility) && !visibility.include?(resolved.visibility)
+        resolved
+      end.compact
     end
 
     # @param pin [Pin::MethodAlias, Pin::Base]
     # @return [Pin::Method]
     def resolve_method_alias pin
-      return pin if !pin.is_a?(Pin::MethodAlias) || @method_alias_stack.include?(pin.path)
+      return pin unless pin.is_a?(Pin::MethodAlias)
+      return nil if @method_alias_stack.include?(pin.path)
       @method_alias_stack.push pin.path
       origin = get_method_stack(pin.full_context.tag, pin.original, scope: pin.scope).first
       @method_alias_stack.pop
-      return pin if origin.nil?
+      return nil if origin.nil?
       args = {
         location: pin.location,
         closure: pin.closure,

data/lib/solargraph/complex_type/unique_type.rb

@@ -8,7 +8,7 @@ module Solargraph
     class UniqueType
       include TypeMethods
 
-      attr_reader :all_params
+      attr_reader :all_params, :subtypes, :key_types
 
       # Create a UniqueType with the specified name and an optional substring.
       # The substring is the parameter section of a parametrized type, e.g.,
@@ -105,13 +105,9 @@ module Solargraph
       # @param resolved_generic_values [Hash{String => ComplexType}] Added to as types are encountered or resolved
       # @return [UniqueType, ComplexType]
       def resolve_generics_from_context generics_to_resolve, context_type, resolved_generic_values: {}
-        transform(name) do |t|
-          next t unless t.name == ComplexType::GENERIC_TAG_NAME
-
-          new_binding = false
-
-          type_param = t.subtypes.first&.name
-          next t unless generics_to_resolve.include? type_param
+        if name == ComplexType::GENERIC_TAG_NAME
+          type_param = subtypes.first&.name
+          return self unless generics_to_resolve.include? type_param
           unless context_type.nil? || !resolved_generic_values[type_param].nil?
             new_binding = true
             resolved_generic_values[type_param] = context_type
@@ -121,7 +117,34 @@ module Solargraph
               complex_type.resolve_generics_from_context(generics_to_resolve, nil, resolved_generic_values: resolved_generic_values)
             end
           end
-          resolved_generic_values[type_param] || t
+          return resolved_generic_values[type_param] || self
+        end
+
+        # @todo typechecking should complain when the method being called has no @yieldparam tag
+        new_key_types = resolve_param_generics_from_context(generics_to_resolve, context_type, resolved_generic_values, &:key_types)
+        new_subtypes = resolve_param_generics_from_context(generics_to_resolve, context_type, resolved_generic_values, &:subtypes)
+        recreate(new_key_types: new_key_types, new_subtypes: new_subtypes)
+      end
+
+      # @param generics_to_resolve [Enumerable<String>]
+      # @param context_type [UniqueType]
+      # @param resolved_generic_values [Hash{String => ComplexType}]
+      # @yieldreturn [Array<ComplexType>]
+      # @return [Array<ComplexType>]
+      def resolve_param_generics_from_context(generics_to_resolve, context_type, resolved_generic_values)
+        types = yield self
+        types.each_with_index.flat_map do |ct, i|
+          ct.items.flat_map do |ut|
+            context_params = yield context_type if context_type
+            if context_params && context_params[i]
+              type_arg = context_params[i]
+              type_arg.map do |new_unique_context_type|
+                ut.resolve_generics_from_context generics_to_resolve, new_unique_context_type, resolved_generic_values: resolved_generic_values
+              end
+            else
+              ut.resolve_generics_from_context generics_to_resolve, nil, resolved_generic_values: resolved_generic_values
+            end
+          end
         end
       end
 

data/lib/solargraph/gem_pins.rb

@@ -20,7 +20,7 @@ module Solargraph
       combined = yard_pins.map do |yard|
         in_yard.add yard.path
         next yard unless yard.is_a?(Pin::Method)
-        rbs = rbs_map.path_pin(yard.path)
+        rbs = rbs_map.path_pin(yard.path, Pin::Method)
         next yard unless rbs
         # @todo Could not include: attribute and anon_splat
         # @sg-ignore

data/lib/solargraph/language_server/host.rb

@@ -493,6 +493,24 @@ module Solargraph
         end
         if params['data']['path']
           result.concat library.path_pins(params['data']['path'])
+          # @todo This exception is necessary because `Library#path_pins` does
+          #   not perform a namespace method query, so the implicit `.new` pin
+          #   might not exist.
+          if result.empty? && params['data']['path'] =~ /\.new$/
+            result.concat(library.path_pins(params['data']['path'].sub(/\.new$/, '#initialize')).map do |pin|
+              next pin unless pin.name == 'initialize'
+
+              Pin::Method.new(
+                name: 'new',
+                scope: :class,
+                location: pin.location,
+                parameters: pin.parameters,
+                return_type: ComplexType.try_parse(params['data']['path']),
+                comments: pin.comments,
+                closure: pin.closure
+              )
+            end)
+          end
         end
         # Selecting by both location and path can result in duplicate pins
         result.uniq { |p| [p.path, p.location] }

data/lib/solargraph/library.rb

@@ -251,7 +251,19 @@ module Solargraph
         found = source.references(pin.name)
         found.select! do |loc|
           referenced = definitions_at(loc.filename, loc.range.ending.line, loc.range.ending.character).first
-          referenced && referenced.path == pin.path
+          referenced&.path == pin.path
+        end
+        if pin.path == 'Class#new'
+          caller = cursor.chain.base.infer(api_map, clip.send(:block), clip.locals).first
+          if caller.defined?
+            found.select! do |loc|
+              clip = api_map.clip_at(loc.filename, loc.range.start)
+              other = clip.send(:cursor).chain.base.infer(api_map, clip.send(:block), clip.locals).first
+              caller == other
+            end
+          else
+            found.clear
+          end
         end
         # HACK: for language clients that exclude special characters from the start of variable names
         if strip && match = cursor.word.match(/^[^a-z0-9_]+/i)

data/lib/solargraph/page.rb

@@ -7,6 +7,12 @@ require 'cgi'
 
 module Solargraph
   class Page
+    # @todo This method directive is necessary because OpenStruct.new confuses
+    #   the typechecker.
+    # @!method self.new(locals, render_method)
+    #   @param locals[Hash]
+    #   @param render_method [Proc]
+    #   @return [Binder]
     class Binder < OpenStruct
       # @param locals [Hash]
       # @param render_method [Proc]

data/lib/solargraph/parser/parser_gem/node_processors/def_node.rb

@@ -6,31 +6,18 @@ module Solargraph
       module NodeProcessors
         class DefNode < Parser::NodeProcessor::Base
           def process
+            name = node.children[0].to_s
+            scope = region.scope || (region.closure.is_a?(Pin::Singleton) ? :class : :instance)
             methpin = Solargraph::Pin::Method.new(
               location: get_node_location(node),
               closure: region.closure,
-              name: node.children[0].to_s,
+              name: name,
               comments: comments_for(node),
-              scope: region.scope || (region.closure.is_a?(Pin::Singleton) ? :class : :instance),
-              visibility: region.visibility,
+              scope: scope,
+              visibility: scope == :instance && name == 'initialize' ? :private : region.visibility,
               node: node
             )
-            if methpin.name == 'initialize' and methpin.scope == :instance
-              pins.push Solargraph::Pin::Method.new(
-                location: methpin.location,
-                closure: methpin.closure,
-                name: 'new',
-                comments: methpin.comments,
-                scope: :class,
-                parameters: methpin.parameters
-              )
-              # @todo Smelly instance variable access.
-              pins.last.instance_variable_set(:@return_type, ComplexType::SELF)
-              pins.push methpin
-              # @todo Smelly instance variable access.
-              methpin.instance_variable_set(:@visibility, :private)
-              methpin.instance_variable_set(:@return_type, ComplexType::VOID)
-            elsif region.visibility == :module_function
+            if region.visibility == :module_function
               pins.push Solargraph::Pin::Method.new(
                 location: methpin.location,
                 closure: methpin.closure,

data/lib/solargraph/pin/base_variable.rb

@@ -51,7 +51,7 @@ module Solargraph
             # Use the return node for inference. The clip might infer from the
             # first node in a method call instead of the entire call.
             chain = Parser.chain(node, nil, nil)
-            result = chain.infer(api_map, closure, clip.locals)
+            result = chain.infer(api_map, closure, clip.locals).self_to(closure.context.tag)
             types.push result unless result.undefined?
           end
         end

data/lib/solargraph/pin/block.rb

@@ -24,11 +24,11 @@ module Solargraph
       # @param api_map [ApiMap]
       # @return [void]
       def rebind api_map
-        @binder ||= binder_or_nil(api_map)
+        @rebind ||= maybe_rebind(api_map)
       end
 
       def binder
-        @binder || closure.binder
+        @rebind&.defined? ? @rebind : closure.binder
       end
 
       # @return [::Array<Parameter>]
@@ -44,39 +44,22 @@ module Solargraph
       private
 
       # @param api_map [ApiMap]
-      # @return [ComplexType, nil]
-      def binder_or_nil api_map
-        return nil unless receiver
-        word = receiver.children.find { |c| c.is_a?(::Symbol) }.to_s
-        return nil unless api_map.rebindable_method_names.include?(word)
+      # @return [ComplexType]
+      def maybe_rebind api_map
+        return ComplexType::UNDEFINED unless receiver
+
         chain = Parser.chain(receiver, location.filename)
         locals = api_map.source_map(location.filename).locals_at(location)
-        links_last_word = chain.links.last.word
-        if %w[instance_eval instance_exec class_eval class_exec module_eval module_exec].include?(links_last_word)
-          return chain.base.infer(api_map, self, locals)
-        end
-        if 'define_method' == links_last_word and chain.define(api_map, self, locals).first&.path == 'Module#define_method' # change class type to instance type
-          if chain.links.size > 1 # Class.define_method
-            ty = chain.base.infer(api_map, self, locals)
-            return Solargraph::ComplexType.parse(ty.namespace)
-          else # define_method without self
-            return Solargraph::ComplexType.parse(closure.binder.namespace)
-          end
-        end
-        # other case without early return, read block yieldreceiver tags
         receiver_pin = chain.define(api_map, self, locals).first
-        if receiver_pin && receiver_pin.docstring
-          ys = receiver_pin.docstring.tag(:yieldreceiver)
-          if ys && ys.types && !ys.types.empty?
-            target = if chain.links.first.is_a?(Source::Chain::Constant)
-              receiver_pin.full_context.namespace
-            else
-              full_context.namespace
-            end
-            return ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace).self_to(target)
-          end
-        end
-        nil
+        return ComplexType::UNDEFINED unless receiver_pin
+
+        types = receiver_pin.docstring.tag(:yieldreceiver)&.types
+        return ComplexType::UNDEFINED unless types&.any?
+
+        target = chain.base.infer(api_map, receiver_pin, locals)
+        target = full_context unless target.defined?
+
+        ComplexType.try_parse(*types).qualify(api_map, receiver_pin.context.namespace).self_to(target.to_s)
       end
     end
   end

data/lib/solargraph/pin/method.rb

@@ -135,7 +135,7 @@ module Solargraph
           result = []
           result.push generate_signature(parameters, top_type) if top_type.defined?
           result.concat(overloads.map { |meth| generate_signature(meth.parameters, meth.return_type) }) unless overloads.empty?
-          result.push generate_signature(parameters, top_type) if result.empty?
+          result.push generate_signature(parameters, @return_type || ComplexType::UNDEFINED) if result.empty?
           result
         end
       end

data/lib/solargraph/rbs_map/conversions.rb

@@ -39,24 +39,7 @@ module Solargraph
         cursor = pins.length
         environment.declarations.each { |decl| convert_decl_to_pin(decl, Solargraph::Pin::ROOT_PIN) }
         added_pins = pins[cursor..-1]
-        add_back_implicit_pins(added_pins)
-      end
-
-      # @param added_pins [::Enumerable<Pin>]
-      # @return [void]
-      def add_back_implicit_pins(added_pins)
-        added_pins.each do |pin|
-          pin.source = :rbs
-          next unless pin.is_a?(Pin::Namespace) && pin.type == :class
-          next if pins.any? { |p| p.path == "#{pin.path}.new"}
-          pins.push Solargraph::Pin::Method.new(
-                      location: nil,
-                      closure: pin,
-                      name: 'new',
-                      comments: pin.comments,
-                      scope: :class
-          )
-        end
+        added_pins.each { |pin| pin.source = :rbs }
       end
 
       # @param decl [RBS::AST::Declarations::Base]
@@ -303,26 +286,8 @@ module Solargraph
           pin.signatures.concat method_def_to_sigs(decl, pin)
           pins.push pin
           if pin.name == 'initialize'
-            pins.push Solargraph::Pin::Method.new(
-              location: pin.location,
-              closure: pin.closure,
-              name: 'new',
-              comments: pin.comments,
-              scope: :class,
-              signatures: pin.signatures
-            )
-            pins.last.signatures.replace(
-              pin.signatures.map do |p|
-                Pin::Signature.new(
-                  p.generics,
-                  p.parameters,
-                  ComplexType::SELF
-                )
-              end
-            )
-            # @todo Is this necessary?
-            # pin.instance_variable_set(:@visibility, :private)
-            # pin.instance_variable_set(:@return_type, ComplexType::VOID)
+            pin.instance_variable_set(:@visibility, :private)
+            pin.instance_variable_set(:@return_type, ComplexType::VOID)
           end
         end
         if decl.singleton?

data/lib/solargraph/rbs_map/core_fills.rb

@@ -22,11 +22,17 @@ module Solargraph
                                     closure: Solargraph::Pin::Namespace.new(name: 'Object'), comments: '@return [Class<self>]')
       ]
 
-      CLASS_RETURN_TYPES = [
-        Override.method_return('Class#new', 'self'),
-        Override.method_return('Class.new', 'Class<BasicObject>'),
-        Override.method_return('Class#allocate', 'self'),
-        Override.method_return('Class.allocate', 'Class<BasicObject>')
+      OVERRIDES = [
+        Override.from_comment('BasicObject#instance_eval', '@yieldreceiver [self]'),
+        Override.from_comment('BasicObject#instance_exec', '@yieldreceiver [self]'),
+        Override.from_comment('Module#define_method', '@yieldreceiver [Object<self>]'),
+        Override.from_comment('Module#class_eval', '@yieldreceiver [Class<self>]'),
+        Override.from_comment('Module#class_exec', '@yieldreceiver [Class<self>]'),
+        Override.from_comment('Module#module_eval', '@yieldreceiver [Module<self>]'),
+        Override.from_comment('Module#module_exec', '@yieldreceiver [Module<self>]'),
+        # RBS does not define Class with a generic, so all calls to
+        # generic() return an 'untyped'.  We can do better:
+        Override.method_return('Class#allocate', 'self')
       ]
 
       # HACK: Add Errno exception classes
@@ -38,7 +44,7 @@ module Solargraph
       end
       ERRNOS = errnos
 
-      ALL = KEYWORDS + MISSING + CLASS_RETURN_TYPES + ERRNOS
+      ALL = KEYWORDS + MISSING + OVERRIDES + ERRNOS
     end
   end
 end

data/lib/solargraph/rbs_map/core_map.rb

@@ -13,27 +13,16 @@ module Solargraph
           pins.replace cache
         else
           loader = RBS::EnvironmentLoader.new(repository: RBS::Repository.new(no_stdlib: false))
-          environment = RBS::Environment.from_loader(loader).resolve_type_names
+          RBS::Environment.from_loader(loader).resolve_type_names
           load_environment_to_pins(loader)
           pins.concat RbsMap::CoreFills::ALL
           processed = ApiMap::Store.new(pins).pins.reject { |p| p.is_a?(Solargraph::Pin::Reference::Override) }
+          processed.each { |pin| pin.source = :rbs }
           pins.replace processed
 
           Cache.save('core.ser', pins)
         end
       end
-
-      def method_def_to_sigs decl, pin
-        stubs = CoreSigns.sign(pin.path)
-        return super unless stubs
-        stubs.map do |stub|
-          Pin::Signature.new(
-            [],
-            [],
-            ComplexType.try_parse(stub.return_type)
-          )
-        end
-      end
     end
   end
 end

data/lib/solargraph/rbs_map.rb

@@ -7,7 +7,6 @@ module Solargraph
     autoload :Conversions, 'solargraph/rbs_map/conversions'
     autoload :CoreMap,     'solargraph/rbs_map/core_map'
     autoload :CoreFills,   'solargraph/rbs_map/core_fills'
-    autoload :CoreSigns,   'solargraph/rbs_map/core_signs'
     autoload :StdlibMap,   'solargraph/rbs_map/stdlib_map'
 
     include Conversions
@@ -28,10 +27,13 @@ module Solargraph
       load_environment_to_pins(loader)
     end
 
+    # @generic T
     # @param path [String]
-    # @return [Pin::Base, nil]
-    def path_pin path
-      pins.find { |p| p.path == path }
+    # @param klass [Class<generic<T>>]
+    # @return [generic<T>, nil]
+    def path_pin path, klass = Pin::Base
+      pin = pins.find { |p| p.path == path }
+      pin if pin&.is_a?(klass)
     end
 
     # @param path [String]

data/lib/solargraph/source_map/clip.rb

@@ -11,6 +11,7 @@ module Solargraph
       def initialize api_map, cursor
         @api_map = api_map
         @cursor = cursor
+        block.rebind(api_map) if block.is_a?(Pin::Block)
       end
 
       # @return [Array<Pin::Base>] Relevant pins for infering the type of the Cursor's position
@@ -50,9 +51,9 @@ module Solargraph
       def infer
         result = cursor.chain.infer(api_map, block, locals)
         if result.tag == 'Class'
-          # HACK: Exception to return Object from Class#new
+          # HACK: Exception to return BasicObject from Class#new
           dfn = cursor.chain.define(api_map, block, locals).first
-          return ComplexType.try_parse('Object') if dfn && dfn.path == 'Class#new'
+          return ComplexType.try_parse('BasicObject') if dfn && dfn.path == 'Class#new'
         end
         return result unless result.tag == 'self'
         ComplexType.try_parse(cursor.chain.base.infer(api_map, block, locals).tag)

data/lib/solargraph/source_map.rb

@@ -40,14 +40,6 @@ module Solargraph
       @pin_select_cache[klass] ||= @pin_class_hash.select { |key, _| key <= klass }.values.flatten
     end
 
-    # @return [Set<String>]
-    def rebindable_method_names
-      @rebindable_method_names ||= pins_by_class(Pin::Method)
-        .select { |pin| pin.comments && pin.comments.include?('@yieldreceiver') }
-        .map(&:name)
-        .to_set
-    end
-
     # @return [String]
     def filename
       source.filename

data/lib/solargraph/type_checker.rb

@@ -268,6 +268,7 @@ module Solargraph
             base = base.base
           end
           closest = found.typify(api_map) if found
+          # @todo remove the internal_or_core? check at a higher-than-strict level
           if !found || found.is_a?(Pin::BaseVariable) || (closest.defined? && internal_or_core?(found))
             unless closest.generic? || ignored_pins.include?(found)
               result.push Problem.new(location, "Unresolved call to #{missing.links.last.word}")
@@ -299,6 +300,14 @@ module Solargraph
           pin = pins.first
           ap = if base.links.last.is_a?(Solargraph::Source::Chain::ZSuper)
             arity_problems_for(pin, fake_args_for(block_pin), location)
+          elsif pin.path == 'Class#new'
+            fqns = if base.links.one?
+              block_pin.namespace
+            else
+              base.base.infer(api_map, block_pin, locals).namespace
+            end
+            init = api_map.get_method_stack(fqns, 'initialize').first
+            init ? arity_problems_for(init, base.links.last.arguments, location) : []
           else
             arity_problems_for(pin, base.links.last.arguments, location)
           end
@@ -320,8 +329,14 @@ module Solargraph
               argchain = base.links.last.arguments[idx]
               if argchain.nil?
                 if par.decl == :arg
-                  errors.push Problem.new(location, "Not enough arguments to #{pin.path}")
-                  next
+                  last = base.links.last.arguments.last
+                  if last && last.node.type == :splat
+                    argchain = last
+                    next # don't try to apply the type of the splat - unlikely to be specific enough
+                  else
+                    errors.push Problem.new(location, "Not enough arguments to #{pin.path}")
+                    next
+                  end
                 else
                   last = base.links.last.arguments.last
                   argchain = last if last && [:kwsplat, :hash].include?(last.node.type)
@@ -332,6 +347,10 @@ module Solargraph
                   errors.concat kwarg_problems_for sig, argchain, api_map, block_pin, locals, location, pin, params, idx
                   next
                 else
+                  last = base.links.last.arguments.last
+                  if last && last.node.type == :splat
+                    next # don't try to apply the type of the splat - unlikely to be specific enough
+                  end
                   ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
                   ptype = ptype.self_to(par.context.namespace)
                   if ptype.nil?

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = '0.53.2'
+  VERSION = '0.53.4'
 end

data/lib/solargraph/yard_map/mapper/to_method.rb

@@ -19,17 +19,20 @@ module Solargraph
             gates: [code_object.namespace.to_s]
           )
           location = object_location(code_object, spec)
+          name ||= code_object.name.to_s
+          return_type = ComplexType::SELF if name == 'new'
           comments = code_object.docstring ? code_object.docstring.all.to_s : ''
           pin = Pin::Method.new(
             location: location,
             closure: closure,
-            name: name || code_object.name.to_s,
+            name: name,
             comments: comments,
             scope: scope || code_object.scope,
             visibility: visibility || code_object.visibility,
             # @todo Might need to convert overloads to signatures
             parameters: [],
-            explicit: code_object.is_explicit?
+            explicit: code_object.is_explicit?,
+            return_type: return_type
           )
           pin.parameters.concat get_parameters(code_object, location, comments, pin)
           pin

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solargraph
 version: !ruby/object:Gem::Version
-  version: 0.53.2
+  version: 0.53.4
 platform: ruby
 authors:
 - Fred Snyder
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-27 00:00:00.000000000 Z
+date: 2025-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: backport
@@ -558,7 +558,6 @@ files:
 - lib/solargraph/rbs_map/conversions.rb
 - lib/solargraph/rbs_map/core_fills.rb
 - lib/solargraph/rbs_map/core_map.rb
-- lib/solargraph/rbs_map/core_signs.rb
 - lib/solargraph/rbs_map/stdlib_map.rb
 - lib/solargraph/server_methods.rb
 - lib/solargraph/shell.rb

data/lib/solargraph/rbs_map/core_signs.rb

@@ -1,35 +0,0 @@
-module Solargraph
-  class RbsMap
-    module CoreSigns
-      Override = Pin::Reference::Override
-
-      class Stub
-        attr_reader :parameters
-
-        attr_reader :return_type
-
-        # @param parameters [Array<Hash>]
-        # @param return_type [String]
-        def initialize parameters, return_type
-          @parameters = parameters
-          @return_type = return_type
-        end
-      end
-
-      SIGNATURE_MAP = {
-        'Object#class' => [
-          Stub.new(
-            [],
-            'Class<self>'
-          )
-        ]
-      }
-
-      # @param path [String]
-      # @return [Array<Stub>]
-      def self.sign path
-        SIGNATURE_MAP[path]
-      end
-    end
-  end
-end