solargraph 0.51.2 → 0.52.0

data/lib/solargraph/pin/namespace.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'solargraph/yard_tags'
+
 module Solargraph
   module Pin
     class Namespace < Closure
@@ -9,12 +11,12 @@ module Solargraph
       # @return [::Symbol] :class or :module
       attr_reader :type
 
-      attr_reader :parameters
+      attr_reader :generics
 
       # @param type [::Symbol] :class or :module
       # @param visibility [::Symbol] :public or :private
       # @param gates [Array<String>]
-      def initialize type: :class, visibility: :public, gates: [''], parameters: [], **splat
+      def initialize type: :class, visibility: :public, gates: [''], generics: nil, **splat
         # super(location, namespace, name, comments)
         super(**splat)
         @type = type
@@ -38,7 +40,7 @@ module Solargraph
           @closure = Pin::Namespace.new(name: closure_name, gates: [parts.join('::')])
           @context = nil
         end
-        @parameters = parameters
+        @generics = generics
       end
 
       def namespace
@@ -89,6 +91,11 @@ module Solargraph
           [path] + @open_gates
         end
       end
+
+      # @return [Array<String>]
+      def generics
+        @generics ||= docstring.tags(:generic).map(&:name)
+      end
     end
   end
 end

data/lib/solargraph/pin/parameter.rb

@@ -123,17 +123,16 @@ module Solargraph
           clip = api_map.clip_at(location.filename, location.range.start)
           locals = clip.locals - [self]
           meths = chain.define(api_map, closure, locals)
+          receiver_type = chain.base.infer(api_map, closure, locals)
           meths.each do |meth|
-            if meth.docstring.has_tag?(:yieldparam_single_parameter)
-              type = chain.base.infer(api_map, closure, locals)
-              if type.defined? && !type.subtypes.empty?
-                bmeth = chain.base.define(api_map, closure, locals).first
-                return type.subtypes.first.qualify(api_map, bmeth.context.namespace)
-              end
-            else
-              yps = meth.docstring.tags(:yieldparam)
-              unless yps[index].nil? or yps[index].types.nil? or yps[index].types.empty?
-                return ComplexType.try_parse(yps[index].types.first).self_to(chain.base.infer(api_map, closure, locals).namespace).qualify(api_map, meth.context.namespace)
+            yps = meth.docstring.tags(:yieldparam)
+            unless yps[index].nil? or yps[index].types.nil? or yps[index].types.empty?
+              yield_type = ComplexType.try_parse(yps[index].types.first)
+              if yield_type.generic? && receiver_type.defined?
+                namespace_pin = api_map.get_namespace_pins(meth.namespace, closure.namespace).first
+                return yield_type.resolve_generics(namespace_pin, receiver_type)
+              else
+                return yield_type.self_to(chain.base.infer(api_map, closure, locals).namespace).qualify(api_map, meth.context.namespace)
               end
             end
           end

data/lib/solargraph/pin/signature.rb

@@ -1,20 +1,28 @@
 module Solargraph
   module Pin
-    class Signature
+    class Signature < Base
       # @return [Array<Parameter>]
       attr_reader :parameters
 
       # @return [ComplexType]
       attr_reader :return_type
 
+      # @return [self]
       attr_reader :block
 
+      # @param parameters [Array<Parameter>]
+      # @param return_type [ComplexType]
+      # @param block [Signature, nil]
       def initialize parameters, return_type, block = nil
         @parameters = parameters
         @return_type = return_type
         @block = block
       end
 
+      def identity
+        @identity ||= "signature#{object_id}"
+      end
+
       def block?
         !!@block
       end

data/lib/solargraph/rbs_map/conversions.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'rbs'
+
 module Solargraph
   class RbsMap
     # Functions for converting RBS declarations to Solargraph pins
@@ -25,15 +27,42 @@ module Solargraph
 
       private
 
+      # @return Hash{String => RBS::AST::Declarations::TypeAlias}
       def type_aliases
         @type_aliases ||= {}
       end
 
+      # @param loader [RBS::EnvironmentLoader]
+      # @return [void]
+      def load_environment_to_pins(loader)
+        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 [Range<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]
       # @param closure [Pin::Closure]
       # @return [void]
       def convert_decl_to_pin decl, closure
-        cursor = pins.length
         case decl
         when RBS::AST::Declarations::Class
           class_decl_to_pin decl
@@ -46,18 +75,10 @@ module Solargraph
           module_decl_to_pin decl
         when RBS::AST::Declarations::Constant
           constant_decl_to_pin decl
-        end
-        pins[cursor..-1].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.closure,
-            name: 'new',
-            comments: pin.comments,
-            scope: :class
-          )
+        when RBS::AST::Declarations::ClassAlias
+          class_alias_decl_to_pin decl
+        else
+          Solargraph.logger.info "Skipping declaration #{decl.class}"
         end
       end
 
@@ -106,7 +127,7 @@ module Solargraph
           name: decl.name.relative!.to_s,
           closure: Solargraph::Pin::ROOT_PIN,
           comments: decl.comment&.string,
-          parameters: decl.type_params.map(&:name).map(&:to_s)
+          generics: decl.type_params.map(&:name).map(&:to_s)
         )
         pins.push class_pin
         if decl.super_class
@@ -142,16 +163,20 @@ module Solargraph
           type: :module,
           name: decl.name.relative!.to_s,
           closure: Solargraph::Pin::ROOT_PIN,
-          comments: decl.comment&.string
+          comments: decl.comment&.string,
+          generics: decl.type_params.map(&:name).map(&:to_s),
         )
         pins.push module_pin
         convert_members_to_pin decl, module_pin
       end
 
-      # @param decl [RBS::AST::Declarations::Constant]
-      # @return [void]
-      def constant_decl_to_pin decl
-        parts = decl.name.relative!.to_s.split('::')
+      # @param name [String]
+      # @param tag [String]
+      # @param comments [String]
+      #
+      # @return [Solargraph::Pin::Constant]
+      def create_constant(name, tag, comments)
+        parts = name.split('::')
         if parts.length > 1
           name = parts.last
           closure = pins.select { |pin| pin && pin.path == parts[0..-2].join('::') }.first
@@ -159,15 +184,31 @@ module Solargraph
           name = parts.first
           closure = Solargraph::Pin::ROOT_PIN
         end
-        pin = Solargraph::Pin::Constant.new(
+        constant_pin = Solargraph::Pin::Constant.new(
           name: name,
           closure: closure,
-          comments: decl.comment&.string
+          comments: comments
         )
-        tag = other_type_to_tag(decl.type)
         # @todo Class or Module?
-        pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', "Class<#{tag}>"))
-        pins.push pin
+        constant_pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', "Class<#{tag}>"))
+        constant_pin
+      end
+
+      # @param decl [RBS::AST::Declarations::ClassAlias]
+      # @return [void]
+      def class_alias_decl_to_pin decl
+        # See https://www.rubydoc.info/gems/rbs/3.4.3/RBS/AST/Declarations/ClassAlias
+        new_name = decl.new_name.relative!.to_s
+        old_name = decl.old_name.relative!.to_s
+
+        pins.push create_constant(new_name, old_name, decl.comment&.string)
+      end
+
+      # @param decl [RBS::AST::Declarations::Constant]
+      # @return [void]
+      def constant_decl_to_pin decl
+        tag = other_type_to_tag(decl.type)
+        pins.push create_constant(decl.name.relative!.to_s, tag, decl.comment&.string)
       end
 
       # @param decl [RBS::AST::Members::MethodDefinition]
@@ -243,7 +284,8 @@ module Solargraph
         end
         type.type.optional_positionals.each do |param|
           name = param.name ? param.name.to_s : "arg#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :optarg, name: name, closure: pin)
+          parameters.push Solargraph::Pin::Parameter.new(decl: :optarg, name: name, closure: pin,
+                                                         return_type: ComplexType.try_parse(other_type_to_tag(param.type)))
         end
         if type.type.rest_positionals
           name = type.type.rest_positionals.name ? type.type.rest_positionals.name.to_s : "arg#{arg_num += 1}"
@@ -253,13 +295,15 @@ module Solargraph
           name = param.name ? param.name.to_s : "arg#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin)
         end
-        type.type.required_keywords.each do |orig, _param|
+        type.type.required_keywords.each do |orig, param|
           name = orig ? orig.to_s : "arg#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :kwarg, name: name, closure: pin)
+          parameters.push Solargraph::Pin::Parameter.new(decl: :kwarg, name: name, closure: pin,
+                                                         return_type: ComplexType.try_parse(other_type_to_tag(param.type)))
         end
-        type.type.optional_keywords.each do |orig, _param|
+        type.type.optional_keywords.each do |orig, param|
           name = orig ? orig.to_s : "arg#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :kwoptarg, name: name, closure: pin)
+          parameters.push Solargraph::Pin::Parameter.new(decl: :kwoptarg, name: name, closure: pin,
+                                                         return_type: ComplexType.try_parse(other_type_to_tag(param.type)))
         end
         if type.type.rest_keywords
           name = type.type.rest_keywords.name ? type.type.rest_keywords.name.to_s : "arg#{arg_num += 1}"
@@ -329,6 +373,7 @@ module Solargraph
         )
       end
 
+      # @param decl [RBS::AST::Members::Alias]
       def alias_to_pin decl, closure
         pins.push Solargraph::Pin::MethodAlias.new(
           name: decl.new_name.to_s,
@@ -345,6 +390,8 @@ module Solargraph
         'NilClass' => 'nil'
       }
 
+      # @param type [RBS::AST::Members::MethodDefinition::Overload]
+      # @return [String]
       def method_type_to_tag type
         if type_aliases.key?(type.type.return_type.to_s)
           other_type_to_tag(type_aliases[type.type.return_type.to_s].type)
@@ -378,16 +425,24 @@ module Solargraph
         elsif type.is_a?(RBS::Types::Bases::Void)
           'void'
         elsif type.is_a?(RBS::Types::Variable)
-          "param<#{type.name}>"
+          "#{Solargraph::ComplexType::GENERIC_TAG_NAME}<#{type.name}>"
         elsif type.is_a?(RBS::Types::ClassInstance) #&& !type.args.empty?
           base = RBS_TO_YARD_TYPE[type.name.relative!.to_s] || type.name.relative!.to_s
           params = type.args.map { |a| other_type_to_tag(a) }.reject { |t| t == 'undefined' }
           return base if params.empty?
           "#{base}<#{params.join(', ')}>"
+        elsif type.is_a?(RBS::Types::Bases::Instance)
+          'self'
+        elsif type.is_a?(RBS::Types::Bases::Top) || type.is_a?(RBS::Types::Bases::Bottom)
+          'self'
+        elsif type.is_a?(RBS::Types::Intersection)
+          type.types.map { |member| other_type_to_tag(member) }.join(', ')
+        elsif type.is_a?(RBS::Types::Proc)
+          'Proc'
         elsif type.respond_to?(:name) && type.name.respond_to?(:relative!)
           RBS_TO_YARD_TYPE[type.name.relative!.to_s] || type.name.relative!.to_s
         else
-          Solargraph.logger.warn "Unrecognized RBS type: #{type.class} #{type}"
+          Solargraph.logger.warn "Unrecognized RBS type: #{type.class} at #{type.location}"
           'undefined'
         end
       end

data/lib/solargraph/rbs_map/core_fills.rb

@@ -16,8 +16,10 @@ module Solargraph
       ].map { |k| Pin::Keyword.new(k) }
 
       MISSING = [
-        Solargraph::Pin::Method.new(name: 'tap', scope: :instance, closure: Solargraph::Pin::Namespace.new(name: 'Object')),
-        Solargraph::Pin::Method.new(name: 'class', scope: :instance, closure: Solargraph::Pin::Namespace.new(name: 'Object'), comments: '@return [Class<self>]')
+        Solargraph::Pin::Method.new(name: 'tap', scope: :instance,
+                                    closure: Solargraph::Pin::Namespace.new(name: 'Object')),
+        Solargraph::Pin::Method.new(name: 'class', scope: :instance,
+                                    closure: Solargraph::Pin::Namespace.new(name: 'Object'), comments: '@return [Class<self>]')
       ]
 
       YIELDPARAMS = [
@@ -27,7 +29,7 @@ module Solargraph
         )),
         Override.from_comment('String#each_line', %(
 @yieldparam [String]
-        )),
+        ))
       ]
 
       methods_with_yieldparam_subtypes = %w[
@@ -39,16 +41,14 @@ module Solargraph
       ]
 
       YIELDPARAM_SINGLE_PARAMETERS = methods_with_yieldparam_subtypes.map do |path|
-        Override.from_comment(path, %(
-@yieldparam_single_parameter
-          ))
+        Override.from_comment(path, <<~DOC
+          @yieldparam [generic<Elem>]
+        DOC
+        )
       end
 
       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>'),
       ]
 
       # HACK: Add Errno exception classes
@@ -64,4 +64,3 @@ module Solargraph
     end
   end
 end
-

data/lib/solargraph/rbs_map/core_map.rb

@@ -14,7 +14,7 @@ module Solargraph
         else
           loader = RBS::EnvironmentLoader.new(repository: RBS::Repository.new(no_stdlib: false))
           environment = RBS::Environment.from_loader(loader).resolve_type_names
-          environment.declarations.each { |decl| convert_decl_to_pin(decl, Solargraph::Pin::ROOT_PIN) }
+          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) }
           pins.replace processed

data/lib/solargraph/rbs_map.rb

@@ -24,8 +24,7 @@ module Solargraph
       loader = RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
       add_library loader, library
       return unless resolved?
-      environment = RBS::Environment.from_loader(loader).resolve_type_names
-      environment.declarations.each { |decl| convert_decl_to_pin(decl, Solargraph::Pin::ROOT_PIN) }
+      load_environment_to_pins(loader)
     end
 
     def path_pin path
@@ -57,7 +56,7 @@ module Solargraph
     # @return [Boolean] true if adding the library succeeded
     def add_library loader, library
       @resolved = if loader.has_library?(library: library, version: nil)
-        loader.add library: library
+        loader.add library: library, version: nil
         Solargraph.logger.info "#{short_name} successfully loaded library #{library}"
         true
       else

data/lib/solargraph/source/chain/array.rb

@@ -0,0 +1,29 @@
+module Solargraph
+  class Source
+    class Chain
+      class Array < Literal
+        # @param type [String]
+        def initialize children
+          super('::Array')
+          @children = children
+        end
+
+        def word
+          @word ||= "<#{@type}>"
+        end
+
+        def resolve api_map, name_pin, locals
+          child_types = @children.map do |child|
+            child.infer(api_map, name_pin, locals).tag
+          end
+          type = if child_types.uniq.length == 1 && child_types.first != 'undefined'
+                   "::Array<#{child_types.first}>"
+                 else
+                   '::Array'
+                 end
+          [Pin::ProxyType.anonymous(ComplexType.try_parse(type))]
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/call.rb

@@ -11,7 +11,7 @@ module Solargraph
         attr_reader :arguments
 
         # @param word [String]
-        # @param arguments [Array<Chain>]
+        # @param arguments [::Array<Chain>]
         # @param with_block [Boolean] True if the chain is inside a block
         # @param head [Boolean] True if the call is the start of its chain
         def initialize word, arguments = [], with_block = false
@@ -26,9 +26,10 @@ module Solargraph
 
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
-        # @param locals [Array<Pin::Base>]
+        # @param locals [::Array<Pin::Base>]
         def resolve api_map, name_pin, locals
           return super_pins(api_map, name_pin) if word == 'super'
+          return yield_pins(api_map, name_pin) if word == 'yield'
           found = if head?
             locals.select { |p| p.name == word }
           else
@@ -75,27 +76,12 @@ module Solargraph
                 end
               end
               if match
-                type = extra_return_type(p.docstring, context)
-                break if type
                 type = with_params(ol.return_type.self_to(context.to_s), context).qualify(api_map, context.namespace) if ol.return_type.defined?
                 type ||= ComplexType::UNDEFINED
               end
               break if type.defined?
             end
             next p.proxy(type) if type.defined?
-            type = extra_return_type(p.docstring, context)
-            if type
-              next Solargraph::Pin::Method.new(
-                location: p.location,
-                closure: p.closure,
-                name: p.name,
-                comments: "@return [#{context.subtypes.first.to_s}]",
-                scope: p.scope,
-                visibility: p.visibility,
-                parameters: p.parameters,
-                node: p.node
-              )
-            end
             if p.is_a?(Pin::Method) && !p.macros.empty?
               result = process_macro(p, api_map, context, locals)
               next result unless result.return_type.undefined?
@@ -170,18 +156,6 @@ module Solargraph
           Pin::ProxyType.anonymous(ComplexType::UNDEFINED)
         end
 
-        # @param docstring [YARD::Docstring]
-        # @param context [ComplexType]
-        # @return [ComplexType]
-        def extra_return_type docstring, context
-          if docstring.has_tag?(:return_single_parameter) #&& context.subtypes.one?
-            return context.subtypes.first || ComplexType::UNDEFINED
-          elsif docstring.has_tag?(:return_value_parameter) && context.value_types.one?
-            return context.value_types.first
-          end
-          nil
-        end
-
         # @param arguments [Array<Chain>]
         # @param signature [Pin::Signature]
         # @return [Boolean]
@@ -197,12 +171,22 @@ module Solargraph
 
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
-        # @return [Array<Pin::Base>]
+        # @return [::Array<Pin::Base>]
         def super_pins api_map, name_pin
           pins = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.context.scope)
           pins.reject{|p| p.path == name_pin.path}
         end
 
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @return [::Array<Pin::Base>]
+        def yield_pins api_map, name_pin
+          method_pin = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.context.scope).first
+          return [] if method_pin.nil?
+
+          method_pin.signatures.map(&:block).compact
+        end
+
         # @param type [ComplexType]
         # @param context [ComplexType]
         def with_params type, context

data/lib/solargraph/source/chain/link.rb

@@ -24,7 +24,7 @@ module Solargraph
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
         # @param locals [Array<Pin::Base>]
-        # @return [Array<Pin::Base>]
+        # @return [::Array<Pin::Base>]
         def resolve api_map, name_pin, locals
           []
         end

data/lib/solargraph/source/chain/z_super.rb

@@ -20,7 +20,7 @@ module Solargraph
 
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
-        # @param locals [Array<Pin::Base>]
+        # @param locals [::Array<Pin::Base>]
         def resolve api_map, name_pin, locals
           return super_pins(api_map, name_pin)
         end

data/lib/solargraph/source/chain.rb

@@ -23,6 +23,7 @@ module Solargraph
       autoload :BlockVariable,    'solargraph/source/chain/block_variable'
       autoload :ZSuper,           'solargraph/source/chain/z_super'
       autoload :Hash,             'solargraph/source/chain/hash'
+      autoload :Array,            'solargraph/source/chain/array'
 
       @@inference_stack = []
       @@inference_depth = 0
@@ -30,12 +31,12 @@ module Solargraph
       UNDEFINED_CALL = Chain::Call.new('<undefined>')
       UNDEFINED_CONSTANT = Chain::Constant.new('<undefined>')
 
-      # @return [Array<Source::Chain::Link>]
+      # @return [::Array<Source::Chain::Link>]
       attr_reader :links
 
       attr_reader :node
 
-      # @param links [Array<Chain::Link>]
+      # @param links [::Array<Chain::Link>]
       def initialize links, node = nil, splat = false
         @links = links.clone
         @links.push UNDEFINED_CALL if @links.empty?
@@ -57,7 +58,7 @@ module Solargraph
       # @param api_map [ApiMap]
       # @param name_pin [Pin::Base]
       # @param locals [Array<Pin::Base>]
-      # @return [Array<Pin::Base>]
+      # @return [::Array<Pin::Base>]
       def define api_map, name_pin, locals
         return [] if undefined?
         working_pin = name_pin
@@ -122,17 +123,13 @@ module Solargraph
         pins.each do |pin|
           # Avoid infinite recursion
           next if @@inference_stack.include?(pin.identity)
+
           @@inference_stack.push pin.identity
           type = pin.typify(api_map)
           @@inference_stack.pop
           if type.defined?
-            if type.parameterized?
-              type = type.resolve_parameters(pin.closure, context)
-              # idx = pin.closure.parameters.index(type.subtypes.first.name)
-              # next if idx.nil?
-              # param_type = context.return_type.all_params[idx]
-              # next unless param_type
-              # type = ComplexType.try_parse(param_type.to_s)
+            if type.generic?
+              type = type.resolve_generics(pin.closure, context.return_type)
             end
             if type.defined?
               possibles.push type
@@ -143,10 +140,12 @@ module Solargraph
         if possibles.empty?
           # Limit method inference recursion
           return ComplexType::UNDEFINED if @@inference_depth >= 10 && pins.first.is_a?(Pin::Method)
+
           @@inference_depth += 1
           pins.each do |pin|
             # Avoid infinite recursion
             next if @@inference_stack.include?(pin.identity)
+
             @@inference_stack.push pin.identity
             type = pin.probe(api_map)
             @@inference_stack.pop

data/lib/solargraph/source/source_chainer.rb

@@ -47,6 +47,8 @@ module Solargraph
           elsif source.parsed? && source.repaired? && end_of_phrase == '.'
             node, parent = source.tree_at(fixed_position.line, fixed_position.column)[0..2]
             node = Parser.parse(fixed_phrase) if node.nil?
+          elsif source.repaired?
+            node = Parser.parse(fixed_phrase)
           else
             node, parent = source.tree_at(fixed_position.line, fixed_position.column)[0..2] unless source.error_ranges.any?{|r| r.nil? || r.include?(fixed_position)}
             # Exception for positions that chain literal nodes in unsynchronized sources

data/lib/solargraph/source.rb

@@ -33,7 +33,7 @@ module Solargraph
     attr_reader :version
 
     # @param code [String]
-    # @param filename [String]
+    # @param filename [String, nil]
     # @param version [Integer]
     def initialize code, filename = nil, version = 0
       @code = normalize(code)
@@ -332,7 +332,7 @@ module Solargraph
 
     # @param top [Parser::AST::Node]
     # @param result [Array<Range>]
-    # @param parent [Symbol]
+    # @param parent [Symbol, nil]
     # @return [void]
     def inner_folding_ranges top, result = [], parent = nil
       return unless Parser.is_ast_node?(top)
@@ -503,7 +503,7 @@ module Solargraph
       end
 
       # @param code [String]
-      # @param filename [String]
+      # @param filename [String, nil]
       # @param version [Integer]
       # @return [Solargraph::Source]
       def load_string code, filename = nil, version = 0

data/lib/solargraph/source_map/clip.rb

@@ -115,21 +115,6 @@ module Solargraph
         @context_pin ||= source_map.locate_named_path_pin(cursor.node_position.line, cursor.node_position.character)
       end
 
-      # @return [Array<Pin::Base>]
-      def yielded_self_pins
-        return [] unless block.is_a?(Pin::Block) && block.receiver
-        chain = Parser.chain(block.receiver, source_map.source.filename)
-        receiver_pin = chain.define(api_map, context_pin, locals).first
-        return [] if receiver_pin.nil?
-        result = []
-        ys = receiver_pin.docstring.tag(:yieldpublic)
-        unless ys.nil? || ys.types.empty?
-          ysct = ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace)
-          result.concat api_map.get_complex_type_methods(ysct, '', false)
-        end
-        result
-      end
-
       # @return [Array<Pin::KeywordParam]
       def complete_keyword_parameters
         return [] unless cursor.argument? && cursor.chain.links.one? && cursor.word =~ /^[a-z0-9_]*:?$/
@@ -226,7 +211,6 @@ module Solargraph
             result.concat api_map.get_methods('Kernel')
             # result.concat ApiMap.keywords
             result.concat api_map.keyword_pins.to_a
-            result.concat yielded_self_pins
           end
         end
         package_completions(result)