solargraph 0.58.2 → 0.59.0.dev.1

data/lib/solargraph/range.rb

@@ -19,7 +19,6 @@ module Solargraph
       @ending = ending
     end
 
-    # @sg-ignore Fix "Not enough arguments to Module#protected"
     protected def equality_fields
       [start, ending]
     end
@@ -27,12 +26,9 @@ module Solargraph
     # @param other [BasicObject]
     def <=>(other)
       return nil unless other.is_a?(Range)
-      # @sg-ignore https://github.com/castwide/solargraph/pull/1114
       if start == other.start
-        # @sg-ignore https://github.com/castwide/solargraph/pull/1114
         ending <=> other.ending
       else
-        # @sg-ignore https://github.com/castwide/solargraph/pull/1114
         start <=> other.start
       end
     end
@@ -54,8 +50,11 @@ module Solargraph
     # @return [Boolean]
     def contain? position
       position = Position.normalize(position)
+      # @sg-ignore flow sensitive typing should be able to handle redefinition
       return false if position.line < start.line || position.line > ending.line
+      # @sg-ignore flow sensitive typing should be able to handle redefinition
       return false if position.line == start.line && position.character < start.character
+      # @sg-ignore flow sensitive typing should be able to handle redefinition
       return false if position.line == ending.line && position.character > ending.character
       true
     end
@@ -63,9 +62,11 @@ module Solargraph
     # True if the range contains the specified position and the position does not precede it.
     #
     # @param position [Position, Array(Integer, Integer)]
+    # @sg-ignore flow sensitive typing should be able to handle redefinition
     # @return [Boolean]
     def include? position
       position = Position.normalize(position)
+      # @sg-ignore flow sensitive typing should be able to handle redefinition
       contain?(position) && !(position.line == start.line && position.character == start.character)
     end
 
@@ -82,7 +83,7 @@ module Solargraph
 
     # Get a range from a node.
     #
-    # @param node [Parser::AST::Node]
+    # @param node [::Parser::AST::Node]
     # @return [Range, nil]
     def self.from_node node
       if node&.loc && node.loc.expression
@@ -101,7 +102,6 @@ module Solargraph
 
     def == other
       return false unless other.is_a?(Range)
-      # @sg-ignore https://github.com/castwide/solargraph/pull/1114
       start == other.start && ending == other.ending
     end
 

data/lib/solargraph/rbs_map/conversions.rb

@@ -65,7 +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
+          # @sg-ignore flow sensitive typing should support case/when
           type_aliases[decl.name.to_s] = decl
         when RBS::AST::Declarations::Module
           module_decl_to_pin decl
@@ -96,7 +96,7 @@ module Solargraph
         type = build_type(decl.name, decl.args)
         generic_values = type.all_params.map(&:to_s)
         include_pin = Solargraph::Pin::Reference::Include.new(
-          name: decl.name.relative!.to_s,
+          name: type.rooted_name,
           type_location: location_decl_to_pin_location(decl.location),
           generic_values: generic_values,
           closure: closure,
@@ -120,32 +120,44 @@ module Solargraph
       def convert_member_to_pin member, closure, context
         case member
         when RBS::AST::Members::MethodDefinition
+          # @sg-ignore flow based typing needs to understand case when class pattern
           method_def_to_pin(member, closure, context)
         when RBS::AST::Members::AttrReader
+          # @sg-ignore flow based typing needs to understand case when class pattern
           attr_reader_to_pin(member, closure, context)
         when RBS::AST::Members::AttrWriter
+          # @sg-ignore flow based typing needs to understand case when class pattern
           attr_writer_to_pin(member, closure, context)
         when RBS::AST::Members::AttrAccessor
+          # @sg-ignore flow based typing needs to understand case when class pattern
           attr_accessor_to_pin(member, closure, context)
         when RBS::AST::Members::Include
+          # @sg-ignore flow based typing needs to understand case when class pattern
           include_to_pin(member, closure)
         when RBS::AST::Members::Prepend
+          # @sg-ignore flow based typing needs to understand case when class pattern
           prepend_to_pin(member, closure)
         when RBS::AST::Members::Extend
+          # @sg-ignore flow based typing needs to understand case when class pattern
           extend_to_pin(member, closure)
         when RBS::AST::Members::Alias
+          # @sg-ignore flow based typing needs to understand case when class pattern
           alias_to_pin(member, closure)
         when RBS::AST::Members::ClassInstanceVariable
+          # @sg-ignore flow based typing needs to understand case when class pattern
           civar_to_pin(member, closure)
         when RBS::AST::Members::ClassVariable
+          # @sg-ignore flow based typing needs to understand case when class pattern
           cvar_to_pin(member, closure)
         when RBS::AST::Members::InstanceVariable
+          # @sg-ignore flow based typing needs to understand case when class pattern
           ivar_to_pin(member, closure)
         when RBS::AST::Members::Public
           return Context.new(:public)
         when RBS::AST::Members::Private
           return Context.new(:private)
         when RBS::AST::Declarations::Base
+          # @sg-ignore flow based typing needs to understand case when class pattern
           convert_decl_to_pin(member, closure)
         else
           Solargraph.logger.warn "Skipping member type #{member.class}"
@@ -232,12 +244,14 @@ module Solargraph
         convert_self_types_to_pins decl, module_pin
         convert_members_to_pins decl, module_pin
 
+        raise "Invalid type for module declaration: #{module_pin.class}" unless module_pin.is_a?(Pin::Namespace)
+
         add_mixins decl, module_pin.closure
       end
 
       # @param name [String]
       # @param tag [String]
-      # @param comments [String]
+      # @param comments [String, nil]
       # @param decl [RBS::AST::Declarations::ClassAlias, RBS::AST::Declarations::Constant, RBS::AST::Declarations::ModuleAlias]
       # @param base [String, nil] Optional conversion of tag to base<tag>
       #
@@ -246,6 +260,7 @@ module Solargraph
         parts = name.split('::')
         if parts.length > 1
           name = parts.last
+          # @sg-ignore Need to add nil check here
           closure = pins.select { |pin| pin && pin.path == parts[0..-2].join('::') }.first
         else
           name = parts.first
@@ -347,12 +362,11 @@ module Solargraph
         ["Rainbow::Presenter", :instance, "wrap_with_sgr"] => :private,
       }
 
-      # @param decl [RBS::AST::Members::MethodDefinition, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrAccessor]
+      # @param decl [RBS::AST::Members::MethodDefinition, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter, RBS::AST::Members::AttrAccessor]
       # @param closure [Pin::Closure]
       # @param context [Context]
       # @param scope [Symbol] :instance or :class
       # @param name [String] The name of the method
-      # @sg-ignore
       # @return [Symbol]
       def calculate_method_visibility(decl, context, closure, scope, name)
         override_key = [closure.path, scope, name]
@@ -432,8 +446,9 @@ module Solargraph
           type_location = location_decl_to_pin_location(overload.method_type.location)
           generics = overload.method_type.type_params.map(&:name).map(&:to_s)
           signature_parameters, signature_return_type = parts_of_function(overload.method_type, pin)
-          block = if overload.method_type.block
-                    block_parameters, block_return_type = parts_of_function(overload.method_type.block, pin)
+          rbs_block = overload.method_type.block
+          block = if rbs_block
+                    block_parameters, block_return_type = parts_of_function(rbs_block, pin)
                     Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type, source: :rbs,
                                        type_location: type_location, closure: pin)
                   end
@@ -447,9 +462,12 @@ module Solargraph
       def location_decl_to_pin_location(location)
         return nil if location&.name.nil?
 
+        # @sg-ignore flow sensitive typing should handle return nil if location&.name.nil?
         start_pos = Position.new(location.start_line - 1, location.start_column)
+        # @sg-ignore flow sensitive typing should handle return nil if location&.name.nil?
         end_pos = Position.new(location.end_line - 1, location.end_column)
         range = Range.new(start_pos, end_pos)
+        # @sg-ignore flow sensitve typing should handle return nil if location&.name.nil?
         Location.new(location.name.to_s, range)
       end
 
@@ -705,7 +723,7 @@ module Solargraph
         'NilClass' => 'nil'
       }
 
-      # @param type [RBS::MethodType]
+      # @param type [RBS::MethodType, RBS::Types::Block]
       # @return [String]
       def method_type_to_tag type
         if type_aliases.key?(type.type.return_type.to_s)
@@ -737,7 +755,9 @@ module Solargraph
         build_type(type_name, type_args).tags
       end
 
-      # @param type [RBS::Types::Bases::Base]
+      # @param type [RBS::Types::Bases::Base,Object] RBS type object.
+      #   Note: Generally these extend from RBS::Types::Bases::Base,
+      #   but not all.
       # @return [String]
       def other_type_to_tag type
         if type.is_a?(RBS::Types::Optional)
@@ -794,13 +814,16 @@ module Solargraph
           # e.g., singleton(String)
           type_tag(type.name)
         else
+          # RBS doesn't provide a common base class for its type AST nodes
+          #
+          # @sg-ignore all types should include location
           Solargraph.logger.warn "Unrecognized RBS type: #{type.class} at #{type.location}"
           'undefined'
         end
       end
 
       # @param decl [RBS::AST::Declarations::Class, RBS::AST::Declarations::Module]
-      # @param namespace [Pin::Namespace]
+      # @param namespace [Pin::Namespace, nil]
       # @return [void]
       def add_mixins decl, namespace
         # @param mixin [RBS::AST::Members::Include, RBS::AST::Members::Members::Extend, RBS::AST::Members::Members::Prepend]

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,23 @@ 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 +37,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

@@ -26,7 +26,8 @@ module Solargraph
     # @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 +38,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 +70,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
+      return CACHE_KEY_UNRESOLVED unless resolved?
+
       @hextdigest ||= 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 flow sensitive typing needs to handle attrs
           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 +86,22 @@ 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'
+            # @sg-ignore Need to add nil check here
+            Digest::SHA1.hexdigest(data)
           end
-        else
-          Digest::SHA1.hexdigest(data)
         end
       end
     end
@@ -77,6 +111,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,14 +126,22 @@ 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 }
@@ -140,19 +186,27 @@ module Solargraph
       @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]