solargraph 0.54.4 → 0.57.0

data/lib/solargraph/rbs_map/core_map.rb

@@ -5,23 +5,49 @@ module Solargraph
     # Ruby core pins
     #
     class CoreMap
-      include Conversions
 
-      def initialize
-        cache = Cache.load('core.ser')
+      def resolved?
+        true
+      end
+
+      FILLS_DIRECTORY = File.join(File.dirname(__FILE__), '..', '..', '..', 'rbs', 'fills')
+
+      def initialize; end
+
+      # @return [Enumerable<Pin::Base>]
+      def pins
+        return @pins if @pins
+
+        @pins = []
+        cache = PinCache.deserialize_core
         if cache
-          pins.replace cache
+          @pins.replace cache
         else
-          loader = RBS::EnvironmentLoader.new(repository: RBS::Repository.new(no_stdlib: false))
-          RBS::Environment.from_loader(loader).resolve_type_names
-          load_environment_to_pins(loader)
-          pins.concat RbsMap::CoreFills::ALL
+          loader.add(path: Pathname(FILLS_DIRECTORY))
+          @pins = conversions.pins
+          @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
+          @pins.replace processed
 
-          Cache.save('core.ser', pins)
+          PinCache.serialize_core @pins
         end
+        @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
     end
   end

data/lib/solargraph/rbs_map/stdlib_map.rb

@@ -7,19 +7,29 @@ module Solargraph
     # Ruby stdlib pins
     #
     class StdlibMap < RbsMap
+      include Logging
+
       # @type [Hash{String => RbsMap}]
       @stdlib_maps_hash = {}
 
       # @param library [String]
       def initialize library
-        cache = Cache.load('stdlib', "#{library}.ser")
-        if cache
-          pins.replace cache
+        cached_pins = PinCache.deserialize_stdlib_require library
+        if cached_pins
+          @pins = cached_pins
           @resolved = true
+          @loaded = true
+          logger.debug { "Deserialized #{cached_pins.length} cached pins for stdlib require #{library.inspect}" }
         else
           super
-          return unless resolved?
-          Cache.save('stdlib', "#{library}.ser", pins)
+          unless resolved?
+            @pins = []
+            logger.info { "Could not resolve #{library.inspect}" }
+            return
+          end
+          generated_pins = pins
+          logger.debug { "Found #{generated_pins.length} pins for stdlib library #{library}" }
+          PinCache.serialize_stdlib_require library, generated_pins
         end
       end
 

data/lib/solargraph/rbs_map.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'digest'
 require 'pathname'
 require 'rbs'
 
@@ -10,25 +11,86 @@ module Solargraph
     autoload :CoreFills,   'solargraph/rbs_map/core_fills'
     autoload :StdlibMap,   'solargraph/rbs_map/stdlib_map'
 
-    include Conversions
+    include Logging
 
     # @type [Hash{String => RbsMap}]
     @@rbs_maps_hash = {}
 
     attr_reader :library
 
+    attr_reader :rbs_collection_paths
+
+    attr_reader :rbs_collection_config_path
+
     # @param library [String]
-    # @param version [String, nil]
-    # @param directories [Array<Pathname, String>]
-    def initialize library, version = nil, directories: []
+    # @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?
+        raise 'Please provide rbs_collection_config_path if you provide rbs_collection_paths'
+      end
       @library = library
       @version = version
-      @collection = nil
-      @directories = directories
-      loader = RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
+      @rbs_collection_config_path = rbs_collection_config_path
+      @rbs_collection_paths = rbs_collection_paths
       add_library loader, library, version
-      return unless resolved?
-      load_environment_to_pins(loader)
+    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
+    #   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))
+          if lockfile_path.exist?
+            collection_config = RBS::Collection::Config.from_path lockfile_path
+            gem_config = collection_config.gem(library)
+            data = gem_config&.to_s
+          end
+        end
+        if data.nil? || data.empty?
+          if resolved?
+            # definitely came from the gem itself and not elsewhere -
+            # only one version per gem
+            'gem-export'
+          else
+            'unresolved'
+          end
+        else
+          Digest::SHA1.hexdigest(data)
+        end
+      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,
+                           rbs_collection_config_path: rbs_collection_config_path)
+      return rbs_map if rbs_map.resolved?
+
+      # try any version of the gem in the collection
+      RbsMap.new(gemspec.name, nil,
+                 rbs_collection_paths: [rbs_collection_path].compact,
+                 rbs_collection_config_path: rbs_collection_config_path)
+    end
+
+    # @return [Array<Pin::Base>]
+    def pins
+      @pins ||= resolved? ? conversions.pins : []
     end
 
     # @generic T
@@ -50,11 +112,13 @@ module Solargraph
       @resolved
     end
 
+    # @return [RBS::Repository]
     def repository
       @repository ||= RBS::Repository.new(no_stdlib: false).tap do |repo|
-        # @todo Temporarily ignoring external directories due to issues with
-        #   incomplete/broken gem_rbs_collection installations
-        # @directories.each { |dir| repo.add(Pathname.new(dir)) }
+        @rbs_collection_paths.each do |dir|
+          dir_path = Pathname.new(dir)
+          repo.add(dir_path) if dir_path.exist? && dir_path.directory?
+        end
       end
     end
 
@@ -64,23 +128,29 @@ module Solargraph
       @@rbs_maps_hash[library] ||= RbsMap.new(library)
     end
 
-    # @param gemspec [Gem::Specification]
-    def self.from_gemspec(gemspec)
-      RbsMap.new(gemspec.name, gemspec.version)
+    private
+
+    # @return [RBS::EnvironmentLoader]
+    def loader
+      @loader ||= RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
     end
 
-    private
+    # @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)
         loader.add library: library, version: version
-        Solargraph.logger.info "#{short_name} successfully loaded library #{library}"
+        logger.debug { "#{short_name} successfully loaded library #{library}:#{version}" }
         true
       else
-        Solargraph.logger.info "#{short_name} failed to load library #{library}"
+        logger.info { "#{short_name} did not find data for library #{library}:#{version}" }
         false
       end
     end

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
@@ -90,19 +92,20 @@ module Solargraph
     # @return [void]
     def clear
       puts "Deleting all cached documentation (gems, core and stdlib)"
-      Solargraph::Cache.clear
+      Solargraph::PinCache.clear
     end
     map 'clear-cache' => :clear
     map 'clear-cores' => :clear
 
     desc 'cache', 'Cache a gem', hide: true
+    option :rebuild, type: :boolean, desc: 'Rebuild existing documentation', default: false
     # @return [void]
     # @param gem [String]
     # @param version [String, nil]
     def cache gem, version = nil
+      api_map = Solargraph::ApiMap.load(Dir.pwd)
       spec = Gem::Specification.find_by_name(gem, version)
-      pins = GemPins.build(spec)
-      Cache.save('gems', "#{spec.name}-#{spec.version}.ser", pins)
+      api_map.cache_gem(spec, rebuild: options[:rebuild], out: $stdout)
     end
 
     desc 'uncache GEM [...GEM]', "Delete specific cached gem documentation"
@@ -117,18 +120,17 @@ module Solargraph
       raise ArgumentError, 'No gems specified.' if gems.empty?
       gems.each do |gem|
         if gem == 'core'
-          Cache.uncache("core.ser")
+          PinCache.uncache_core
           next
         end
 
         if gem == 'stdlib'
-          Cache.uncache("stdlib")
+          PinCache.uncache_stdlib
           next
         end
 
         spec = Gem::Specification.find_by_name(gem)
-        Cache.uncache('gems', "#{spec.name}-#{spec.version}.ser")
-        Cache.uncache('gems', "#{spec.name}-#{spec.version}.yardoc")
+        PinCache.uncache_gem(spec, out: $stdout)
       end
     end
 
@@ -137,15 +139,18 @@ module Solargraph
     # @param names [Array<String>]
     # @return [void]
     def gems *names
+      api_map = ApiMap.load('.')
       if names.empty?
-        Gem::Specification.to_a.each { |spec| do_cache spec }
+        Gem::Specification.to_a.each { |spec| do_cache spec, api_map }
+        STDERR.puts "Documentation cached for all #{Gem::Specification.count} gems."
       else
         names.each do |name|
           spec = Gem::Specification.find_by_name(*name.split('='))
-          do_cache spec
+          do_cache spec, api_map
         rescue Gem::MissingSpecError
           warn "Gem '#{name}' not found"
         end
+        STDERR.puts "Documentation cached for #{names.count} gems."
       end
     end
 
@@ -206,6 +211,7 @@ module Solargraph
     # @return [void]
     def scan
       directory = File.realpath(options[:directory])
+      # @type [Solargraph::ApiMap, nil]
       api_map = nil
       time = Benchmark.measure {
         api_map = Solargraph::ApiMap.load_with_cache(directory, $stdout)
@@ -254,16 +260,12 @@ module Solargraph
     end
 
     # @param gemspec [Gem::Specification]
+    # @param api_map [ApiMap]
     # @return [void]
-    def do_cache gemspec
-      cached = Yardoc.cached?(gemspec)
-      if cached && !options.rebuild
-        puts "Cache already exists for #{gemspec.name} #{gemspec.version}"
-      else
-        puts "#{cached ? 'Rebuilding' : 'Caching'} gem documentation for #{gemspec.name} #{gemspec.version}"
-        pins = GemPins.build(gemspec)
-        Cache.save('gems', "#{gemspec.name}-#{gemspec.version}.ser", pins)
-      end
+    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
   end
 end

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

@@ -3,8 +3,9 @@ module Solargraph
     class Chain
       class Array < Literal
         # @param children [::Array<Chain>]
-        def initialize children
-          super('::Array')
+        # @param node [Parser::AST::Node]
+        def initialize children, node
+          super('::Array', node)
           @children = children
         end
 
@@ -17,15 +18,18 @@ module Solargraph
         # @param locals [::Array<Pin::Parameter, Pin::LocalVariable>]
         def resolve api_map, name_pin, locals
           child_types = @children.map do |child|
-            child.infer(api_map, name_pin, locals)
+            child.infer(api_map, name_pin, locals).simplify_literals
           end
-
-          type = if child_types.uniq.length == 1 && child_types.first.defined?
+          type = if child_types.length == 0 || child_types.any?(&:undefined?)
+                   ComplexType::UniqueType.new('Array', rooted: true)
+                 elsif child_types.uniq.length == 1 && child_types.first.defined?
                    ComplexType::UniqueType.new('Array', [], child_types.uniq, rooted: true, parameters_type: :list)
+                 elsif child_types.length == 0
+                   ComplexType::UniqueType.new('Array', rooted: true, parameters_type: :list)
                  else
-                   ComplexType::UniqueType.new('Array', rooted: true)
+                   ComplexType::UniqueType.new('Array', [], child_types, rooted: true, parameters_type: :fixed)
                  end
-          [Pin::ProxyType.anonymous(type)]
+          [Pin::ProxyType.anonymous(type, source: :chain)]
         end
       end
     end

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

@@ -5,7 +5,7 @@ module Solargraph
     class Chain
       class BlockSymbol < Link
         def resolve api_map, name_pin, locals
-          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'))]
+          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'), source: :chain)]
         end
       end
     end

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

@@ -5,7 +5,7 @@ module Solargraph
     class Chain
       class BlockVariable < Link
         def resolve api_map, name_pin, locals
-          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'))]
+          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'), source: :chain)]
         end
       end
     end

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

@@ -3,12 +3,20 @@
 module Solargraph
   class Source
     class Chain
+      #
+      # Handles both method calls and local variable references by
+      # first looking for a variable with the name 'word', then
+      # proceeding to method signature resolution if not found.
+      #
       class Call < Chain::Link
         include Solargraph::Parser::NodeMethods
 
         # @return [String]
         attr_reader :word
 
+        # @return [Location]
+        attr_reader :location
+
         # @return [::Array<Chain>]
         attr_reader :arguments
 
@@ -16,10 +24,12 @@ module Solargraph
         attr_reader :block
 
         # @param word [String]
+        # @param location [Location, nil]
         # @param arguments [::Array<Chain>]
         # @param block [Chain, nil]
-        def initialize word, arguments = [], block = nil
+        def initialize word, location = nil, arguments = [], block = nil
           @word = word
+          @location = location
           @arguments = arguments
           @block = block
           fix_block_pass
@@ -35,20 +45,21 @@ module Solargraph
         end
 
         # @param api_map [ApiMap]
-        # @param name_pin [Pin::Closure] name_pin.binder should give us the object on which 'word' will be invoked
+        # @param name_pin [Pin::Closure] name_pin.binder should give us the type of the object on which 'word' will be invoked
         # @param locals [::Array<Pin::LocalVariable>]
         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 }
+            api_map.visible_pins(locals, word, name_pin, location)
           else
             []
           end
           return inferred_pins(found, api_map, name_pin, locals) unless found.empty?
           pins = name_pin.binder.each_unique_type.flat_map do |context|
-            ns = context.namespace == '' ? '' : context.namespace_type.tag
-            api_map.get_method_stack(ns, word, scope: context.scope)
+            ns_tag = context.namespace == '' ? '' : context.namespace_type.tag
+            stack = api_map.get_method_stack(ns_tag, word, scope: context.scope)
+            [stack.first].compact
           end
           return [] if pins.empty?
           inferred_pins(pins, api_map, name_pin, locals)
@@ -72,7 +83,9 @@ module Solargraph
             # use it.  If we didn't pass a block, the logic below will
             # reject it regardless
 
-            sorted_overloads = overloads.sort { |ol| ol.block? ? -1 : 1 }
+            with_block, without_block = overloads.partition(&:block?)
+            sorted_overloads = with_block + without_block
+            # @type [Pin::Signature, nil]
             new_signature_pin = nil
             sorted_overloads.each do |ol|
               next unless ol.arity_matches?(arguments, with_block?)
@@ -85,13 +98,8 @@ module Solargraph
                   match = ol.parameters.any?(&:restarg?)
                   break
                 end
-                atype = atypes[idx] ||= arg.infer(api_map, Pin::ProxyType.anonymous(name_pin.context), locals)
-                # make sure we get types from up the method
-                # inheritance chain if we don't have them on this pin
-                ptype = param.typify api_map
-                # @todo Weak type comparison
-                # unless atype.tag == param.return_type.tag || api_map.super_and_sub?(param.return_type.tag, atype.tag)
-                unless ptype.undefined? || atype.name == ptype.name || ptype.any? { |current_ptype| api_map.super_and_sub?(current_ptype.name, atype.name) } || ptype.generic? || param.restarg?
+                atype = atypes[idx] ||= arg.infer(api_map, Pin::ProxyType.anonymous(name_pin.context, source: :chain), locals)
+                unless param.compatible_arg?(atype, api_map) || param.restarg?
                   match = false
                   break
                 end
@@ -106,9 +114,30 @@ module Solargraph
                     blocktype = block_call_type(api_map, name_pin, locals)
                   end
                 end
+                # @type new_signature_pin [Pin::Signature]
                 new_signature_pin = ol.resolve_generics_from_context_until_complete(ol.generics, atypes, nil, nil, blocktype)
                 new_return_type = new_signature_pin.return_type
-                type = with_params(new_return_type.self_to_type(name_pin.context), name_pin.context).qualify(api_map, name_pin.context.namespace) if new_return_type.defined?
+                if head?
+                  # If we're at the head of the chain, we called a
+                  # method somewhere that marked itself as returning
+                  # self.  Given we didn't invoke this on an object,
+                  # this must be a method in this same class - so we
+                  # use our own self type
+                  self_type = name_pin.context
+                else
+                  # if we're past the head in the chain, whatever the
+                  # type of the lhs side is what 'self' will be in its
+                  # declaration - we can't just use the type of the
+                  # method pin, as this might be a subclass of the
+                  # place where the method is defined
+                  self_type = name_pin.binder
+                end
+                # This same logic applies to the YARD work done by
+                # 'with_params()'.
+                #
+                # 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 ||= ComplexType::UNDEFINED
               end
               break if type.defined?
@@ -124,13 +153,14 @@ module Solargraph
             end
             p
           end
-          result.map do |pin|
-            if pin.path == 'Class#new' && name_pin.context.tag != 'Class'
-              reduced_context = name_pin.context.reduce_class_type
+          logger.debug { "Call#inferred_pins(name_pin.binder=#{name_pin.binder}, word=#{word}, pins=#{pins.map(&:desc)}, name_pin=#{name_pin}) - result=#{result}" }
+          out = result.map do |pin|
+            if pin.path == 'Class#new' && name_pin.binder.tag != 'Class'
+              reduced_context = name_pin.binder.reduce_class_type
               pin.proxy(reduced_context)
             else
               next pin if pin.return_type.undefined?
-              selfy = pin.return_type.self_to_type(name_pin.context)
+              selfy = pin.return_type.self_to_type(name_pin.binder)
               selfy == pin.return_type ? pin : pin.proxy(selfy)
             end
           end
@@ -152,7 +182,7 @@ module Solargraph
             result = inner_process_macro(pin, macro, api_map, context, locals)
             return result unless result.return_type.undefined?
           end
-          Pin::ProxyType.anonymous(ComplexType::UNDEFINED)
+          Pin::ProxyType.anonymous(ComplexType::UNDEFINED, source: :chain)
         end
 
         # @param pin [Pin::Method]
@@ -167,7 +197,7 @@ module Solargraph
             result = inner_process_macro(pin, macro, api_map, context, locals)
             return result unless result.return_type.undefined?
           end
-          Pin::ProxyType.anonymous ComplexType::UNDEFINED
+          Pin::ProxyType.anonymous ComplexType::UNDEFINED, source: :chain
         end
 
         # @param pin [Pin::Base]
@@ -177,7 +207,7 @@ module Solargraph
         # @param locals [::Array<Pin::LocalVariable, Pin::Parameter>]
         # @return [Pin::ProxyType]
         def inner_process_macro pin, macro, api_map, context, locals
-          vals = arguments.map{ |c| Pin::ProxyType.anonymous(c.infer(api_map, pin, locals)) }
+          vals = arguments.map{ |c| Pin::ProxyType.anonymous(c.infer(api_map, pin, locals), source: :chain) }
           txt = macro.tag.text.clone
           if txt.empty? && macro.tag.name
             named = api_map.named_macro(macro.tag.name)
@@ -191,9 +221,9 @@ module Solargraph
           docstring = Solargraph::Source.parse_docstring(txt).to_docstring
           tag = docstring.tag(:return)
           unless tag.nil? || tag.types.nil?
-            return Pin::ProxyType.anonymous(ComplexType.try_parse(*tag.types))
+            return Pin::ProxyType.anonymous(ComplexType.try_parse(*tag.types), source: :chain)
           end
-          Pin::ProxyType.anonymous(ComplexType::UNDEFINED)
+          Pin::ProxyType.anonymous(ComplexType::UNDEFINED, source: :chain)
         end
 
         # @param docstring [YARD::Docstring]

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

@@ -41,7 +41,7 @@ module Solargraph
 
         private
 
-        # @param pin [Pin::Base]
+        # @param pin [Pin::Closure]
         # @return [::Array<String>]
         def crawl_gates pin
           clos = pin

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

@@ -5,9 +5,10 @@ module Solargraph
     class Chain
       class Hash < Literal
         # @param type [String]
+        # @param node [Parser::AST::Node]
         # @param splatted [Boolean]
-        def initialize type, splatted = false
-          super(type)
+        def initialize type, node, splatted = false
+          super(type, node)
           @splatted = splatted
         end
 
@@ -21,7 +22,7 @@ module Solargraph
         end
 
         def resolve api_map, name_pin, locals
-          [Pin::ProxyType.anonymous(@complex_type)]
+          [Pin::ProxyType.anonymous(@complex_type, source: :chain)]
         end
 
         def splatted?

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

@@ -9,7 +9,7 @@ module Solargraph
       # @note Chain::Head is only intended to handle `self` and `super`.
       class Head < Link
         def resolve api_map, name_pin, locals
-          return [Pin::ProxyType.anonymous(name_pin.binder)] if word == 'self'
+          return [Pin::ProxyType.anonymous(name_pin.binder, source: :chain)] if word == 'self'
           # return super_pins(api_map, name_pin) if word == 'super'
           []
         end

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

@@ -20,7 +20,7 @@ module Solargraph
 
         def resolve api_map, name_pin, locals
           types = @links.map { |link| link.infer(api_map, name_pin, locals) }
-          [Solargraph::Pin::ProxyType.anonymous(Solargraph::ComplexType.try_parse(types.map(&:tag).uniq.join(', ')))]
+          [Solargraph::Pin::ProxyType.anonymous(Solargraph::ComplexType.try_parse(types.map(&:tag).uniq.join(', ')), source: :chain)]
         end
       end
     end