solargraph 0.53.2 → 0.53.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd82572e0c8ca2d5e7477c4bbcd58fa66b318550a23b6944d8749f67913560e3
-  data.tar.gz: 79ba0becff2e00fbcc7139ec540e91db5dec195cf5ae557cdcf599026b11b964
+  metadata.gz: c5f84e528dd40d7638e36189ca6b4dceccdfd1722a07bd1c1f060bf0265aa815
+  data.tar.gz: 39d6938ccabce6dda403c709711f6136472def5982222e73d89310eaeb906ee1
 SHA512:
-  metadata.gz: 743c84f70a8d49f253f4fdf3e8b43a3061ad7cd6eec68fbbf592505d63d56666ae5654ca2664750a7963d43f5b131ff1c7bc52660266786d345c9a19b86856fa
-  data.tar.gz: 8accd71eec8ce6f5ccf3aa5efd692a3ff71ea35eabf125446fe533049df80bd84fb33bf73d0cdadd7914598d485ed1f013c7cc898575b1a34238c90e92d8318e
+  metadata.gz: cf06b94032becde9f26b7d5cedcecbc0fd7d6bde539a980c748328f11165f91398605e7ff49af502b83a70a4aa9b32406c5846cda96f5246d20c97d17220700b
+  data.tar.gz: bdddccf5d52efd2a9be2b00ac473065ecca21d76646d59d247c5cb93b14de137ebfc16ec4ffbc3ed0d6e9de9f271e9763808775d6aa271496e6328bf70b443bf

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 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,7 +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 +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/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/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

@@ -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,6 +346,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.3'
 end

metadata

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