solargraph 0.61.0 → 0.62.0

data/lib/solargraph/rbs_collection.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # The RBS collection declared by a project's rbs_collection.lock.yaml.
+  #
+  class RbsCollection
+    attr_reader :lockfile
+
+    def initialize lockfile
+      @lockfile = File.expand_path(lockfile) if lockfile
+    end
+
+    # @param metagem [Metagem]
+    # @return [Array<Pin::Base>]
+    def load metagem
+      key = best_key(metagem)
+      return [] unless key
+      mem_cache[key] ||= RbsMap::Path.pins(gem_path_map[key])
+    end
+
+    def gem_keys
+      gem_path_map.keys
+    end
+
+    # The names of the stdlib signature sets declared by the collection.
+    #
+    # +rbs collection install+ resolves these to the signatures which ship
+    # with the rbs gem instead of copying them into the collection directory,
+    # so they can never be located by a gem name/version lookup.
+    #
+    # @return [Array<String>]
+    def stdlib_names
+      @stdlib_names ||= raw_data[:gems].select { |gem| gem.dig(:source, :type).to_s == 'stdlib' }
+                                       .map { |gem| gem[:name].to_s }.uniq
+    end
+
+    private
+
+    def gem_path_map
+      @gem_path_map ||= raw_data[:gems].to_h { |gem| ["#{gem[:name]}-#{gem[:version]}", gem_source_path(gem)] }
+    end
+
+    # The versions available in the collection for each gem name.
+    #
+    # @return [Hash{String => Array<String>}]
+    def versions_by_name
+      @versions_by_name ||= raw_data[:gems].group_by { |gem| gem[:name].to_s }
+                                           .transform_values { |gems| gems.map { |gem| gem[:version].to_s } }
+    end
+
+    def best_key metagem
+      key = "#{metagem.name}-#{metagem.version}"
+      return key if gem_path_map.key?(key)
+
+      full_key = "#{metagem.name}-#{metagem.version}."
+      zero_key = "#{metagem.name}-0"
+      found = gem_path_map.find { |key, _| full_key.start_with?("#{key}.") } ||
+              gem_path_map.find { |key, _| key == zero_key }
+      found&.first || closest_key(metagem)
+    end
+
+    # Signature collections version their directories independently from the
+    # gems they describe. gem_rbs_collection, for example, provides
+    # +actionpack/6.0+ for every Rails 6 and 7 release and +devise/4.9+ for
+    # Devise 4 and 5. When no directory matches a gem's version, fall back to
+    # the closest version the collection provides for that gem, preferring the
+    # highest one that does not exceed the gem's version.
+    #
+    # @param metagem [Metagem]
+    # @return [String, nil]
+    def closest_key metagem
+      versions = versions_by_name[metagem.name.to_s]
+      return nil if versions.nil? || versions.empty?
+      return "#{metagem.name}-#{versions.first}" if versions.size == 1
+      parsed = versions.map { |version| [version, parse_version(version)] }
+      usable = parsed.compact
+      gem_version = parse_version(metagem.version)
+      chosen = if gem_version
+                 usable.reject { |_, parsed_version| parsed_version > gem_version }.max_by { |_, parsed_version| parsed_version }
+               end
+      chosen ||= usable.min_by { |_, parsed_version| parsed_version }
+      chosen ||= parsed.first
+      "#{metagem.name}-#{chosen[0]}"
+    end
+
+    # @param value [Object]
+    # @return [Gem::Version, nil]
+    def parse_version value
+      Gem::Version.new value.to_s
+    rescue ArgumentError
+      nil
+    end
+
+    # @param gem_hash [Hash]
+    def gem_source_path gem_hash
+      root_path = gem_hash.dig(:source, :path) || raw_data[:path]
+      return unless root_path
+      gem_path = File.join(root_path, gem_hash[:name], gem_hash[:version])
+      File.expand_path(gem_path, File.dirname(lockfile))
+    end
+
+    def gem_rbs_collection_path
+      @gem_rbs_collection_path ||= File.expand_path(raw_data[:path]) if raw_data[:path]
+    end
+
+    # @return [Hash]
+    def raw_data
+      @raw_data ||= if lockfile && File.file?(lockfile)
+                      YAML.load_file(lockfile, symbolize_names: true)
+                    else
+                      { gems: [] }
+                    end
+    end
+
+    def mem_cache
+      @mem_cache ||= {}
+    end
+  end
+end

data/lib/solargraph/rbs_map/conversions.rb

@@ -37,6 +37,11 @@ module Solargraph
 
       private
 
+      # @return [Hash{String => RBS::AST::Declarations::TypeAlias}]
+      def type_alias_decls
+        @type_alias_decls ||= {}
+      end
+
       # @param loader [RBS::EnvironmentLoader]
       #
       # @return [void]
@@ -48,11 +53,64 @@ module Solargraph
                                  "directories #{loader.dirs}"
           return
         end
+        # Register up front so expansion does not depend on declaration order.
+        core_aware_environment(loader, fallback: environment).type_alias_decls.each_value do |entry|
+          type_alias_decls[entry.decl.name.to_s] = entry.decl
+        end
+        # @sg-ignore Need a downcast here
         environment.declarations.each { |decl| convert_decl_to_pin(decl, Solargraph::Pin::ROOT_PIN) }
       rescue RBS::DuplicatedDeclarationError => e
         Solargraph.logger.warn "RBS conversion failed due to duplicate declarations: [#{e.class}] #{e.message}"
       end
 
+      # A non-core RbsMap omits core so its pins do not re-declare CoreMap's,
+      # which leaves #resolve_type_names unable to bind an alias pointing into
+      # core. Resolve alias names against core separately; pins do not.
+      #
+      # @param loader [RBS::EnvironmentLoader]
+      # @param fallback [RBS::Environment] the already-resolved, core-less
+      #   environment to use if a core-aware one can't be built
+      # @return [RBS::Environment]
+      def core_aware_environment loader, fallback:
+        return fallback unless loader.core_root.nil?
+        return fallback unless rebound_alias?(fallback)
+
+        # Loading core makes RBS add the stringio library, which only the
+        # stdlib repository provides.
+        core_repository = RBS::Repository.new(no_stdlib: false)
+        loader.repository.dirs.each { |dir| core_repository.add(dir) unless core_repository.dirs.include?(dir) }
+        core_loader = RBS::EnvironmentLoader.new(repository: core_repository)
+        loader.libs.each { |lib| core_loader.add(library: lib.name, version: lib.version) }
+        loader.dirs.each { |dir| core_loader.add(path: dir) }
+        RBS::Environment.from_loader(core_loader).resolve_type_names
+      rescue RBS::DuplicatedDeclarationError => e
+        # A local RBS shim may redeclare a core name; nominal tags beat no pins.
+        logger.warn do
+          "Could not build a core-aware environment for #{loader.libs}: #{e.message}. " \
+            'Type aliases referencing names declared in RBS core will not be expanded ' \
+            'for these libraries, and will be typed by their alias name instead.'
+        end
+        fallback
+      end
+
+      # A reference into absent core survives #resolve_type_names naming
+      # either the alias itself or a name nothing declares.
+      #
+      # @param environment [RBS::Environment]
+      # @return [Boolean]
+      def rebound_alias? environment
+        decls = environment.type_alias_decls
+        decls.any? do |name, entry|
+          # @sg-ignore Unresolved call to decl on generic<D>
+          type = entry.decl.type
+          # @sg-ignore Unresolved call to is_a? on generic<D>
+          next false unless type.is_a?(RBS::Types::Alias)
+
+          # @sg-ignore Unresolved call to to_s on generic<D>
+          type.name.to_s == name.to_s || !decls.key?(type.name)
+        end
+      end
+
       # @param decl [RBS::AST::Declarations::Base]
       # @param closure [Pin::Closure]
       # @return [void]
@@ -77,11 +135,12 @@ module Solargraph
                                      # @sg-ignore flow sensitive typing should support case/when
                                      "Ignoring closure #{closure.inspect} on alias type name #{decl.name}")
           end
+          # @sg-ignore flow sensitive typing should support case/when
+          alias_return_type = RbsTranslator.to_complex_type(decl.type, type_alias_decls: type_alias_decls).force_rooted
           pins.push(
-            # @sg-ignore Wrong argument type for Solargraph::Pin::Reference::TypeAlias.new: return_type expected Solargraph::ComplexType, received Solargraph::ComplexType::UniqueType, Solargraph::ComplexType
             Solargraph::Pin::Reference::TypeAlias.new(
-              # @sg-ignore Unresolved calls to name, type, type_location; return_type type mismatch
-              name: ComplexType.try_parse(decl.name.to_s).to_s, return_type: RbsTranslator.to_complex_type(decl.type).force_rooted, closure: closure, source: :rbs, type_location: location_decl_to_pin_location(decl.location)
+              # @sg-ignore flow sensitive typing should support case/when
+              name: ComplexType.try_parse(decl.name.to_s).to_s, return_type: alias_return_type, closure: closure, source: :rbs, type_location: location_decl_to_pin_location(decl.location)
             )
           )
         when RBS::AST::Declarations::Module
@@ -255,10 +314,10 @@ module Solargraph
         # @type [Hash{String => ComplexType, ComplexType::UniqueType}]
         generic_defaults = {}
         decl.type_params.each do |param|
-          if param.default_type
-            complex_type = RbsTranslator.to_complex_type(param.default_type).force_rooted
-            generic_defaults[param.name.to_s] = complex_type
-          end
+          next unless param.default_type
+          # @sg-ignore Wrong argument type for to_complex_type: type expected RBS::Types::Bases::Base, received union of concrete subtypes, nil
+          complex_type = RbsTranslator.to_complex_type(param.default_type, type_alias_decls: type_alias_decls).force_rooted
+          generic_defaults[param.name.to_s] = complex_type
         end
 
         class_name = fqns(decl.name)
@@ -282,7 +341,6 @@ module Solargraph
         if decl.super_class
           type = build_type(decl.super_class.name, decl.super_class.args)
           generic_values = type.all_params.map(&:to_s)
-          superclass_name = decl.super_class.name.to_s
           pins.push Solargraph::Pin::Reference::Superclass.new(
             type_location: location_decl_to_pin_location(decl.super_class.location),
             closure: class_pin,
@@ -394,7 +452,7 @@ module Solargraph
       # @param decl [RBS::AST::Declarations::Constant]
       # @return [void]
       def constant_decl_to_pin decl
-        tag = RbsTranslator.to_complex_type(decl.type)
+        tag = RbsTranslator.to_complex_type(decl.type, type_alias_decls: type_alias_decls)
         pins.push create_constant(decl.name.relative!.to_s, tag, decl.comment&.string, decl)
       end
 
@@ -410,7 +468,7 @@ module Solargraph
           type_location: location_decl_to_pin_location(decl.location),
           source: :rbs
         )
-        rooted_tag = RbsTranslator.to_complex_type(decl.type).force_rooted.rooted_tags
+        rooted_tag = RbsTranslator.to_complex_type(decl.type, type_alias_decls: type_alias_decls).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', rooted_tag))
         pins.push pin
       end
@@ -516,51 +574,51 @@ module Solargraph
             pin.instance_variable_set(:@return_type, ComplexType::VOID)
           end
         end
-        if decl.singleton?
-          final_scope = :class
-          name = decl.name.to_s
-          visibility = calculate_method_visibility(decl, context, closure, final_scope, name)
-          pin = Solargraph::Pin::Method.new(
-            name: name,
-            closure: closure,
-            comments: decl.comment&.string,
-            type_location: location_decl_to_pin_location(decl.location),
-            visibility: visibility,
-            scope: final_scope,
-            signatures: [],
-            generics: generics,
-            source: :rbs
-          )
-          pin.signatures.concat method_def_to_sigs(decl, pin)
-          pins.push pin
-        end
+        return unless decl.singleton?
+        final_scope = :class
+        name = decl.name.to_s
+        visibility = calculate_method_visibility(decl, context, closure, final_scope, name)
+        pin = Solargraph::Pin::Method.new(
+          name: name,
+          closure: closure,
+          comments: decl.comment&.string,
+          type_location: location_decl_to_pin_location(decl.location),
+          visibility: visibility,
+          scope: final_scope,
+          signatures: [],
+          generics: generics,
+          source: :rbs
+        )
+        pin.signatures.concat method_def_to_sigs(decl, pin)
+        pins.push pin
       end
 
       # @param decl [RBS::AST::Members::MethodDefinition]
       # @param pin [Pin::Method]
       # @return [void]
       def method_def_to_sigs decl, pin
-        # rubocop:disable Style/SafeNavigationChainLength
-        implicit_nil = decl.overloads.first&.annotations&.map(&:string)&.include?('implicitly-returns-nil') || false
-        # rubocop:enable Style/SafeNavigationChainLength
         # @param overload [RBS::AST::Members::MethodDefinition::Overload]
         decl.overloads.map do |overload|
+          # RBS attaches this annotation to a single overload, not to the method as a whole
+          implicit_nil = overload.annotations.map(&:string).include?('implicitly-returns-nil')
           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, implicit_nil)
           block = if overload.method_type.block
-                    block_parameters, block_return_type = parts_of_function(overload.method_type.block, pin, implicit_nil)
+                    # the annotation describes the method's return value, not the block's
+                    block_parameters, block_return_type = parts_of_function(overload.method_type.block, pin, false)
                     Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type, source: :rbs,
                                        type_location: type_location, closure: pin)
                   end
-          Pin::Signature.new(generics: generics, parameters: signature_parameters, return_type: signature_return_type, block: block, source: :rbs,
+          Pin::Signature.new(generics: generics, parameters: signature_parameters, return_type: signature_return_type, block: block,
+                             block_required: overload.method_type.block&.required || false, source: :rbs,
                              type_location: type_location, closure: pin)
         end
       end
 
       # @param location [RBS::Location, nil]
       # @return [Solargraph::Location, nil]
-      def location_decl_to_pin_location(location)
+      def location_decl_to_pin_location location
         return nil if location&.name.nil?
 
         start_pos = Position.new(location.start_line - 1, location.start_column)
@@ -575,7 +633,7 @@ module Solargraph
       # @return [Array(Array<Pin::Parameter>, ComplexType)]
       def parts_of_function type, pin, implicit_nil
         [
-          RbsTranslator.to_parameter_pins(type, pin, pin.parameter_names),
+          RbsTranslator.to_parameter_pins(type, pin, pin.parameter_names, type_alias_decls: type_alias_decls),
           extract_method_type_return_type(type, implicit_nil).force_rooted
         ]
       end
@@ -598,7 +656,7 @@ module Solargraph
           visibility: visibility,
           source: :rbs
         )
-        rooted_tag = RbsTranslator.to_complex_type(decl.type).force_rooted.rooted_tags
+        rooted_tag = RbsTranslator.to_complex_type(decl.type, type_alias_decls: type_alias_decls).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', rooted_tag))
         logger.debug do
           "Conversions#attr_reader_to_pin(name=#{name.inspect}, visibility=#{visibility.inspect}) => #{pin.inspect}"
@@ -629,12 +687,12 @@ module Solargraph
         pin.parameters <<
           Solargraph::Pin::Parameter.new(
             name: 'value',
-            return_type: RbsTranslator.to_complex_type(decl.type).force_rooted,
+            return_type: RbsTranslator.to_complex_type(decl.type, type_alias_decls: type_alias_decls).force_rooted,
             source: :rbs,
             closure: pin,
             type_location: type_location
           )
-        rooted_tag = RbsTranslator.to_complex_type(decl.type).force_rooted.rooted_tags
+        rooted_tag = RbsTranslator.to_complex_type(decl.type, type_alias_decls: type_alias_decls).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', rooted_tag))
         pins.push pin
       end
@@ -659,7 +717,7 @@ module Solargraph
           comments: decl.comment&.string,
           source: :rbs
         )
-        rooted_tag = RbsTranslator.to_complex_type(decl.type).force_rooted.rooted_tags
+        rooted_tag = RbsTranslator.to_complex_type(decl.type, type_alias_decls: type_alias_decls).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', rooted_tag))
         pins.push pin
       end
@@ -676,7 +734,7 @@ module Solargraph
           type_location: location_decl_to_pin_location(decl.location),
           source: :rbs
         )
-        rooted_tag = RbsTranslator.to_complex_type(decl.type).force_rooted.rooted_tags
+        rooted_tag = RbsTranslator.to_complex_type(decl.type, type_alias_decls: type_alias_decls).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', rooted_tag))
         pins.push pin
       end
@@ -693,7 +751,7 @@ module Solargraph
           type_location: location_decl_to_pin_location(decl.location),
           source: :rbs
         )
-        rooted_tag = RbsTranslator.to_complex_type(decl.type).force_rooted.rooted_tags
+        rooted_tag = RbsTranslator.to_complex_type(decl.type, type_alias_decls: type_alias_decls).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', rooted_tag))
         pins.push pin
       end
@@ -762,7 +820,7 @@ module Solargraph
         'int' => 'Integer',
         'untyped' => '',
         'NilClass' => 'nil'
-      }
+      }.freeze
       private_constant :RBS_TO_YARD_TYPE
 
       # Extract a ComplexType from a MethodType's return type.
@@ -771,18 +829,19 @@ module Solargraph
       #
       # @param type [RBS::MethodType]
       # @return [ComplexType]
+      # @param [Object] implicit_nil
       def extract_method_type_return_type type, implicit_nil
-          tag = RbsTranslator.to_complex_type(type.type.return_type)
-          return ComplexType.parse("#{tag}, nil") if tag && implicit_nil
-          tag
+        tag = RbsTranslator.to_complex_type(type.type.return_type, type_alias_decls: type_alias_decls)
+        return ComplexType.parse("#{tag}, nil") if tag && implicit_nil
+        tag
       end
 
       # @param type_name [RBS::TypeName]
       # @param type_args [Enumerable<RBS::Types::Bases::Base>]
       # @return [ComplexType::UniqueType]
-      def build_type(type_name, type_args = [])
+      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 { |arg| RbsTranslator.to_complex_type(arg).force_rooted }
+        params = type_args.map { |arg| RbsTranslator.to_complex_type(arg, type_alias_decls: type_alias_decls).force_rooted }
         if base == 'Hash' && params.length == 2
           ComplexType::UniqueType.new(base, [params.first], [params.last], rooted: true, parameters_type: :hash)
         else

data/lib/solargraph/rbs_map/gem.rb

@@ -6,7 +6,10 @@ module Solargraph
       # @param metagem [Metagem]
       def initialize metagem
         super()
-        loader.add path: Pathname.new(metagem.full_path)
+        # Gems ship their signatures in sig/, the directory RBS itself
+        # loads; other .rbs files (e.g., the rbs gem's core/) are not the
+        # gem's own API
+        loader.add path: Pathname.new(metagem.full_path).join('sig')
       end
     end
   end

data/lib/solargraph/rbs_map/helpers.rb

@@ -44,12 +44,13 @@ module Solargraph
         # @param pin [Pin::Method]
         out = pins.reduce(combined_pin) do |memo, pin|
           next pin if memo.nil?
-          if memo == pin && memo.source != :combined
-            # @todo we should track down situations where we are handled
-            #   the same pin from the same source here and eliminate them -
-            #   this is an efficiency workaround for now
-            next memo
-          end
+          # @todo Maybe wrong now. External runs multiple rounds of combinations
+          # if memo == pin && memo.source != :combined
+          #   # @todo we should track down situations where we are handled
+          #   #   the same pin from the same source here and eliminate them -
+          #   #   this is an efficiency workaround for now
+          #   next memo
+          # end
           memo.combine_with(pin)
         end
         Solargraph.logger.debug { "GemPins.combine_method_pins(pins.length=#{pins.length}, pins=#{pins}) => #{out.inspect}" }