solargraph 0.54.0 → 0.58.0

data/lib/solargraph/rbs_map/core_fills.rb

@@ -13,38 +13,72 @@ module Solargraph
         'elsif', 'end', 'ensure', 'false', 'for', 'if', 'in', 'module', 'next',
         'nil', 'not', 'or', 'redo', 'rescue', 'retry', 'return', 'self', 'super',
         'then', 'true', 'undef', 'unless', 'until', 'when', 'while', 'yield'
-      ].map { |k| Pin::Keyword.new(k) }
+      ].map { |k| Pin::Keyword.new(k, source: :core_fill) }
 
       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>]')
+                                    closure: Solargraph::Pin::Namespace.new(name: 'Object', source: :core_fill), comments: '@return [::Class<self>]',
+                                    source: :core_fill)
       ]
 
       OVERRIDES = [
-        Override.from_comment('BasicObject#instance_eval', '@yieldreceiver [self]'),
-        Override.from_comment('BasicObject#instance_exec', '@yieldreceiver [self]'),
-        Override.from_comment('Module#define_method', '@yieldreceiver [Object<self>]'),
-        Override.from_comment('Module#class_eval', '@yieldreceiver [Class<self>]'),
-        Override.from_comment('Module#class_exec', '@yieldreceiver [Class<self>]'),
-        Override.from_comment('Module#module_eval', '@yieldreceiver [Module<self>]'),
-        Override.from_comment('Module#module_exec', '@yieldreceiver [Module<self>]'),
+        Override.from_comment('BasicObject#instance_eval', '@yieldreceiver [self]',
+                              source: :core_fill),
+        Override.from_comment('BasicObject#instance_exec', '@yieldreceiver [self]',
+                              source: :core_fill),
+        Override.from_comment('Module#define_method', '@yieldreceiver [::Object<self>]',
+                              source: :core_fill),
+        Override.from_comment('Module#class_eval', '@yieldreceiver [::Class<self>]',
+                              source: :core_fill),
+        Override.from_comment('Module#class_exec', '@yieldreceiver [::Class<self>]',
+                              source: :core_fill),
+        Override.from_comment('Module#module_eval', '@yieldreceiver [::Module<self>]',
+                              source: :core_fill),
+        Override.from_comment('Module#module_exec', '@yieldreceiver [::Module<self>]',
+                              source: :core_fill),
         # RBS does not define Class with a generic, so all calls to
         # generic() return an 'untyped'.  We can do better:
-        Override.method_return('Class#allocate', 'self')
+        Override.method_return('Class#allocate', 'self', source: :core_fill),
+      ]
+
+      # @todo I don't see any direct link in RBS to build this from -
+      #   presumably RBS is using duck typing to match interfaces
+      #   against concrete classes
+      INCLUDES = [
+        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)
       ]
 
       # HACK: Add Errno exception classes
-      errno = Solargraph::Pin::Namespace.new(name: 'Errno')
+      errno = Solargraph::Pin::Namespace.new(name: 'Errno', source: :core_fill)
       errnos = []
       Errno.constants.each do |const|
-        errnos.push Solargraph::Pin::Namespace.new(type: :class, name: const.to_s, closure: errno)
-        errnos.push Solargraph::Pin::Reference::Superclass.new(closure: errnos.last, name: 'SystemCallError')
+        errnos.push Solargraph::Pin::Namespace.new(type: :class, name: const.to_s, closure: errno, source: :core_fill)
+        errnos.push Solargraph::Pin::Reference::Superclass.new(closure: errnos.last, name: 'SystemCallError', source: :core_fill)
       end
       ERRNOS = errnos
 
-      ALL = KEYWORDS + MISSING + OVERRIDES + ERRNOS
+      ALL = KEYWORDS + MISSING + OVERRIDES + ERRNOS + INCLUDES
     end
   end
 end

data/lib/solargraph/rbs_map/core_map.rb

@@ -5,23 +5,53 @@ module Solargraph
     # Ruby core pins
     #
     class CoreMap
-      include Conversions
+      include Logging
 
-      def initialize
-        cache = Cache.load('core.ser')
+      def resolved?
+        true
+      end
+
+      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
+
+        @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
+          @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) }
-          processed.each { |pin| pin.source = :rbs }
-          pins.replace processed
+          @pins.replace processed
 
-          Cache.save('core.ser', pins)
+          PinCache.serialize_core @pins
         end
+        @pins
+      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 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, 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,
+                           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,22 +128,29 @@ module Solargraph
       @@rbs_maps_hash[library] ||= RbsMap.new(library)
     end
 
-    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
@@ -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
@@ -89,46 +92,66 @@ module Solargraph
     )
     # @return [void]
     def clear
-      puts "Deleting the cached documentation"
-      Solargraph::Cache.clear
+      puts "Deleting all cached documentation (gems, core and stdlib)"
+      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 cached gem documentation"
+    desc 'uncache GEM [...GEM]', "Delete specific cached gem documentation"
+    long_desc %(
+      Specify one or more gem names to clear. 'core' or 'stdlib' may
+      also be specified to clear cached system documentation.
+      Documentation will be regenerated as needed.
+    )
+    # @param gems [Array<String>]
     # @return [void]
     def uncache *gems
       raise ArgumentError, 'No gems specified.' if gems.empty?
       gems.each do |gem|
+        if gem == 'core'
+          PinCache.uncache_core
+          next
+        end
+
+        if gem == '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
 
     desc 'gems [GEM[=VERSION]]', 'Cache documentation for installed gems'
     option :rebuild, type: :boolean, desc: 'Rebuild existing documentation', default: false
+    # @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
 
@@ -150,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?
@@ -161,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 }
@@ -189,6 +215,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)
@@ -218,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]
@@ -237,15 +321,31 @@ 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 do_cache gemspec
-      cached = Yardoc.cached?(gemspec)
-      if cached && !options.rebuild
-        puts "Cache already exists for #{gemspec.name} #{gemspec.version}"
+    def print_pin(pin)
+      if options[:rbs]
+        puts pin.to_rbs
       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)
+        puts pin.inspect
       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
 
@@ -14,17 +15,21 @@ module Solargraph
 
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
-        # @param locals [Enumerable<Pin::LocalVariable>]
+        # @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).tag
+            child.infer(api_map, name_pin, locals).simplify_literals
           end
-          type = if child_types.uniq.length == 1 && child_types.first != 'undefined'
-                   "::Array<#{child_types.first}>"
+          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
-                   '::Array'
+                   ComplexType::UniqueType.new('Array', [], child_types, rooted: true, parameters_type: :fixed)
                  end
-          [Pin::ProxyType.anonymous(ComplexType.try_parse(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