solargraph 0.58.3 → 0.60.0

data/lib/solargraph/rbs_map/core_fills.rb

@@ -19,7 +19,7 @@ module Solargraph
         Solargraph::Pin::Method.new(name: 'class', scope: :instance,
                                     closure: Solargraph::Pin::Namespace.new(name: 'Object', source: :core_fill), comments: '@return [::Class<self>]',
                                     source: :core_fill)
-      ]
+      ].freeze
 
       OVERRIDES = [
         Override.from_comment('BasicObject#instance_eval', '@yieldreceiver [self]',
@@ -38,43 +38,50 @@ module Solargraph
                               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', source: :core_fill),
-      ]
+        Override.method_return('Class#allocate', 'self', source: :core_fill)
+      ].freeze
 
       # @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),
+                                                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),
+                                                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),
+                                                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),
+                                                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),
+                                                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),
+                                                closure: Solargraph::Pin::Namespace.new(name: 'String',
+                                                                                        source: :core_fill),
                                                 source: :core_fill)
-      ]
+      ].freeze
 
       # HACK: Add Errno exception classes
       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, source: :core_fill)
-        errnos.push Solargraph::Pin::Reference::Superclass.new(closure: errnos.last, name: 'SystemCallError', source: :core_fill)
+        errnos.push Solargraph::Pin::Reference::Superclass.new(closure: errnos.last, name: 'SystemCallError',
+                                                               source: :core_fill)
       end
       ERRNOS = errnos
 

data/lib/solargraph/rbs_map/core_map.rb

@@ -15,31 +15,38 @@ module Solargraph
 
       def initialize; end
 
+      # @param out [IO, nil] output stream for logging
       # @return [Enumerable<Pin::Base>]
-      def pins
+      def pins out: $stderr
         return @pins if @pins
+        @pins = cache_core(out: out)
+      end
 
-        @pins = []
+      # @param out [StringIO, IO, nil] output stream for logging
+      # @return [Array<Pin::Base>]
+      def cache_core out: $stderr
+        new_pins = []
         cache = PinCache.deserialize_core
-        if cache
-          @pins.replace cache
-        else
-          @pins.concat conversions.pins
+        return cache if cache
+        new_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))
+        out&.puts 'Caching RBS pins for Ruby core'
+        fill_conversions = Conversions.new(loader: fill_loader)
+        new_pins.concat fill_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
+        # add some overrides
+        new_pins.concat RbsMap::CoreFills::ALL
 
-          @pins.concat RbsMap::CoreFills::ALL
+        # process overrides, then remove any which couldn't be resolved
+        processed = ApiMap::Store.new(new_pins).pins.reject { |p| p.is_a?(Solargraph::Pin::Reference::Override) }
+        new_pins.replace processed
 
-          processed = ApiMap::Store.new(pins).pins.reject { |p| p.is_a?(Solargraph::Pin::Reference::Override) }
-          @pins.replace processed
+        PinCache.serialize_core new_pins
 
-          PinCache.serialize_core @pins
-        end
-        @pins
+        new_pins
       end
 
       private

data/lib/solargraph/rbs_map/stdlib_map.rb

@@ -12,19 +12,22 @@ module Solargraph
       # @type [Hash{String => RbsMap}]
       @stdlib_maps_hash = {}
 
+      # @param rebuild [Boolean] build pins regardless of whether we
+      #   have cached them already
       # @param library [String]
-      def initialize library
+      # @param out [StringIO, IO, nil] where to log messages
+      def initialize library, rebuild: false, out: $stderr
         cached_pins = PinCache.deserialize_stdlib_require library
-        if cached_pins
+        if cached_pins && !rebuild
           @pins = cached_pins
           @resolved = true
           @loaded = true
           logger.debug { "Deserialized #{cached_pins.length} cached pins for stdlib require #{library.inspect}" }
-        else
-          super
+        elsif self.class.source.has? library, nil
+          super(library, out: out)
           unless resolved?
             @pins = []
-            logger.info { "Could not resolve #{library.inspect}" }
+            logger.debug { "StdlibMap could not resolve #{library.inspect}" }
             return
           end
           generated_pins = pins
@@ -33,6 +36,31 @@ module Solargraph
         end
       end
 
+      # @return [RBS::Collection::Sources::Stdlib]
+      def self.source
+        @source ||= RBS::Collection::Sources::Stdlib.instance
+      end
+
+      # @param name [String]
+      # @param version [String, nil]
+      # @return [Array<Hash{String => String}>, nil]
+      def self.stdlib_dependencies name, version = nil
+        if source.has?(name, version)
+          # @sg-ignore we are relying on undocumented behavior where
+          #   passing version=nil gives the latest version it has
+          source.dependencies_of(name, version)
+        else
+          []
+        end
+      end
+
+      def resolve_dependencies?
+        # there are 'virtual' dependencies for stdlib gems in RBS that
+        # aren't represented in the actual gemspecs that we'd
+        # otherwise use
+        true
+      end
+
       # @param library [String]
       # @return [StdlibMap]
       def self.load library

data/lib/solargraph/rbs_map.rb

@@ -16,17 +16,14 @@ module Solargraph
     # @type [Hash{String => RbsMap}]
     @@rbs_maps_hash = {}
 
-    attr_reader :library
-
-    attr_reader :rbs_collection_paths
-
-    attr_reader :rbs_collection_config_path
+    attr_reader :library, :rbs_collection_paths, :rbs_collection_config_path
 
     # @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: []
+    # @param out [StringIO, IO, nil] where to log messages
+    def initialize library, version = nil, rbs_collection_config_path: nil, rbs_collection_paths: [], out: $stderr
       if rbs_collection_config_path.nil? && !rbs_collection_paths.empty?
         raise 'Please provide rbs_collection_config_path if you provide rbs_collection_paths'
       end
@@ -37,6 +34,28 @@ module Solargraph
       add_library loader, library, version
     end
 
+    CACHE_KEY_GEM_EXPORT = 'gem-export'
+    CACHE_KEY_UNRESOLVED = 'unresolved'
+    CACHE_KEY_STDLIB = 'stdlib'
+    CACHE_KEY_LOCAL = 'local'
+
+    # @param cache_key [String, nil]
+    # @return [String, nil] a description of the source of the RBS info
+    def self.rbs_source_desc cache_key
+      case cache_key
+      when CACHE_KEY_GEM_EXPORT
+        'RBS gem export'
+      when CACHE_KEY_UNRESOLVED
+        nil
+      when CACHE_KEY_STDLIB
+        'RBS standard library'
+      when CACHE_KEY_LOCAL
+        'local RBS shims'
+      else
+        'RBS collection'
+      end
+    end
+
     # @return [RBS::EnvironmentLoader]
     def loader
       @loader ||= RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
@@ -47,10 +66,15 @@ module Solargraph
     #   updated upstream for the same library and version.  May change
     #   if the config for where information comes form changes.
     def cache_key
-      @hextdigest ||= begin
+      return CACHE_KEY_UNRESOLVED unless resolved?
+
+      @cache_key ||= begin
         # @type [String, nil]
         data = nil
+        # @type gem_config [nil, Hash{String => Hash{String => String}}]
+        gem_config = nil
         if rbs_collection_config_path
+          # @sg-ignore rbs_collection_config_path is not nil here
           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
@@ -58,16 +82,21 @@ module Solargraph
             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'
+        if gem_config.nil?
+          CACHE_KEY_STDLIB
+        else
+          # @type [String]
+          source = gem_config.dig('source', 'type')
+          case source
+          when 'rubygems'
+            CACHE_KEY_GEM_EXPORT
+          when 'local'
+            CACHE_KEY_LOCAL
+          when 'stdlib'
+            CACHE_KEY_STDLIB
           else
-            'unresolved'
+            Digest::SHA1.hexdigest(data || '')
           end
-        else
-          Digest::SHA1.hexdigest(data)
         end
       end
     end
@@ -77,6 +106,10 @@ module Solargraph
     # @param rbs_collection_config_path [String, Pathname, nil]
     # @return [RbsMap]
     def self.from_gemspec gemspec, rbs_collection_path, rbs_collection_config_path
+      # prefers stdlib RBS if available
+      rbs_map = RbsMap::StdlibMap.new(gemspec.name)
+      return rbs_map if rbs_map.resolved?
+
       rbs_map = RbsMap.new(gemspec.name, gemspec.version,
                            rbs_collection_paths: [rbs_collection_path].compact,
                            rbs_collection_config_path: rbs_collection_config_path)
@@ -88,18 +121,26 @@ module Solargraph
                  rbs_collection_config_path: rbs_collection_config_path)
     end
 
+    # @param out [IO, nil] where to log messages
     # @return [Array<Pin::Base>]
-    def pins
-      @pins ||= resolved? ? conversions.pins : []
+    def pins out: $stderr
+      @pins ||= if resolved?
+                  conversions.pins
+                else
+                  []
+                end
     end
 
     # @generic T
     # @param path [String]
     # @param klass [Class<generic<T>>]
+    #
+    # @sg-ignore Need to be able to resolve generics based on a
+    #   Class<generic<T>> param
     # @return [generic<T>, nil]
     def path_pin path, klass = Pin::Base
       pin = pins.find { |p| p.path == path }
-      pin if pin&.is_a?(klass)
+      pin if pin.is_a?(klass)
     end
 
     # @param path [String]
@@ -130,29 +171,32 @@ 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
 
+    def resolve_dependencies?
+      # we need to resolve dependencies via gemfile.lock manually for
+      # YARD regardless, so use same mechanism here so we don't
+      # duplicate work generating pins from dependencies
+      false
+    end
+
     # @param loader [RBS::EnvironmentLoader]
     # @param library [String]
-    # @param version [String, nil]
+    # @param version [String, nil] the version of the library to load, or nil for any
+    # @param out [StringIO, IO, nil] where to log messages
     # @return [Boolean] true if adding the library succeeded
-    def add_library loader, library, version
+    def add_library loader, library, version, out: $stderr
       @resolved = if loader.has_library?(library: library, version: version)
-        loader.add library: library, version: version
-        logger.debug { "#{short_name} successfully loaded library #{library}:#{version}" }
-        true
-      else
-        logger.info { "#{short_name} did not find data for library #{library}:#{version}" }
-        false
-      end
+                    loader.add library: library, version: version, resolve_dependencies: resolve_dependencies?
+                    logger.debug { "#{short_name} successfully loaded library #{library}:#{version}" }
+                    true
+                  else
+                    logger.info { "#{short_name} did not find data for library #{library}:#{version}" }
+                    false
+                  end
     end
 
     # @return [String]

data/lib/solargraph/rbs_translator.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # Convert RBS types to complex types and pins.
+  #
+  module RbsTranslator
+    RBS_TO_YARD_TYPE = {
+      'bool' => 'Boolean',
+      'string' => 'String',
+      'int' => 'Integer',
+      'untyped' => '',
+      'NilClass' => 'nil'
+    }
+
+    # @param type [RBS::Types::Bases::Base]
+    # @return [ComplexType]
+    def self.to_complex_type(type)
+      tag = type_to_tag(type)
+      ComplexType.try_parse(tag).force_rooted
+    end
+
+    # @param param_type [RBS::Types::Function::Param]
+    # @param name [String]
+    # @param decl [Symbol]
+    # @param closure [Pin::Closure]
+    # @return [Pin::Parameter]
+    def self.to_parameter_pin(param_type, name, decl, closure)
+      return_type = if decl == :restarg
+        ComplexType.parse('Array')
+      elsif decl == :kwrestarg
+        ComplexType.parse('Hash{Symbol => Object}')
+      else
+        RbsTranslator.to_complex_type(param_type.type)
+      end
+      Solargraph::Pin::Parameter.new(decl: decl, name: name, closure: closure, return_type: return_type, source: :rbs, type_location: to_sg_location(param_type.location) || closure.type_location)
+    end
+
+    # @param method_type [RBS::MethodType]
+    # @param closure [Pin::Closure]
+    # @param parameter_names [Array<String>]
+    # @return [Array<Pin::Parameter>]
+    def self.to_parameter_pins method_type, closure, parameter_names = []
+      if defined?(RBS::Types::UntypedFunction) && method_type.type.is_a?(RBS::Types::UntypedFunction)
+        return [
+          Solargraph::Pin::Parameter.new(decl: :restarg, name: 'arg', closure: closure, source: :rbs)
+        ]
+      end
+
+      arg_num = 0
+      params = []
+      method_type.type.required_positionals.each do |param|
+        params.push RbsTranslator.to_parameter_pin(param, param.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :arg, closure)
+        arg_num += 1
+      end
+      method_type.type.optional_positionals.each do |param|
+        params.push RbsTranslator.to_parameter_pin(param, param.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :optarg, closure)
+        arg_num += 1
+      end
+      if method_type.type.rest_positionals
+        params.push RbsTranslator.to_parameter_pin(method_type.type.rest_positionals, method_type.type.rest_positionals.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :restarg, closure)
+        arg_num += 1
+      end
+      method_type.type.required_keywords.each do |param|
+        params.push RbsTranslator.to_parameter_pin(param.last, param.first.to_s, :kwarg, closure)
+        arg_num += 1
+      end
+      method_type.type.optional_keywords.each do |param|
+        params.push RbsTranslator.to_parameter_pin(param.last, param.first.to_s, :kwoptarg, closure)
+        arg_num += 1
+      end
+      if method_type.type.rest_keywords
+        params.push RbsTranslator.to_parameter_pin(method_type.type.rest_keywords, method_type.type.rest_keywords.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :kwrestarg, closure)
+      end
+      params
+    end
+
+    # @param method_type [RBS::MethodType]
+    # @param closure [Pin::Closure]
+    # @param parameter_names [Array<String>]
+    # @return [Pin::Signature]
+    def self.to_signature method_type, closure, parameter_names = []
+      # There may be edge cases here around different signatures
+      # having different type params / orders - we may need to match
+      # this data model and have generics live in signatures to
+      # handle those correctly
+      generics = method_type.type_params.map(&:name).map(&:to_s).uniq
+      parameters = to_parameter_pins(method_type, closure, parameter_names)
+      return_type = to_complex_type(method_type.type.return_type)
+      block = if method_type.block
+        block_parameters = to_parameter_pins(method_type.block, closure)
+        block_return_type = to_complex_type(method_type.block.type.return_type)
+        Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type, source: :rbs, type_location: closure.location, closure: closure)
+      end
+      Pin::Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block, source: :rbs, type_location: closure.location, closure: closure)
+    end
+
+    # @param type_name [RBS::TypeName]
+    # @param type_args [Enumerable<RBS::Types::Bases::Base>]
+    # @return [ComplexType::UniqueType]
+    def self.build_unique_type(type_name, type_args = [])
+      base = RBS_TO_YARD_TYPE[type_name.relative!.to_s] || type_name.relative!.to_s
+      params = type_args.map do |a|
+        RbsTranslator.to_complex_type(a)
+      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.reject(&:undefined?), rooted: true, parameters_type: :list)
+      end
+    end
+
+    # @param location [RBS::Location, nil]
+    # @return [Solargraph::Location, nil]
+    def self.to_sg_location(location)
+      return nil if location&.name.nil?
+
+      start_pos = Position.new(location.start_line - 1, location.start_column)
+      end_pos = Position.new(location.end_line - 1, location.end_column)
+      range = Range.new(start_pos, end_pos)
+      Location.new(location.name.to_s, range)
+    end
+
+    class << self
+      private
+
+      # @param type [RBS::Types::Bases::Base]
+      # @return [String]
+      def type_to_tag type
+        case type
+        when RBS::Types::Optional
+          "#{type_to_tag(type.type)}, nil"
+        when RBS::Types::Bases::Bool
+          'Boolean'
+        when RBS::Types::Tuple
+          "Array(#{type.types.map { |t| type_to_tag(t) }.join(', ')})"
+        when RBS::Types::Literal
+          type.literal.inspect
+        when RBS::Types::Union
+          type.types.map { |t| type_to_tag(t) }.join(', ')
+        when RBS::Types::Record
+          # @todo Better record support
+          'Hash'
+        when RBS::Types::Bases::Nil
+          'nil'
+        when RBS::Types::Bases::Void
+          'void'
+        when RBS::Types::Variable
+          "#{Solargraph::ComplexType::GENERIC_TAG_NAME}<#{type.name}>"
+        when RBS::Types::Bases::Self, RBS::Types::Bases::Instance
+          'self'
+        when RBS::Types::Bases::Top
+          # `Top` is the most super superclass
+          'BasicObject'
+        when RBS::Types::Intersection
+          type.types.map { |member| type_to_tag(member) }.join(', ')
+        when RBS::Types::Proc
+          'Proc'
+        when RBS::Types::ClassInstance, RBS::Types::Alias, RBS::Types::Interface
+          # `Alias` is a top-level type alias, e.g., 'bool' in "type bool = true | false"
+          # @todo ensure these get resolved after processing all aliases
+          # @todo handle recursive aliases
+          #
+          # `Interface represents a mix-in module which can be considered a
+          # subtype of a consumer of it
+          #
+          type_tag(type.name, type.args)
+        when RBS::Types::ClassSingleton
+          # e.g., singleton(String)
+          type_tag(type.name)
+        when RBS::Types::Bases::Any, RBS::Types::Bases::Bottom
+          # `Bottom`` is used in contexts where nothing will ever return
+          # - e.g., it could be the return type of 'exit()' or 'raise'
+          # @todo define a specific bottom type and use it to
+          #   determine dead code
+          #
+          'undefined'
+        else
+          Solargraph.logger.warn "Unrecognized RBS type: #{type.class} at #{type.location}"
+          'undefined'
+        end
+      end
+
+      # @param type_name [RBS::TypeName]
+      # @param type_args [Enumerable<RBS::Types::Bases::Base>]
+      # @return [String]
+      def type_tag(type_name, type_args = [])
+        build_type(type_name, type_args).tags
+      end
+
+      # @param type_name [RBS::TypeName]
+      # @param type_args [Enumerable<RBS::Types::Bases::Base>]
+      # @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| type_to_tag(a) }.map do |t|
+          ComplexType.try_parse(t)
+        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.reject(&:undefined?), rooted: true, parameters_type: :list)
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/server_methods.rb

@@ -7,7 +7,7 @@ module Solargraph
     # @return [Integer]
     def available_port
       socket = Socket.new(:INET, :STREAM, 0)
-      socket.bind(Addrinfo.tcp("127.0.0.1", 0))
+      socket.bind(Addrinfo.tcp('127.0.0.1', 0))
       port = socket.local_address.ip_port
       socket.close
       port