solargraph 0.56.2 → 0.58.0

data/lib/solargraph/rbs_map/conversions.rb

@@ -65,6 +65,7 @@ module Solargraph
           # STDERR.puts "Skipping interface #{decl.name.relative!}"
           interface_decl_to_pin decl, closure
         when RBS::AST::Declarations::TypeAlias
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
           type_aliases[decl.name.to_s] = decl
         when RBS::AST::Declarations::Module
           module_decl_to_pin decl
@@ -163,9 +164,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),
@@ -180,11 +182,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
@@ -345,7 +348,7 @@ module Solargraph
       }
 
       # @param decl [RBS::AST::Members::MethodDefinition, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrAccessor]
-      # @param closure [Pin::Namespace]
+      # @param closure [Pin::Closure]
       # @param context [Context]
       # @param scope [Symbol] :instance or :class
       # @param name [String] The name of the method
@@ -424,6 +427,7 @@ module Solargraph
       # @param pin [Pin::Method]
       # @return [void]
       def method_def_to_sigs decl, pin
+        # @param overload [RBS::AST::Members::MethodDefinition::Overload]
         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)
@@ -464,33 +468,50 @@ module Solargraph
         parameters = []
         arg_num = -1
         type.type.required_positionals.each do |param|
+          # @sg-ignore RBS generic type understanding issue
           name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
+          # @sg-ignore RBS generic type understanding issue
           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|
+          # @sg-ignore RBS generic type understanding issue
           name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :optarg, name: name, closure: pin,
+                                                         # @sg-ignore RBS generic type understanding issue
                                                          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, type_location: type_location)
+          inner_rest_positional_type =
+            ComplexType.try_parse(other_type_to_tag(type.type.rest_positionals.type))
+          rest_positional_type = ComplexType::UniqueType.new('Array',
+                                                             [],
+                                                             [inner_rest_positional_type],
+                                                             rooted: true, parameters_type: :list)
+          parameters.push Solargraph::Pin::Parameter.new(decl: :restarg, name: name, closure: pin,
+                                                         source: :rbs, type_location: type_location,
+                                                         return_type: rest_positional_type,)
         end
         type.type.trailing_positionals.each do |param|
+          # @sg-ignore RBS generic type understanding issue
           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, type_location: type_location)
         end
         type.type.required_keywords.each do |orig, param|
+          # @sg-ignore RBS generic type understanding issue
           name = orig ? orig.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :kwarg, name: name, closure: pin,
+                                                         # @sg-ignore RBS generic type understanding issue
                                                          return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted,
                                                          source: :rbs, type_location: type_location)
         end
         type.type.optional_keywords.each do |orig, param|
+          # @sg-ignore RBS generic type understanding issue
           name = orig ? orig.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :kwoptarg, name: name, closure: pin,
+                                                         # @sg-ignore RBS generic type understanding issue
                                                          return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted,
                                                          type_location: type_location,
                                                          source: :rbs)
@@ -699,13 +720,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
 
@@ -782,7 +803,9 @@ module Solargraph
       # @param namespace [Pin::Namespace]
       # @return [void]
       def add_mixins decl, namespace
+        # @param mixin [RBS::AST::Members::Include, RBS::AST::Members::Members::Extend, RBS::AST::Members::Members::Prepend]
         decl.each_mixin do |mixin|
+          # @todo are we handling prepend correctly?
           klass = mixin.is_a?(RBS::AST::Members::Include) ? Pin::Reference::Include : Pin::Reference::Extend
           type = build_type(mixin.name, mixin.args)
           generic_values = type.all_params.map(&:to_s)

data/lib/solargraph/rbs_map/core_fills.rb

@@ -48,6 +48,24 @@ module Solargraph
         Solargraph::Pin::Reference::Include.new(name: '_ToAry',
                                                 closure: Solargraph::Pin::Namespace.new(name: 'Array', source: :core_fill),
                                                 generic_values: ['generic<Elem>'],
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_ToAry',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Set', source: :core_fill),
+                                                generic_values: ['generic<Elem>'],
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_Each',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Array', source: :core_fill),
+                                                generic_values: ['generic<Elem>'],
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_Each',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Set', source: :core_fill),
+                                                generic_values: ['generic<Elem>'],
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_ToS',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Object', source: :core_fill),
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_ToS',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'String', source: :core_fill),
                                                 source: :core_fill)
       ]
 

data/lib/solargraph/rbs_map/core_map.rb

@@ -5,15 +5,17 @@ module Solargraph
     # Ruby core pins
     #
     class CoreMap
+      include Logging
 
       def resolved?
         true
       end
 
-      FILLS_DIRECTORY = File.join(File.dirname(__FILE__), '..', '..', '..', 'rbs', 'fills')
+      FILLS_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'rbs', 'fills'))
 
       def initialize; end
 
+      # @return [Enumerable<Pin::Base>]
       def pins
         return @pins if @pins
 
@@ -22,9 +24,16 @@ module Solargraph
         if cache
           @pins.replace cache
         else
-          loader.add(path: Pathname(FILLS_DIRECTORY))
-          @pins = conversions.pins
+          @pins.concat conversions.pins
+
+          # Avoid RBS::DuplicatedDeclarationError by loading in a different EnvironmentLoader
+          fill_loader = RBS::EnvironmentLoader.new(core_root: nil, repository: RBS::Repository.new(no_stdlib: false))
+          fill_loader.add(path: Pathname(FILLS_DIRECTORY))
+          fill_conversions = Conversions.new(loader: fill_loader)
+          @pins.concat fill_conversions.pins
+
           @pins.concat RbsMap::CoreFills::ALL
+
           processed = ApiMap::Store.new(pins).pins.reject { |p| p.is_a?(Solargraph::Pin::Reference::Override) }
           @pins.replace processed
 
@@ -33,16 +42,14 @@ module Solargraph
         @pins
       end
 
-      def loader
-        @loader ||= RBS::EnvironmentLoader.new(repository: RBS::Repository.new(no_stdlib: false))
-      end
-
       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'
 
@@ -23,6 +24,7 @@ module Solargraph
 
     # @param library [String]
     # @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, Bundler::LazySpecification]
+    # @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
@@ -77,6 +79,7 @@ module Solargraph
           conf['extensions'].push m
         end
       end
+      # @param file [File]
       File.open(File.join(directory, '.solargraph.yml'), 'w') do |file|
         file.puts conf.to_yaml
       end
@@ -170,6 +173,9 @@ module Solargraph
     # @return [void]
     def typecheck *files
       directory = File.realpath(options[:directory])
+      workspace = Solargraph::Workspace.new(directory)
+      level = options[:level].to_sym
+      rules = workspace.rules(level)
       api_map = Solargraph::ApiMap.load_with_cache(directory, $stdout)
       probcount = 0
       if files.empty?
@@ -181,7 +187,7 @@ module Solargraph
 
       time = Benchmark.measure {
         files.each do |file|
-          checker = TypeChecker.new(file, api_map: api_map, level: options[:level].to_sym)
+          checker = TypeChecker.new(file, api_map: api_map, level: options[:level].to_sym, workspace: workspace)
           problems = checker.problems
           next if problems.empty?
           problems.sort! { |a, b| a.location.range.start.line <=> b.location.range.start.line }
@@ -239,6 +245,63 @@ module Solargraph
       puts "#{workspace.filenames.length} files total."
     end
 
+    desc 'pin [PATH]', 'Describe a pin', hide: true
+    option :rbs, type: :boolean, desc: 'Output the pin as RBS', default: false
+    option :typify, type: :boolean, desc: 'Output the calculated return type of the pin from annotations', default: false
+    option :references, type: :boolean, desc: 'Show references', default: false
+    option :probe, type: :boolean, desc: 'Output the calculated return type of the pin from annotations and inference', default: false
+    option :stack, type: :boolean, desc: 'Show entire stack of a method pin by including definitions in superclasses', default: false
+    # @param path [String] The path to the method pin, e.g. 'Class#method' or 'Class.method'
+    # @return [void]
+    def pin path
+      api_map = Solargraph::ApiMap.load_with_cache('.', $stderr)
+      is_method = path.include?('#') || path.include?('.')
+      if is_method && options[:stack]
+        scope, ns, meth = if path.include? '#'
+                            [:instance, *path.split('#', 2)]
+                          else
+                            [:class, *path.split('.', 2)]
+                          end
+
+        # @sg-ignore Wrong argument type for
+        #   Solargraph::ApiMap#get_method_stack: rooted_tag
+        #   expected String, received Array<String>
+        pins = api_map.get_method_stack(ns, meth, scope: scope)
+      else
+        pins = api_map.get_path_pins path
+      end
+      # @type [Hash{Symbol => Pin::Base}]
+      references = {}
+      pin = pins.first
+      case pin
+      when nil
+        $stderr.puts "Pin not found for path '#{path}'"
+        exit 1
+      when Pin::Namespace
+        if options[:references]
+          superclass_tag = api_map.qualify_superclass(pin.return_type.tag)
+          superclass_pin = api_map.get_path_pins(superclass_tag).first if superclass_tag
+          references[:superclass] = superclass_pin if superclass_pin
+        end
+      end
+
+      pins.each do |pin|
+        if options[:typify] || options[:probe]
+          type = ComplexType::UNDEFINED
+          type = pin.typify(api_map) if options[:typify]
+          type = pin.probe(api_map) if options[:probe] && type.undefined?
+          print_type(type)
+          next
+        end
+
+        print_pin(pin)
+      end
+      references.each do |key, refpin|
+        puts "\n# #{key.to_s.capitalize}:\n\n"
+        print_pin(refpin)
+      end
+    end
+
     private
 
     # @param pin [Solargraph::Pin::Base]
@@ -258,11 +321,32 @@ 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,
       #   typecheck doesn't complain on the below line
       api_map.cache_gem(gemspec, rebuild: options.rebuild, out: $stdout)
     end
+
+    # @param type [ComplexType]
+    # @return [void]
+    def print_type(type)
+      if options[:rbs]
+        puts type.to_rbs
+      else
+        puts type.rooted_tag
+      end
+    end
+
+    # @param pin [Solargraph::Pin::Base]
+    # @return [void]
+    def print_pin(pin)
+      if options[:rbs]
+        puts pin.to_rbs
+      else
+        puts pin.inspect
+      end
+    end
   end
 end

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

@@ -98,7 +98,10 @@ module Solargraph
                   match = ol.parameters.any?(&:restarg?)
                   break
                 end
-                atype = atypes[idx] ||= arg.infer(api_map, Pin::ProxyType.anonymous(name_pin.context, source: :chain), locals)
+                arg_name_pin = Pin::ProxyType.anonymous(name_pin.context,
+                                                        gates: name_pin.gates,
+                                                        source: :chain)
+                atype = atypes[idx] ||= arg.infer(api_map, arg_name_pin, locals)
                 unless param.compatible_arg?(atype, api_map) || param.restarg?
                   match = false
                   break
@@ -137,7 +140,7 @@ module Solargraph
                 #
                 # qualify(), however, happens in the namespace where
                 # the docs were written - from the method pin.
-                type = with_params(new_return_type.self_to_type(self_type), self_type).qualify(api_map, p.namespace) if new_return_type.defined?
+                type = with_params(new_return_type.self_to_type(self_type), self_type).qualify(api_map, *p.gates) if new_return_type.defined?
                 type ||= ComplexType::UNDEFINED
               end
               break if type.defined?
@@ -266,8 +269,9 @@ module Solargraph
           method_pin = find_method_pin(name_pin)
           return [] unless method_pin
 
+          # @param signature_pin [Pin::Signature]
           method_pin.signatures.map(&:block).compact.map do |signature_pin|
-            return_type = signature_pin.return_type.qualify(api_map, name_pin.namespace)
+            return_type = signature_pin.return_type.qualify(api_map, *name_pin.gates)
             signature_pin.proxy(return_type)
           end
         end

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

@@ -15,73 +15,10 @@ module Solargraph
             gates = ['']
           else
             base = word
-            gates = crawl_gates(name_pin)
+            gates = name_pin.gates
           end
-          parts = base.split('::')
-          gates.each do |gate|
-            # @todo 'Wrong argument type for
-            #   Solargraph::Source::Chain::Constant#deep_constant_type:
-            #   gate expected String, received generic<Elem>' is because
-            #   we lose 'rooted' information in the 'Chain::Array' class
-            #   internally, leaving ::Array#each shadowed when it
-            #   shouldn't be.
-            type = deep_constant_type(gate, api_map)
-            # Use deep inference to resolve root
-            parts[0..-2].each do |sym|
-              pins = api_map.get_constants('', type.namespace).select{ |pin| pin.name == sym }
-              type = first_pin_type(pins, api_map)
-              break if type.undefined?
-            end
-            next if type.undefined?
-            result = api_map.get_constants('', type.namespace).select { |pin| pin.name == parts.last }
-            return result unless result.empty?
-          end
-          []
-        end
-
-        private
-
-        # @param pin [Pin::Closure]
-        # @return [::Array<String>]
-        def crawl_gates pin
-          clos = pin
-          until clos.nil?
-            if clos.is_a?(Pin::Namespace)
-              gates = clos.gates
-              gates.push('') if gates.empty?
-              return gates
-            end
-            clos = clos.closure
-          end
-          ['']
-        end
-
-        # @param pins [::Array<Pin::Base>]
-        # @param api_map [ApiMap]
-        # @return [ComplexType]
-        def first_pin_type(pins, api_map)
-          type = ComplexType::UNDEFINED
-          pins.each do |pin|
-            type = pin.typify(api_map)
-            break if type.defined?
-            type = pin.probe(api_map)
-            break if type.defined?
-          end
-          type
-        end
-
-        # @param gate [String]
-        # @param api_map [ApiMap]
-        # @return [ComplexType]
-        def deep_constant_type(gate, api_map)
-          type = ComplexType::ROOT
-          return type if gate == ''
-          gate.split('::').each do |word|
-            pins = api_map.get_constants('', type.namespace).select { |pin| pin.name == word }
-            type = first_pin_type(pins, api_map)
-            break if type.undefined?
-          end
-          type
+          fqns = api_map.resolve(base, gates)
+          api_map.get_path_pins(fqns)
         end
       end
     end

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

@@ -8,7 +8,7 @@ module Solargraph
           '<if>'
         end
 
-        # @param links [::Array<Link>]
+        # @param links [::Array<Chain>]
         def initialize links
           @links = links
         end

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
@@ -32,13 +38,14 @@ module Solargraph
 
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
-        # @param locals [::Enumerable<Pin::Base>]
+        # @param locals [::Array<Pin::Base>]
         # @return [::Array<Pin::Base>]
         def resolve api_map, name_pin, locals
           []
         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/or.rb

@@ -8,7 +8,7 @@ module Solargraph
           '<or>'
         end
 
-        # @param links [::Array<Link>]
+        # @param links [::Array<Chain>]
         def initialize links
           @links = links
         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
@@ -260,12 +264,17 @@ module Solargraph
                  ComplexType::UNDEFINED
                elsif types.length > 1
                  # Move nil to the end by convention
+
+                 # @param a [ComplexType::UniqueType]
                  sorted = types.flat_map(&:items).sort { |a, _| a.tag == 'nil' ? 1 : 0 }
                  ComplexType.new(sorted.uniq)
                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