solargraph 0.60.4 → 0.62.0

data/lib/solargraph/rbs_map/conversions.rb

@@ -3,7 +3,7 @@
 require 'rbs'
 
 module Solargraph
-  class RbsMap
+  module RbsMap
     # Functions for converting RBS declarations to Solargraph pins
     #
     class Conversions
@@ -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,7 +53,62 @@ 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]
@@ -75,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
@@ -253,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)
@@ -280,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,
@@ -392,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
 
@@ -408,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
@@ -514,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)
@@ -573,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
@@ -596,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}"
@@ -627,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
@@ -657,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
@@ -674,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
@@ -691,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
@@ -760,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.
@@ -769,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/{core_map.rb → core.rb}

@@ -1,39 +1,32 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class RbsMap
-    # Ruby core pins
-    #
-    class CoreMap
-      include Logging
+  module RbsMap
+    class Core < Base
+      FILLS_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'rbs', 'fills'))
 
-      def resolved?
-        true
+      def pins
+        @pins ||= generate_pins
       end
 
-      FILLS_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'rbs', 'fills'))
-
-      def initialize; end
+      # @return [RBS::EnvironmentLoader]
+      def loader
+        @loader ||= RBS::EnvironmentLoader.new(repository: repository)
+      end
 
-      # @param out [IO, nil] output stream for logging
-      # @return [Enumerable<Pin::Base>]
-      def pins out: $stderr
-        return @pins if @pins
-        @pins = cache_core(out: out)
+      def repository
+        @repository ||= RBS::Repository.new(no_stdlib: false)
       end
 
-      # @param out [StringIO, IO, nil] output stream for logging
+      private
+
       # @return [Array<Pin::Base>]
-      def cache_core out: $stderr
-        new_pins = []
-        cache = PinCache.deserialize_core
-        return cache if cache
-        new_pins.concat conversions.pins
+      def generate_pins
+        new_pins = RbsMap::Conversions.new(loader: loader).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
 
@@ -42,23 +35,9 @@ module Solargraph
 
         # 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
-
-        PinCache.serialize_core new_pins
-
-        new_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)
+        # serial = Marshal.dump(processed)
+        # File.write cache_file, serial, mode: 'wb'
+        processed
       end
     end
   end

data/lib/solargraph/rbs_map/core_fills.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class RbsMap
+  module RbsMap
     # Override pins to fill gaps in RbsMap::CoreMap coverage
     #
     module CoreFills

data/lib/solargraph/rbs_map/gem.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module RbsMap
+    class Gem < Base
+      # @param metagem [Metagem]
+      def initialize metagem
+        super()
+        # 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
+end

data/lib/solargraph/rbs_map/helpers.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module RbsMap
+    module Helpers
+      module_function
+
+      # @param  orig_pins [Array<Pin::Base>]
+      # @param rbs_pins [Array<Pin::Base>]
+      # @return [Array<Pin::Base>]
+      def combine orig_pins, rbs_pins
+        in_orig = Set.new
+        # @todo There's gotta be a better way!
+        rbs_api_map = Solargraph::ApiMap.new(pins: rbs_pins)
+        combined =  orig_pins.map do |orig_pin|
+          in_orig.add orig_pin.path
+          rbs_pin = rbs_api_map.get_path_pins(orig_pin.path).filter { |pin| pin.is_a? Pin::Method }.first
+          next orig_pin unless rbs_pin && orig_pin.instance_of?(Pin::Method)
+
+          unless rbs_pin
+            # @sg-ignore https://github.com/castwide/solargraph/pull/1114
+            Solargraph.logger.debug { "GemPins.combine: No rbs pin for #{orig_pin.path} - using YARD's '#{orig_pin.inspect} (return_type=#{orig_pin.return_type}; signatures=#{orig_pin.signatures})" }
+            next orig_pin
+          end
+
+          out = combine_method_pins(rbs_pin, orig_pin)
+          Solargraph.logger.debug { "GemPins.combine: Combining yard.path=#{orig_pin.path} - rbs=#{rbs_pin.inspect} with yard=#{orig_pin.inspect} into #{out}" }
+          out
+        end
+        in_rbs_only = rbs_pins.select do |pin|
+          pin.path.nil? || !in_orig.include?(pin.path)
+        end
+        out = combined + in_rbs_only
+        Solargraph.logger.debug { "GemPins#combine: Returning #{out.length} combined pins" }
+        out
+      end
+
+      # @param pins [Array<Pin::Method>]
+      # @return [Pin::Method, nil]
+      def combine_method_pins(*pins)
+        # @type [Pin::Method, nil]
+        combined_pin = nil
+        # @param memo [Pin::Method, nil]
+        # @param pin [Pin::Method]
+        out = pins.reduce(combined_pin) do |memo, pin|
+          next pin if memo.nil?
+          # @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}" }
+        out
+      end
+    end
+  end
+end

data/lib/solargraph/rbs_map/path.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module RbsMap
+    class Path < Base
+      # @param path [String]
+      # @return [Array<Pin::Base>]
+      def self.pins path
+        new(path).pins
+      end
+
+      # @param path [String]
+      def initialize path
+        super()
+        loader.add path: Pathname.new(path)
+      end
+    end
+  end
+end

data/lib/solargraph/rbs_map/stdlib.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'rbs'
+
+module Solargraph
+  module RbsMap
+    # Ruby stdlib pins
+    #
+    class Stdlib < Base
+      def initialize library
+        super()
+        loader.add(library: library.gsub('/', '-')) if self.class.has?(library)
+      end
+
+      def repository
+        @repository ||= RBS::Repository.new(no_stdlib: false)
+      end
+
+      def self.has? library
+        !!RBS::Collection::Sources::Stdlib.instance.has?(library.gsub('/', '-'), nil)
+      end
+    end
+  end
+end