solargraph 0.56.1 → 0.57.0

data/lib/solargraph/rbs_map/conversions.rb

@@ -22,12 +22,14 @@ module Solargraph
         end
       end
 
+      # @param loader [RBS::EnvironmentLoader]
       def initialize(loader:)
         @loader = loader
         @pins = []
         load_environment_to_pins(loader)
       end
 
+      # @return [RBS::EnvironmentLoader]
       attr_reader :loader
 
       # @return [Array<Pin::Base>]
@@ -106,14 +108,14 @@ module Solargraph
       # @param closure [Pin::Namespace]
       # @return [void]
       def convert_members_to_pins decl, closure
-        context = Context.new
+        context = Conversions::Context.new
         decl.members.each { |m| context = convert_member_to_pin(m, closure, context) }
       end
 
       # @param member [RBS::AST::Members::Base,RBS::AST::Declarations::Base]
       # @param closure [Pin::Namespace]
       # @param context [Context]
-      # @return [void]
+      # @return [Context]
       def convert_member_to_pin member, closure, context
         case member
         when RBS::AST::Members::MethodDefinition
@@ -161,9 +163,10 @@ module Solargraph
             generic_defaults[param.name.to_s] = ComplexType.parse(tag).force_rooted
           end
         end
+        class_name = decl.name.relative!.to_s
         class_pin = Solargraph::Pin::Namespace.new(
           type: :class,
-          name: decl.name.relative!.to_s,
+          name: class_name,
           closure: Solargraph::Pin::ROOT_PIN,
           comments: decl.comment&.string,
           type_location: location_decl_to_pin_location(decl.location),
@@ -178,11 +181,12 @@ module Solargraph
         if decl.super_class
           type = build_type(decl.super_class.name, decl.super_class.args)
           generic_values = type.all_params.map(&:to_s)
+          superclass_name = decl.super_class.name.to_s
           pins.push Solargraph::Pin::Reference::Superclass.new(
             type_location: location_decl_to_pin_location(decl.super_class.location),
             closure: class_pin,
             generic_values: generic_values,
-            name: decl.super_class.name.relative!.to_s,
+            name: superclass_name,
             source: :rbs
           )
         end
@@ -295,6 +299,7 @@ module Solargraph
           name: name,
           closure: closure,
           comments: decl.comment&.string,
+          type_location: location_decl_to_pin_location(decl.location),
           source: :rbs
         )
         rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
@@ -316,6 +321,7 @@ module Solargraph
       #   related overrides
       # @todo externalize remaining overrides into yaml file, then
       #   allow that to be extended via .solargraph.yml
+      # @type [Hash{Array(String, Symbol, String) => Symbol}
       VISIBILITY_OVERRIDE = {
         ["Rails::Engine", :instance, "run_tasks_blocks"] => :protected,
         # Should have been marked as both instance and class method in module -e.g., 'module_function'
@@ -340,6 +346,13 @@ module Solargraph
         ["Rainbow::Presenter", :instance, "wrap_with_sgr"] => :private,
       }
 
+      # @param decl [RBS::AST::Members::MethodDefinition, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrAccessor]
+      # @param closure [Pin::Closure]
+      # @param context [Context]
+      # @param scope [Symbol] :instance or :class
+      # @param name [String] The name of the method
+      # @sg-ignore
+      # @return [Symbol]
       def calculate_method_visibility(decl, context, closure, scope, name)
         override_key = [closure.path, scope, name]
         visibility = VISIBILITY_OVERRIDE[override_key]
@@ -414,15 +427,16 @@ module Solargraph
       # @return [void]
       def method_def_to_sigs decl, pin
         decl.overloads.map do |overload|
+          type_location = location_decl_to_pin_location(overload.method_type.location)
           generics = overload.method_type.type_params.map(&:name).map(&:to_s)
           signature_parameters, signature_return_type = parts_of_function(overload.method_type, pin)
           block = if overload.method_type.block
                     block_parameters, block_return_type = parts_of_function(overload.method_type.block, pin)
-                    Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type,
-                                       closure: pin, source: :rbs)
+                    Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type, source: :rbs,
+                                       type_location: type_location, closure: pin)
                   end
-          Pin::Signature.new(generics: generics, parameters: signature_parameters, return_type: signature_return_type, block: block,
-                             closure: pin, source: :rbs)
+          Pin::Signature.new(generics: generics, parameters: signature_parameters, return_type: signature_return_type, block: block, source: :rbs,
+                             type_location: type_location, closure: pin)
         end
       end
 
@@ -441,44 +455,52 @@ module Solargraph
       # @param pin [Pin::Method]
       # @return [Array(Array<Pin::Parameter>, ComplexType)]
       def parts_of_function type, pin
-        return [[Solargraph::Pin::Parameter.new(decl: :restarg, name: 'arg', closure: pin, source: :rbs)], ComplexType.try_parse(method_type_to_tag(type)).force_rooted] if defined?(RBS::Types::UntypedFunction) && type.type.is_a?(RBS::Types::UntypedFunction)
+        type_location = pin.type_location
+        if defined?(RBS::Types::UntypedFunction) && type.type.is_a?(RBS::Types::UntypedFunction)
+          return [
+            [Solargraph::Pin::Parameter.new(decl: :restarg, name: 'arg', closure: pin, source: :rbs, type_location: type_location)],
+            ComplexType.try_parse(method_type_to_tag(type)).force_rooted
+          ]
+        end
 
         parameters = []
         arg_num = -1
         type.type.required_positionals.each do |param|
           name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted, source: :rbs)
+          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted, source: :rbs, type_location: type_location)
         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,
                                                          return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted,
+                                                         type_location: type_location,
                                                          source: :rbs)
         end
         if type.type.rest_positionals
           name = type.type.rest_positionals.name ? type.type.rest_positionals.name.to_s : "arg_#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :restarg, name: name, closure: pin, source: :rbs)
+          parameters.push Solargraph::Pin::Parameter.new(decl: :restarg, name: name, closure: pin, source: :rbs, type_location: type_location)
         end
         type.type.trailing_positionals.each do |param|
           name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, source: :rbs)
+          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, source: :rbs, type_location: type_location)
         end
         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,
                                                          return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted,
-                                                         source: :rbs)
+                                                         source: :rbs, type_location: type_location)
         end
         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,
                                                          return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted,
+                                                         type_location: type_location,
                                                          source: :rbs)
         end
         if type.type.rest_keywords
           name = type.type.rest_keywords.name ? type.type.rest_keywords.name.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :kwrestarg, name: type.type.rest_keywords.name.to_s, closure: pin,
-                                                         source: :rbs)
+                                                         source: :rbs, type_location: type_location)
         end
 
         rooted_tag = method_type_to_tag(type)
@@ -488,6 +510,7 @@ module Solargraph
 
       # @param decl [RBS::AST::Members::AttrReader,RBS::AST::Members::AttrAccessor]
       # @param closure [Pin::Namespace]
+      # @param context [Context]
       # @return [void]
       def attr_reader_to_pin(decl, closure, context)
         name = decl.name.to_s
@@ -511,14 +534,16 @@ module Solargraph
 
       # @param decl [RBS::AST::Members::AttrWriter, RBS::AST::Members::AttrAccessor]
       # @param closure [Pin::Namespace]
+      # @param context [Context]
       # @return [void]
       def attr_writer_to_pin(decl, closure, context)
         final_scope = decl.kind == :instance ? :instance : :class
         name = "#{decl.name.to_s}="
         visibility = calculate_method_visibility(decl, context, closure, final_scope, name)
+        type_location = location_decl_to_pin_location(decl.location)
         pin = Solargraph::Pin::Method.new(
           name: name,
-          type_location: location_decl_to_pin_location(decl.location),
+          type_location: type_location,
           closure: closure,
           parameters: [],
           comments: decl.comment&.string,
@@ -532,7 +557,8 @@ module Solargraph
             name: 'value',
             return_type: ComplexType.try_parse(other_type_to_tag(decl.type)).force_rooted,
             source: :rbs,
-            closure: pin
+            closure: pin,
+            type_location: type_location
           )
         rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', rooted_tag))
@@ -541,6 +567,7 @@ module Solargraph
 
       # @param decl [RBS::AST::Members::AttrAccessor]
       # @param closure [Pin::Namespace]
+      # @param context [Context]
       # @return [void]
       def attr_accessor_to_pin(decl, closure, context)
         attr_reader_to_pin(decl, closure, context)
@@ -572,6 +599,7 @@ module Solargraph
           name: name,
           closure: closure,
           comments: decl.comment&.string,
+          type_location: location_decl_to_pin_location(decl.location),
           source: :rbs
         )
         rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
@@ -588,6 +616,7 @@ module Solargraph
           name: name,
           closure: closure,
           comments: decl.comment&.string,
+          type_location: location_decl_to_pin_location(decl.location),
           source: :rbs
         )
         rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
@@ -672,13 +701,13 @@ module Solargraph
       # @return [ComplexType::UniqueType]
       def build_type(type_name, type_args = [])
         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' }.map do |t|
+        params = type_args.map { |a| other_type_to_tag(a) }.map do |t|
           ComplexType.try_parse(t).force_rooted
         end
         if base == 'Hash' && params.length == 2
           ComplexType::UniqueType.new(base, [params.first], [params.last], rooted: true, parameters_type: :hash)
         else
-          ComplexType::UniqueType.new(base, [], params, rooted: true, parameters_type: :list)
+          ComplexType::UniqueType.new(base, [], params.reject(&:undefined?), rooted: true, parameters_type: :list)
         end
       end
 

data/lib/solargraph/rbs_map/core_map.rb

@@ -14,6 +14,7 @@ module Solargraph
 
       def initialize; end
 
+      # @return [Enumerable<Pin::Base>]
       def pins
         return @pins if @pins
 
@@ -39,10 +40,12 @@ module Solargraph
 
       private
 
+      # @return [RBS::EnvironmentLoader]
       def loader
         @loader ||= RBS::EnvironmentLoader.new(repository: RBS::Repository.new(no_stdlib: false))
       end
 
+      # @return [Conversions]
       def conversions
         @conversions ||= Conversions.new(loader: loader)
       end

data/lib/solargraph/rbs_map.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'digest'
 require 'pathname'
 require 'rbs'
 
@@ -22,7 +23,8 @@ module Solargraph
     attr_reader :rbs_collection_config_path
 
     # @param library [String]
-    # @param version [String, nil]
+    # @param version [String, nil
+    # @param rbs_collection_config_path [String, Pathname, nil]
     # @param rbs_collection_paths [Array<Pathname, String>]
     def initialize library, version = nil, rbs_collection_config_path: nil, rbs_collection_paths: []
       if rbs_collection_config_path.nil? && !rbs_collection_paths.empty?
@@ -35,16 +37,18 @@ module Solargraph
       add_library loader, library, version
     end
 
+    # @return [RBS::EnvironmentLoader]
     def loader
       @loader ||= RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
     end
 
-    # @return string representing the version of the RBS info fetched
+    # @return [String] representing the version of the RBS info fetched
     #   for the given library.  Must change when the RBS info is
     #   updated upstream for the same library and version.  May change
     #   if the config for where information comes form changes.
     def cache_key
       @hextdigest ||= begin
+        # @type [String, nil]
         data = nil
         if rbs_collection_config_path
           lockfile_path = RBS::Collection::Config.to_lockfile_path(Pathname.new(rbs_collection_config_path))
@@ -68,6 +72,10 @@ module Solargraph
       end
     end
 
+    # @param gemspec [Gem::Specification]
+    # @param rbs_collection_path [String, Pathname, nil]
+    # @param rbs_collection_config_path [String, Pathname, nil]
+    # @return [RbsMap]
     def self.from_gemspec gemspec, rbs_collection_path, rbs_collection_config_path
       rbs_map = RbsMap.new(gemspec.name, gemspec.version,
                            rbs_collection_paths: [rbs_collection_path].compact,
@@ -80,6 +88,7 @@ module Solargraph
                  rbs_collection_config_path: rbs_collection_config_path)
     end
 
+    # @return [Array<Pin::Base>]
     def pins
       @pins ||= resolved? ? conversions.pins : []
     end
@@ -103,6 +112,7 @@ module Solargraph
       @resolved
     end
 
+    # @return [RBS::Repository]
     def repository
       @repository ||= RBS::Repository.new(no_stdlib: false).tap do |repo|
         @rbs_collection_paths.each do |dir|
@@ -120,16 +130,19 @@ module Solargraph
 
     private
 
+    # @return [RBS::EnvironmentLoader]
     def loader
       @loader ||= RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
     end
 
+    # @return [Conversions]
     def conversions
       @conversions ||= Conversions.new(loader: loader)
     end
 
     # @param loader [RBS::EnvironmentLoader]
     # @param library [String]
+    # @param version [String, nil]
     # @return [Boolean] true if adding the library succeeded
     def add_library loader, library, version
       @resolved = if loader.has_library?(library: library, version: version)

data/lib/solargraph/shell.rb

@@ -36,6 +36,7 @@ module Solargraph
         Signal.trap("TERM") do
           Backport.stop
         end
+        # @sg-ignore Wrong argument type for Backport.prepare_tcp_server: adapter expected Backport::Adapter, received Module<Solargraph::LanguageServer::Transport::Adapter>
         Backport.prepare_tcp_server host: options[:host], port: port, adapter: Solargraph::LanguageServer::Transport::Adapter
         STDERR.puts "Solargraph is listening PORT=#{port} PID=#{Process.pid}"
       end
@@ -52,6 +53,7 @@ module Solargraph
         Signal.trap("TERM") do
           Backport.stop
         end
+        # @sg-ignore Wrong argument type for Backport.prepare_stdio_server: adapter expected Backport::Adapter, received Module<Solargraph::LanguageServer::Transport::Adapter>
         Backport.prepare_stdio_server adapter: Solargraph::LanguageServer::Transport::Adapter
         STDERR.puts "Solargraph is listening on stdio PID=#{Process.pid}"
       end
@@ -258,6 +260,7 @@ module Solargraph
     end
 
     # @param gemspec [Gem::Specification]
+    # @param api_map [ApiMap]
     # @return [void]
     def do_cache gemspec, api_map
       # @todo if the rebuild: option is passed as a positional arg,

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

@@ -17,7 +17,13 @@ module Solargraph
           @word = word
         end
 
-        # @sg-ignore Fix "Not enough arguments to Module#protected"
+        # @sg-ignore two problems - Declared return type
+        #   ::Solargraph::Source::Chain::Array does not match inferred
+        #   type ::Array(::Class<::Solargraph::Source::Chain::Link>,
+        #   ::String) for
+        #   Solargraph::Source::Chain::Link#equality_fields
+        #   and
+        #   Not enough arguments to Module#protected
         protected def equality_fields
           [self.class, word]
         end
@@ -39,6 +45,7 @@ module Solargraph
         end
 
         # debugging description of contents; not for machine use
+        # @return [String]
         def desc
           word
         end
@@ -74,6 +81,8 @@ module Solargraph
         end
 
         # debugging description of contents; not for machine use
+        #
+        # @return [String]
         def desc
           word
         end

data/lib/solargraph/source/chain.rb

@@ -15,6 +15,7 @@ module Solargraph
     #
     class Chain
       include Equality
+      include Logging
 
       autoload :Link,             'solargraph/source/chain/link'
       autoload :Call,             'solargraph/source/chain/call'
@@ -75,7 +76,9 @@ module Solargraph
 
       # Determine potential Pins returned by this chain of words
       #
-      # @param api_map [ApiMap] @param name_pin [Pin::Base] A pin
+      # @param api_map [ApiMap]
+      #
+      # @param name_pin [Pin::Base] A pin
       # representing the place in which expression is evaluated (e.g.,
       # a Method pin, or a Module or Class pin if not run within a
       # method - both in terms of the closure around the chain, as well
@@ -192,6 +195,7 @@ module Solargraph
 
       include Logging
 
+      # @return [String]
       def desc
         links.map(&:desc).to_s
       end
@@ -265,7 +269,10 @@ module Solargraph
                else
                  ComplexType.new(types)
                end
-        return type if context.nil? || context.return_type.undefined?
+        if context.nil? || context.return_type.undefined?
+          # up to downstream to resolve self type
+          return type
+        end
 
         type.self_to_type(context.return_type)
       end

data/lib/solargraph/source/change.rb

@@ -28,7 +28,7 @@ module Solargraph
       #   syntax errors will be repaired.
       # @return [String] The updated text.
       def write text, nullable = false
-        if nullable and !range.nil? and new_text.match(/[\.\[\{\(@\$:]$/)
+        if nullable and !range.nil? and new_text.match(/[.\[{(@$:]$/)
           [':', '@'].each do |dupable|
             next unless new_text == dupable
             offset = Position.to_offset(text, range.start)
@@ -59,7 +59,7 @@ module Solargraph
         else
           result = commit text, fixed
           off = Position.to_offset(text, range.start)
-          match = result[0, off].match(/[\.:]+\z/)
+          match = result[0, off].match(/[.:]+\z/)
           if match
             result = result[0, off].sub(/#{match[0]}\z/, ' ' * match[0].length) + result[off..-1]
           end

data/lib/solargraph/source/cursor.rb

@@ -35,7 +35,6 @@ module Solargraph
       # The part of the word before the current position. Given the text
       # `foo.bar`, the start_of_word at position(0, 6) is `ba`.
       #
-      # @sg-ignore Improve resolution of String#match below
       # @return [String]
       def start_of_word
         @start_of_word ||= begin
@@ -125,7 +124,7 @@ module Solargraph
       def node_position
         @node_position ||= begin
           if start_of_word.empty?
-            match = source.code[0, offset].match(/[\s]*(\.|:+)[\s]*$/)
+            match = source.code[0, offset].match(/\s*(\.|:+)\s*$/)
             if match
               Position.from_offset(source.code, offset - match[0].length)
             else
@@ -160,7 +159,7 @@ module Solargraph
       #
       # @return [Regexp]
       def end_word_pattern
-        /^([a-z0-9_]|[^\u0000-\u007F])*[\?\!]?/i
+        /^([a-z0-9_]|[^\u0000-\u007F])*[?!]?/i
       end
     end
   end

data/lib/solargraph/source/source_chainer.rb

@@ -97,7 +97,7 @@ module Solargraph
       # @return [String]
       def end_of_phrase
         @end_of_phrase ||= begin
-          match = phrase.match(/[\s]*(\.{1}|::)[\s]*$/)
+          match = phrase.match(/\s*(\.{1}|::)\s*$/)
           if match
             match[0]
           else

data/lib/solargraph/source.rb

@@ -30,7 +30,7 @@ module Solargraph
       @node
     end
 
-    # @return [Hash{Integer => Array<String>}]
+    # @return [Hash{Integer => Solargraph::Parser::Snippet}]
     def comments
       finalize
       @comments
@@ -235,6 +235,7 @@ module Solargraph
     # @return [Hash{Integer => String}]
     def associated_comments
       @associated_comments ||= begin
+        # @type [Hash{Integer => String}]
         result = {}
         buffer = String.new('')
         # @type [Integer, nil]
@@ -317,7 +318,7 @@ module Solargraph
       @string_nodes ||= string_nodes_in(node)
     end
 
-    # @return [Array<Range>]
+    # @return [Array<Solargraph::Range>]
     def comment_ranges
       @comment_ranges ||= comments.values.map(&:range)
     end
@@ -386,6 +387,7 @@ module Solargraph
     # @return [Integer]
     attr_writer :version
 
+    # @return [void]
     def finalize
       return if @finalized && changes.empty?
 
@@ -440,6 +442,7 @@ module Solargraph
     # @return [String]
     attr_writer :repaired
 
+    # @return [String]
     def repaired
       finalize
       @repaired

data/lib/solargraph/source_map/clip.rb

@@ -65,7 +65,7 @@ module Solargraph
       # position. Locals can be local variables, method parameters, or block
       # parameters. The array starts with the nearest local pin.
       #
-      # @return [::Array<Solargraph::Pin::Base>]
+      # @return [::Array<Solargraph::Pin::LocalVariable>]
       def locals
         @locals ||= source_map.locals_at(location)
       end

data/lib/solargraph/source_map/data.rb

@@ -3,15 +3,18 @@
 module Solargraph
   class SourceMap
     class Data
+      # @param source [Solargraph::Source]
       def initialize source
         @source = source
       end
 
+      # @return [Array<Solargraph::Pin::Base>]
       def pins
         generate
         @pins || []
       end
 
+      # @return [Array<Solargraph::LocalVariable>]
       def locals
         generate
         @locals || []
@@ -19,6 +22,7 @@ module Solargraph
 
       private
 
+      # @return [void]
       def generate
         return if @generated
 

data/lib/solargraph/source_map/mapper.rb

@@ -70,6 +70,7 @@ module Solargraph
       # @param comment [String]
       # @return [void]
       def process_comment source_position, comment_position, comment
+        # @sg-ignore Wrong argument type for String#=~: object expected String::_MatchAgainst<String, undefined>, received Regexp
         return unless comment.encode('UTF-8', invalid: :replace, replace: '?') =~ DIRECTIVE_REGEXP
         cmnt = remove_inline_comment_hashes(comment)
         parse = Solargraph::Source.parse_docstring(cmnt)
@@ -163,7 +164,7 @@ module Solargraph
             end
           end
         when 'visibility'
-          begin
+
             kind = directive.tag.text&.to_sym
             return unless [:private, :protected, :public].include?(kind)
 
@@ -182,7 +183,7 @@ module Solargraph
                 pin.instance_variable_set(:@visibility, kind)
               end
             end
-          end
+
         when 'parse'
           begin
             ns = closure_at(source_position)
@@ -244,6 +245,7 @@ module Solargraph
 
       # @return [void]
       def process_comment_directives
+        # @sg-ignore Wrong argument type for String#=~: object expected String::_MatchAgainst<String, undefined>, received Regexp
         return unless @code.encode('UTF-8', invalid: :replace, replace: '?') =~ DIRECTIVE_REGEXP
         code_lines = @code.lines
         @source.associated_comments.each do |line, comments|