solargraph 0.59.0.dev.1 → 0.59.0

data/lib/solargraph/api_map.rb

@@ -51,15 +51,15 @@ module Solargraph
     #
 
     # @param other [Object]
-    def eql?(other)
+    def eql? other
       self.class == other.class &&
         # @sg-ignore flow sensitive typing needs to handle self.class == other.class
         equality_fields == other.equality_fields
     end
 
     # @param other [Object]
-    def ==(other)
-      self.eql?(other)
+    def == other
+      eql?(other)
     end
 
     # @return [Integer]
@@ -115,8 +115,9 @@ module Solargraph
       end
       unresolved_requires = (bench.external_requires + conventions_environ.requires + bench.workspace.config.required).to_a.compact.uniq
       recreate_docmap = @unresolved_requires != unresolved_requires ||
+                        # @sg-ignore Unresolved call to rbs_collection_path on Solargraph::Workspace, nil
                         workspace.rbs_collection_path != bench.workspace.rbs_collection_path ||
-                        @doc_map.any_uncached?
+                        @doc_map.uncached_gemspecs.any?
 
       if recreate_docmap
         @doc_map = DocMap.new(unresolved_requires, bench.workspace, out: nil) # @todo Implement gem preferences
@@ -127,13 +128,6 @@ module Solargraph
       self
     end
 
-    # @todo need to model type def statement in chains as a symbol so
-    #   that this overload of 'protected' will typecheck @sg-ignore
-    # @sg-ignore
-    protected def equality_fields
-      [self.class, @source_map_hash, conventions_environ, @doc_map, @unresolved_requires, @missing_docs, @loose_unions]
-    end
-
     # @return [DocMap]
     def doc_map
       @doc_map ||= DocMap.new([], Workspace.new('.'))
@@ -144,6 +138,16 @@ module Solargraph
       doc_map.uncached_gemspecs || []
     end
 
+    # @return [::Array<Gem::Specification>]
+    def uncached_rbs_collection_gemspecs
+      @doc_map.uncached_rbs_collection_gemspecs
+    end
+
+    # @return [::Array<Gem::Specification>]
+    def uncached_yard_gemspecs
+      @doc_map.uncached_yard_gemspecs
+    end
+
     # @return [Enumerable<Pin::Base>]
     def core_pins
       @@core_map.pins
@@ -205,14 +209,14 @@ module Solargraph
     # @param rebuild [Boolean] whether to rebuild the pins even if they are cached
     # @return [void]
     def cache_all_for_doc_map! out: $stderr, rebuild: false
-      doc_map.cache_doc_map_gems!(out, rebuild: rebuild)
+      doc_map.cache_all!(out, rebuild: rebuild)
     end
 
     # @param gemspec [Gem::Specification]
     # @param rebuild [Boolean]
     # @param out [StringIO, IO, nil]
     # @return [void]
-    def cache_gem(gemspec, rebuild: false, out: nil)
+    def cache_gem gemspec, rebuild: false, out: nil
       doc_map.cache(gemspec, rebuild: rebuild, out: out)
     end
 
@@ -252,6 +256,12 @@ module Solargraph
       store.pins_by_class(Pin::Keyword)
     end
 
+    # @param name [String]
+    # @return [ComplexType, nil]
+    def unalias name
+      store.unalias(name)
+    end
+
     # True if the namespace exists.
     #
     # @param name [String] The namespace to match
@@ -317,19 +327,19 @@ module Solargraph
     #
     # @param pin [Pin::Reference]
     # @return [String, nil]
-    def dereference(pin)
+    def dereference pin
       store.constants.dereference(pin)
     end
 
     # @param fqns [String]
     # @return [Array<Pin::Reference::Extend>]
-    def get_extends(fqns)
+    def get_extends fqns
       store.get_extends(fqns)
     end
 
     # @param fqns [String]
     # @return [Array<Pin::Reference::Include>]
-    def get_includes(fqns)
+    def get_includes fqns
       store.get_includes(fqns)
     end
 
@@ -341,7 +351,7 @@ module Solargraph
     # @return [Array<Solargraph::Pin::InstanceVariable>]
     def get_instance_variable_pins namespace, scope = :instance
       result = []
-      used = [namespace]
+      [namespace]
       result.concat store.get_instance_variables(namespace, scope)
       sc_fqns = namespace
       while (sc = store.get_superclass(sc_fqns))
@@ -364,12 +374,12 @@ module Solargraph
     # @param location [Location]
     #
     # @return [Pin::BaseVariable, nil]
-    def var_at_location(candidates, name, closure, location)
-      with_correct_name = candidates.select { |pin| pin.name == name}
+    def var_at_location candidates, name, closure, location
+      with_correct_name = candidates.select { |pin| pin.name == name }
       vars_at_location = with_correct_name.reject do |pin|
         # visible_at? excludes the starting position, but we want to
         # include it for this purpose
-        (!pin.visible_at?(closure, location) && !pin.starts_at?(location))
+        !pin.visible_at?(closure, location) && !pin.starts_at?(location)
       end
 
       vars_at_location.inject(&:combine_with)
@@ -446,7 +456,7 @@ module Solargraph
               comments: init_pin.comments,
               closure: init_pin.closure,
               source: init_pin.source,
-              type_location: init_pin.type_location,
+              type_location: init_pin.type_location
             )
             new_pin.parameters = init_pin.parameters.map do |init_param|
               param = init_param.clone
@@ -505,7 +515,7 @@ module Solargraph
       result = Set.new
       complex_type.each do |type|
         if type.duck_type?
-          result.add Pin::DuckMethod.new(name: type.to_s[1..-1], source: :api_map)
+          result.add Pin::DuckMethod.new(name: type.to_s[1..], source: :api_map)
           result.merge get_methods('Object')
         else
           unless type.nil? || type.name == 'void'
@@ -536,7 +546,8 @@ module Solargraph
     # @param preserve_generics [Boolean] True to preserve any
     #   unresolved generic parameters, false to erase them
     # @return [Array<Solargraph::Pin::Method>]
-    def get_method_stack rooted_tag, name, scope: :instance, visibility: [:private, :protected, :public], preserve_generics: false
+    def get_method_stack rooted_tag, name, scope: :instance, visibility: %i[private protected public],
+                         preserve_generics: false
       rooted_type = ComplexType.parse(rooted_tag)
       fqns = rooted_type.namespace
       namespace_pin = store.get_path_pins(fqns).first
@@ -619,7 +630,6 @@ module Solargraph
     # @param cursor [Source::Cursor]
     # @return [SourceMap::Clip]
     def clip cursor
-      # @sg-ignore Need to add nil check here
       raise FileNotFoundError, "ApiMap did not catalog #{cursor.filename}" unless source_map_hash.key?(cursor.filename)
 
       SourceMap::Clip.new(self, cursor)
@@ -661,7 +671,7 @@ module Solargraph
     # @param sup [String] The superclass
     # @param sub [String] The subclass
     # @return [Boolean]
-    def super_and_sub?(sup, sub)
+    def super_and_sub? sup, sub
       sup = ComplexType.try_parse(sup)
       sub = ComplexType.try_parse(sub)
       # @todo If two literals are different values of the same type, it would
@@ -693,14 +703,14 @@ module Solargraph
     # @param module_ns [String] The module namespace (no type parameters)
     #
     # @return [Boolean]
-    def type_include?(host_ns, module_ns)
+    def type_include? host_ns, module_ns
       store.get_includes(host_ns).map { |inc_tag| inc_tag.type.name }.include?(module_ns)
     end
 
     # @param pins [Enumerable<Pin::Base>]
     # @param visibility [Enumerable<Symbol>]
     # @return [Array<Pin::Base>]
-    def resolve_method_aliases pins, visibility = [:public, :private, :protected]
+    def resolve_method_aliases pins, visibility = %i[public private protected]
       with_resolved_aliases = pins.map do |pin|
         next pin unless pin.is_a?(Pin::MethodAlias)
         resolved = resolve_method_alias(pin)
@@ -714,7 +724,7 @@ module Solargraph
       GemPins.combine_method_pins_by_path(with_resolved_aliases)
     end
 
-    # @return [Workspace]
+    # @return [Workspace, nil]
     def workspace
       doc_map.workspace
     end
@@ -730,7 +740,7 @@ module Solargraph
     # @param skip [Set<String>]
     # @param no_core [Boolean] Skip core classes if true
     # @return [Array<Pin::Base>]
-    def inner_get_methods_from_reference(fq_reference_tag, namespace_pin, type, scope, visibility, deep, skip, no_core)
+    def inner_get_methods_from_reference fq_reference_tag, namespace_pin, type, scope, visibility, deep, skip, no_core
       logger.debug { "ApiMap#add_methods_from_reference(type=#{type}) starting" }
 
       # Ensure the types returned by the methods in the referenced
@@ -786,7 +796,7 @@ module Solargraph
     def inner_get_methods rooted_tag, scope, visibility, deep, skip, no_core = false
       rooted_type = ComplexType.parse(rooted_tag).force_rooted
       fqns = rooted_type.namespace
-      fqns_generic_params = rooted_type.all_params
+      rooted_type.all_params
       namespace_pin = store.get_path_pins(fqns).select { |p| p.is_a?(Pin::Namespace) }.first
       return [] if no_core && fqns =~ /^(Object|BasicObject|Class|Module)$/
       reqstr = "#{fqns}|#{scope}|#{visibility.sort}|#{deep}"
@@ -797,7 +807,9 @@ module Solargraph
       # ensure we start out with any immediate methods in this
       # namespace so we roughly match the same ordering of get_methods
       # and obey the 'deep' instruction
-      direct_convention_methods, convention_methods_by_reference = environ.pins.partition { |p| p.namespace == rooted_tag }
+      direct_convention_methods, convention_methods_by_reference = environ.pins.partition do |p|
+        p.namespace == rooted_tag
+      end
       result.concat direct_convention_methods
 
       if deep && scope == :instance
@@ -809,8 +821,10 @@ module Solargraph
       # Store#get_methods doesn't know about full tags, just
       # namespaces; resolving the generics in the method pins is this
       # class' responsibility
-      methods = store.get_methods(fqns, scope: scope, visibility: visibility).sort{ |a, b| a.name <=> b.name }
-      logger.info { "ApiMap#inner_get_methods(rooted_tag=#{rooted_tag.inspect}, scope=#{scope.inspect}, visibility=#{visibility.inspect}, deep=#{deep.inspect}, skip=#{skip.inspect}, fqns=#{fqns}) - added from store: #{methods}" }
+      methods = store.get_methods(fqns, scope: scope, visibility: visibility).sort { |a, b| a.name <=> b.name }
+      logger.info do
+        "ApiMap#inner_get_methods(rooted_tag=#{rooted_tag.inspect}, scope=#{scope.inspect}, visibility=#{visibility.inspect}, deep=#{deep.inspect}, skip=#{skip.inspect}, fqns=#{fqns}) - added from store: #{methods}"
+      end
       result.concat methods
       if deep
         result.concat convention_methods_by_reference
@@ -819,7 +833,8 @@ module Solargraph
           store.get_includes(fqns).reverse.each do |ref|
             in_tag = dereference(ref)
             # @sg-ignore Need to add nil check here
-            result.concat inner_get_methods_from_reference(in_tag, namespace_pin, rooted_type, scope, visibility, deep, skip, true)
+            result.concat inner_get_methods_from_reference(in_tag, namespace_pin, rooted_type, scope, visibility, deep,
+                                                           skip, true)
           end
           rooted_sc_tag = qualify_superclass(rooted_tag)
           unless rooted_sc_tag.nil?
@@ -827,7 +842,9 @@ module Solargraph
                                                            visibility, true, skip, no_core)
           end
         else
-          logger.info { "ApiMap#inner_get_methods(#{fqns}, #{scope}, #{visibility}, #{deep}, #{skip}) - looking for get_extends() from #{fqns}" }
+          logger.info do
+            "ApiMap#inner_get_methods(#{fqns}, #{scope}, #{visibility}, #{deep}, #{skip}) - looking for get_extends() from #{fqns}"
+          end
           store.get_extends(fqns).reverse.each do |em|
             fqem = dereference(em)
             result.concat inner_get_methods(fqem, :instance, visibility, deep, skip, true) unless fqem.nil?
@@ -863,7 +880,7 @@ module Solargraph
     def get_namespace_type fqns
       return nil if fqns.nil?
       # @type [Pin::Namespace, nil]
-      pin = store.get_path_pins(fqns).select{|p| p.is_a?(Pin::Namespace)}.first
+      pin = store.get_path_pins(fqns).select { |p| p.is_a?(Pin::Namespace) }.first
       return nil if pin.nil?
       pin.type
     end
@@ -889,7 +906,7 @@ module Solargraph
 
     # @param alias_pin [Pin::MethodAlias]
     # @return [Pin::Method, nil]
-    def resolve_method_alias(alias_pin)
+    def resolve_method_alias alias_pin
       ancestors = store.get_ancestors(alias_pin.full_context.reduce_class_type.tag)
       # @type [Pin::Method, nil]
       original = nil
@@ -920,7 +937,9 @@ module Solargraph
       end
       if original.nil?
         # :nocov:
-        Solargraph.assert_or_log(:alias_target_missing) { "Rejecting alias - target is missing while looking for #{alias_pin.full_context.tag} #{alias_pin.original} in #{alias_pin.scope} scope = #{alias_pin.inspect}" }
+        Solargraph.assert_or_log(:alias_target_missing) do
+          "Rejecting alias - target is missing while looking for #{alias_pin.full_context.tag} #{alias_pin.original} in #{alias_pin.scope} scope = #{alias_pin.inspect}"
+        end
         return nil
         # :nocov:
       end
@@ -933,7 +952,7 @@ module Solargraph
     # @param alias_pin [Pin::MethodAlias] The alias pin to resolve
     # @param original [Pin::Method] The original method pin that was already found
     # @return [Pin::Method] The resolved method pin
-    def create_resolved_alias_pin(alias_pin, original)
+    def create_resolved_alias_pin alias_pin, original
       # Build the resolved method pin directly (same logic as resolve_method_alias but without lookup)
       args = {
         location: alias_pin.location,
@@ -949,7 +968,7 @@ module Solargraph
         return_type: original.return_type,
         source: :resolve_method_alias
       }
-      resolved_pin = Pin::Method.new **args
+      resolved_pin = Pin::Method.new(**args)
 
       # Clone signatures and parameters
       resolved_pin.signatures.each do |sig|
@@ -987,7 +1006,7 @@ module Solargraph
     end
 
     # @param namespace_pin [Pin::Namespace, Pin::Constant]
-    def has_generics?(namespace_pin)
+    def has_generics? namespace_pin
       namespace_pin.is_a?(Pin::Namespace) && !namespace_pin.generics.empty?
     end
 
@@ -996,5 +1015,15 @@ module Solargraph
     def can_resolve_generics? namespace_pin, rooted_type
       has_generics?(namespace_pin) && !rooted_type.all_params.empty?
     end
+
+    protected
+
+    # @todo need to model type def statement in chains as a symbol so
+    #   that this overload of 'protected' will typecheck @sg-ignore
+    # @sg-ignore
+    def equality_fields
+      [self.class, @source_map_hash, conventions_environ, @doc_map, @unresolved_requires, @missing_docs,
+       @loose_unions]
+    end
   end
 end

data/lib/solargraph/bench.rb

@@ -1,45 +1,44 @@
-# frozen_string_literal: true
-
-
-module Solargraph
-  # A container of source maps and workspace data to be cataloged in an ApiMap.
-  #
-  class Bench
-    # @return [Set<SourceMap>]
-    attr_reader :source_maps
-
-    # @return [Workspace]
-    attr_reader :workspace
-
-    # @return [SourceMap]
-    attr_reader :live_map
-
-    # @return [Set<String>]
-    attr_reader :external_requires
-
-    # @param source_maps [Array<SourceMap>, Set<SourceMap>]
-    # @param workspace [Workspace]
-    # @param live_map [SourceMap, nil]
-    # @param external_requires [Array<String>, Set<String>]
-    def initialize source_maps: [], workspace: Workspace.new, live_map: nil, external_requires: []
-      @source_maps = source_maps.to_set
-      @workspace = workspace
-      @live_map = live_map
-      @external_requires = external_requires.reject { |path| workspace.would_require?(path) }
-                                            .compact
-                                            .to_set
-    end
-
-    # @return [Hash{String => SourceMap}]
-    def source_map_hash
-      # @todo Work around #to_h bug in current Ruby head (3.5) with #map#to_h
-      @source_map_hash ||= source_maps.map { |s| [s.filename, s] }
-                                      .to_h
-    end
-
-    # @return [Set<SourceMap>]
-    def icebox
-      @icebox ||= (source_maps - [live_map])
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  # A container of source maps and workspace data to be cataloged in an ApiMap.
+  #
+  class Bench
+    # @return [Set<SourceMap>]
+    attr_reader :source_maps
+
+    # @return [Workspace]
+    attr_reader :workspace
+
+    # @return [SourceMap]
+    attr_reader :live_map
+
+    # @return [Set<String>]
+    attr_reader :external_requires
+
+    # @param source_maps [Array<SourceMap>, Set<SourceMap>]
+    # @param workspace [Workspace]
+    # @param live_map [SourceMap, nil]
+    # @param external_requires [Array<String>, Set<String>]
+    def initialize source_maps: [], workspace: Workspace.new, live_map: nil, external_requires: []
+      @source_maps = source_maps.to_set
+      @workspace = workspace
+      @live_map = live_map
+      @external_requires = external_requires.reject { |path| workspace.would_require?(path) }
+                                            .compact
+                                            .to_set
+    end
+
+    # @sg-ignore flow sensitive typing needs better handling of ||= on lvars
+    # @return [Hash{String => SourceMap}]
+    def source_map_hash
+      # @todo Work around #to_h bug in current Ruby head (3.5) with #map#to_h
+      @source_map_hash ||= source_maps.to_h { |s| [s.filename, s] }
+    end
+
+    # @return [Set<SourceMap>]
+    def icebox
+      @icebox ||= (source_maps - [live_map])
+    end
+  end
+end

data/lib/solargraph/complex_type/type_methods.rb

@@ -43,8 +43,9 @@ module Solargraph
         @rooted_tag ||= rooted_name + rooted_substring
       end
 
+      # Whether this is an RBS interface like _ToAry or Hash::_Key.
       def interface?
-        name.start_with?('_')
+        name.start_with?('_') || name.include?('::_')
       end
 
       # @return [Boolean]
@@ -54,11 +55,11 @@ module Solargraph
 
       # @return [Boolean]
       def nil_type?
-        @nil_type ||= (name.casecmp('nil') == 0)
+        @nil_type ||= name.casecmp('nil').zero?
       end
 
       def tuple?
-        @tuple_type ||= (name == 'Tuple') || (name == 'Array' && subtypes.length >= 1 && fixed_parameters?)
+        @tuple ||= (name == 'Tuple') || (name == 'Array' && subtypes.length >= 1 && fixed_parameters?)
       end
 
       def void?
@@ -87,7 +88,7 @@ module Solargraph
 
       # @param generics_to_erase [Enumerable<String>]
       # @return [self]
-      def erase_generics(generics_to_erase)
+      def erase_generics generics_to_erase
         transform do |type|
           if type.name == ComplexType::GENERIC_TAG_NAME
             if type.all_params.length == 1 && generics_to_erase.include?(type.all_params.first.to_s)
@@ -142,7 +143,7 @@ module Solargraph
         @namespace ||= lambda do
           return 'Object' if duck_type?
           return 'NilClass' if nil_type?
-          return (name == 'Class' || name == 'Module') && !subtypes.empty? ? subtypes.first.name : name
+          %w[Class Module].include?(name) && !subtypes.empty? ? subtypes.first.name : name
         end.call
       end
 
@@ -150,7 +151,7 @@ module Solargraph
       def namespace_type
         return ComplexType.parse('::Object') if duck_type?
         return ComplexType.parse('::NilClass') if nil_type?
-        return subtypes.first if (name == 'Class' || name == 'Module') && !subtypes.empty?
+        return subtypes.first if %w[Class Module].include?(name) && !subtypes.empty?
         self
       end
 
@@ -177,30 +178,27 @@ module Solargraph
       end
 
       # @return [String]
-      def generate_substring_from(&to_str)
+      def generate_substring_from &to_str
         key_types_str = key_types.map(&to_str).join(', ')
         subtypes_str = subtypes.map(&to_str).join(', ')
-        if key_types.none?(&:defined?) && subtypes.none?(&:defined?)
-          ''
-        elsif key_types.empty? && subtypes.empty?
+        if (key_types.none?(&:defined?) && subtypes.none?(&:defined?)) ||
+           (key_types.empty? && subtypes.empty?)
           ''
         elsif hash_parameters?
           "{#{key_types_str} => #{subtypes_str}}"
         elsif fixed_parameters?
           "(#{subtypes_str})"
+        elsif name == 'Hash'
+          "<#{key_types_str}, #{subtypes_str}>"
         else
-          if name == 'Hash'
-            "<#{key_types_str}, #{subtypes_str}>"
-          else
-            "<#{key_types_str}#{subtypes_str}>"
-          end
+          "<#{key_types_str}#{subtypes_str}>"
         end
       end
 
       # @return [::Symbol] :class or :instance
       def scope
         @scope ||= :instance if duck_type? || nil_type?
-        @scope ||= (name == 'Class' || name == 'Module') && !subtypes.empty? ? :class : :instance
+        @scope ||= %w[Class Module].include?(name) && !subtypes.empty? ? :class : :instance
       end
 
       # @param other [Object]