solargraph 0.53.1 → 0.53.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb238e5ca67dae6ca26b2a5fb6eda261727eb6464f0c048adf1d043fb13ccacd
-  data.tar.gz: dfc03ca7f87fe40f79ba387b4489be60f7f155b60e2e6a3fa696637684545501
+  metadata.gz: c5f84e528dd40d7638e36189ca6b4dceccdfd1722a07bd1c1f060bf0265aa815
+  data.tar.gz: 39d6938ccabce6dda403c709711f6136472def5982222e73d89310eaeb906ee1
 SHA512:
-  metadata.gz: f101995ec1f808c69afbdb8be4d865159a6b349782b97ab7d6bb96dd61fd6ec43b8b3a3d7c9c55e14ee6feab4cdd7f570c9de688ff6a8a099f927a3d972a4e0a
-  data.tar.gz: 82b02c423e72e482e93b314361eb7165898906c3d02221b4336af853645bc668bbbb7412298db2921b621e91c0baf294987cf0d16c2b878bb5ad3b57fd0d2f3b
+  metadata.gz: cf06b94032becde9f26b7d5cedcecbc0fd7d6bde539a980c748328f11165f91398605e7ff49af502b83a70a4aa9b32406c5846cda96f5246d20c97d17220700b
+  data.tar.gz: bdddccf5d52efd2a9be2b00ac473065ecca21d76646d59d247c5cb93b14de137ebfc16ec4ffbc3ed0d6e9de9f271e9763808775d6aa271496e6328bf70b443bf

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 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)
+- Use configured command path to spawn solargraph processes (#837)
+
 ## 0.53.1 - March 26, 2025
 - Reject nil requires in live code (#831)
 - RbsMap adds mixins to current namespace (#832)

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

@@ -64,11 +64,10 @@ module Solargraph
         implicit.merge map.environ
       end
       unresolved_requires = (bench.external_requires + implicit.requires + bench.workspace.config.required).uniq
-      @doc_map = DocMap.new(unresolved_requires, []) # @todo Implement gem dependencies
+      @doc_map = DocMap.new(unresolved_requires, []) # @todo Implement gem preferences
       @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 +153,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>]

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/doc_map.rb

@@ -8,7 +8,7 @@ module Solargraph
     attr_reader :requires
 
     # @return [Array<Gem::Specification>]
-    attr_reader :dependencies
+    attr_reader :preferences
 
     # @return [Array<Pin::Base>]
     attr_reader :pins
@@ -17,10 +17,10 @@ module Solargraph
     attr_reader :uncached_gemspecs
 
     # @param requires [Array<String>]
-    # @param dependencies [Array<Gem::Specification>]
-    def initialize(requires, dependencies)
+    # @param preferences [Array<Gem::Specification>]
+    def initialize(requires, preferences)
       @requires = requires.compact
-      @dependencies = dependencies.compact
+      @preferences = preferences.compact
       generate
     end
 
@@ -39,17 +39,11 @@ module Solargraph
       @gems_in_memory ||= {}
     end
 
-    private
-
-    # @return [Hash{String => Gem::Specification, nil}]
-    def required_gem_map
-      @required_gem_map ||= requires.to_h { |path| [path, resolve_path_to_gemspec(path)] }
+    def dependencies
+      @dependencies ||= (gemspecs.flat_map { |spec| fetch_dependencies(spec) } - gemspecs).to_set
     end
 
-    # @return [Hash{String => Gem::Specification}]
-    def dependency_map
-      @dependency_map ||= dependencies.to_h { |gemspec| [gemspec.name, gemspec] }
-    end
+    private
 
     # @return [void]
     def generate
@@ -62,6 +56,17 @@ module Solargraph
           try_stdlib_map path
         end
       end
+      dependencies.each { |dep| try_cache dep }
+    end
+
+    # @return [Hash{String => Gem::Specification, nil}]
+    def required_gem_map
+      @required_gem_map ||= requires.to_h { |path| [path, resolve_path_to_gemspec(path)] }
+    end
+
+    # @return [Hash{String => Gem::Specification}]
+    def preference_map
+      @preference_map ||= preferences.to_h { |gemspec| [gemspec.name, gemspec] }
     end
 
     # @param gemspec [Gem::Specification]
@@ -123,16 +128,16 @@ module Solargraph
           nil
         end
       end
-      return gemspec if dependencies.empty? || gemspec.nil?
+      gemspec_or_preference gemspec
+    end
 
-      if dependency_map.key?(gemspec.name)
-        return gemspec if gemspec.version == dependency_map[gemspec.name].version
+    # @param gemspec [Gem::Specification, nil]
+    # @return [Gem::Specification, nil]
+    def gemspec_or_preference gemspec
+      return gemspec unless gemspec && preference_map.key?(gemspec.name)
+      return gemspec if gemspec.version == preference_map[gemspec.name].version
 
-        change_gemspec_version gemspec, dependency_map[by_path.name].version
-      else
-        Solargraph.logger.warn "Gem #{gemspec.name} is not an expected dependency"
-        gemspec
-      end
+      change_gemspec_version gemspec, preference_map[by_path.name].version
     end
 
     # @param gemspec [Gem::Specification]
@@ -144,5 +149,23 @@ module Solargraph
       Solargraph.logger.info "Gem #{gemspec.name} version #{version} not found. Using #{gemspec.version} instead"
       gemspec
     end
+
+    # @param gemspec [Gem::Specification]
+    # @return [Array<Gem::Specification>]
+    def fetch_dependencies gemspec
+      only_runtime_dependencies(gemspec).each_with_object(Set.new) do |spec, deps|
+        Solargraph.logger.info "Adding #{spec.name} dependency for #{gemspec.name}"
+        dep = Gem::Specification.find_by_name(spec.name, spec.requirement)
+        deps.merge fetch_dependencies(dep) if deps.add?(dep)
+      rescue Gem::MissingSpecError
+        Solargraph.logger.warn "Gem dependency #{spec.name} #{spec.requirements} for #{gemspec.name} not found."
+      end.to_a
+    end
+
+    # @param gemspec [Gem::Specification]
+    # @return [Array<Gem::Dependency>]
+    def only_runtime_dependencies gemspec
+      gemspec.dependencies - gemspec.development_dependencies
+    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/dispatch.rb

@@ -95,6 +95,10 @@ module Solargraph
           nil
         end
 
+        def options
+          @options ||= {}.freeze
+        end
+
         # Get a generic library for the given URI and attach the corresponding
         # source.
         #
@@ -109,7 +113,7 @@ module Solargraph
 
         # @return [Library]
         def generic_library
-          @generic_library ||= Solargraph::Library.new
+          @generic_library ||= Solargraph::Library.new(Solargraph::Workspace.new('', nil, options), nil)
         end
       end
     end

data/lib/solargraph/language_server/host.rb

@@ -292,7 +292,8 @@ module Solargraph
         path = ''
         path = normalize_separators(directory) unless directory.nil?
         begin
-          lib = Solargraph::Library.load(path, name)
+          workspace = Solargraph::Workspace.new(path, nil, options)
+          lib = Solargraph::Library.new(workspace, name)
           libraries.push lib
           async_library_map lib
         rescue WorkspaceTooLargeError => e

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)
@@ -603,7 +615,7 @@ module Solargraph
 
       logger.info "Caching #{spec.name} #{spec.version}"
       Thread.new do
-        @cache_pid = Process.spawn('solargraph', 'cache', spec.name, spec.version.to_s)
+        @cache_pid = Process.spawn(workspace.command_path, 'cache', spec.name, spec.version.to_s)
         Process.wait(@cache_pid)
         logger.info "Cached #{spec.name} #{spec.version}"
         @synchronized = false

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

@@ -47,36 +47,19 @@ module Solargraph
       # @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)
+
         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 nil unless receiver_pin
+
+        types = receiver_pin.docstring.tag(:yieldreceiver)&.types
+        return nil 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/rbs_map/conversions.rb

@@ -38,25 +38,6 @@ module Solargraph
         environment = RBS::Environment.from_loader(loader).resolve_type_names
         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
       end
 
       # @param decl [RBS::AST::Declarations::Base]
@@ -303,26 +284,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,14 @@ 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>]')
       ]
 
       # HACK: Add Errno exception classes
@@ -38,7 +41,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

@@ -50,9 +50,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

@@ -299,6 +299,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 +328,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,7 +346,12 @@ 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?
                     # @todo Some level (strong, I guess) should require the param here
                   else

data/lib/solargraph/version.rb

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

data/lib/solargraph/workspace.rb

@@ -25,9 +25,11 @@ module Solargraph
 
     # @param directory [String]
     # @param config [Config, nil]
-    def initialize directory = '', config = nil
+    # @param server [Hash]
+    def initialize directory = '', config = nil, server = {}
       @directory = directory
       @config = config
+      @server = server
       load_sources
       @gemnames = []
       @require_paths = generate_require_paths
@@ -134,8 +136,19 @@ module Solargraph
       source_hash[updater.filename] = source_hash[updater.filename].synchronize(updater)
     end
 
+    # @return [String]
+    def command_path
+      server['commandPath'] || 'solargraph'
+    end
+
     private
 
+    # The language server configuration (or an empty hash if the workspace was
+    # not initialized from a server).
+    #
+    # @return [Hash]
+    attr_reader :server
+
     # @return [Hash{String => Solargraph::Source}]
     def source_hash
       @source_hash ||= {}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solargraph
 version: !ruby/object:Gem::Version
-  version: 0.53.1
+  version: 0.53.3
 platform: ruby
 authors:
 - Fred Snyder
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-26 00:00:00.000000000 Z
+date: 2025-03-29 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