solargraph 0.60.3 → 0.61.0

data/lib/solargraph/shell.rb

@@ -98,60 +98,37 @@ module Solargraph
     # @return [void]
     def clear
       puts 'Deleting all cached documentation (gems, core and stdlib)'
-      Solargraph::PinCache.clear
+      Solargraph::CacheDir.clear
     end
     map 'clear-cache' => :clear
     map 'clear-cores' => :clear
 
-    desc 'cache', 'Cache a gem', hide: true
-    option :rebuild, type: :boolean, desc: 'Rebuild existing documentation', default: false
-    # @return [void]
-    # @param gem [String]
-    # @param version [String, nil]
-    def cache gem, version = nil
-      gemspec = Gem::Specification.find_by_name(gem, version)
-
-      if options[:rebuild] || !PinCache.has_yard?(gemspec)
-        pins = GemPins.build_yard_pins(['yard-activesupport-concern'], gemspec)
-        PinCache.serialize_yard_gem(gemspec, pins)
-      end
-
-      workspace = Solargraph::Workspace.new(Dir.pwd) if File.exist?('rbs_collection.yaml')
-      rbs_map = RbsMap.from_gemspec(gemspec, workspace&.rbs_collection_path, workspace&.rbs_collection_config_path)
-      if options[:rebuild] || !PinCache.has_rbs_collection?(gemspec, rbs_map.cache_key)
-        PinCache.serialize_rbs_collection_gem(gemspec, rbs_map.cache_key, rbs_map.pins)
-      end
-    rescue Gem::MissingSpecError
-      warn "Gem '#{gem}' not found"
-    end
-
     desc 'uncache GEM [...GEM]', 'Delete specific cached gem documentation'
     long_desc %(
       Specify one or more gem names to clear. 'core' or 'stdlib' may
       also be specified to clear cached system documentation.
       Documentation will be regenerated as needed.
     )
+    option :directory, type: :string, desc: 'Workspace directory', default: Dir.pwd
     # @param gems [Array<String>]
     # @return [void]
     def uncache *gems
       raise ArgumentError, 'No gems specified.' if gems.empty?
+      repo = Solargraph::Repo.new(options[:directory])
+
       gems.each do |gem|
         if gem == 'core'
-          PinCache.uncache_core
-          next
-        end
-
-        if gem == 'stdlib'
-          PinCache.uncache_stdlib
-          next
+          Solargraph::Collection::Core.uncache
+        elsif gem == 'stdlib'
+          FileUtils.rm_rf CacheDir.stdlib_dir
+        else
+          metagem = repo.find_by_name(gem)
+          Solargraph::Collection::Gem.uncache(metagem) if metagem
         end
-
-        spec = Gem::Specification.find_by_name(gem)
-        PinCache.uncache_gem(spec, out: $stdout)
       end
     end
 
-    desc 'gems [GEM[=VERSION]...] [STDLIB...] [core]', 'Cache documentation for
+    desc 'cache GEM_NAME [...GEM_NAME] [core]', 'Cache documentation for
          installed libraries'
     long_desc %( This command will cache the
     generated type documentation for the specified libraries.  While
@@ -172,56 +149,51 @@ module Solargraph
         If the library is already cached, it will be rebuilt if the
         --rebuild option is set.
 
-        Cached documentation is stored in #{PinCache.base_dir}, which
+        Cached documentation is stored in #{CacheDir.base_dir}, which
         can be stored between CI runs.
     )
+    option :directory, type: :string, desc: 'Workspace directory', default: Dir.pwd
     option :rebuild, type: :boolean, desc: 'Rebuild existing documentation', default: false
     # @param names [Array<String>]
     # @return [void]
-    def gems *names
-      # print time with ms
-      workspace = Solargraph::Workspace.new('.')
-
-      if names.empty?
-        Gem::Specification.to_a.each { |spec| do_cache spec, rebuild: options[:rebuild] }
-        $stderr.puts "Documentation cached for all #{Gem::Specification.count} gems."
-      else
-        warn("Caching these gems: #{names}")
-        names.each do |name|
-          if name == 'core'
-            # @sg-ignore cache_core and core? are dynamically defined
-            PinCache.cache_core(out: $stdout) # if !PinCache.core? || options[:rebuild]
-            next
-          end
-
-          gemspec = workspace.find_gem(*name.split('='))
-          if gemspec.nil?
-            warn "Gem '#{name}' not found"
-          else
-            if options[:rebuild] || !PinCache.has_yard?(gemspec)
-              pins = GemPins.build_yard_pins(['yard-activesupport-concern'], gemspec)
-              PinCache.serialize_yard_gem(gemspec, pins)
-            end
-
-            workspace = Solargraph::Workspace.new(Dir.pwd)
-            rbs_map = RbsMap.from_gemspec(gemspec, workspace.rbs_collection_path, workspace.rbs_collection_config_path)
-            if options[:rebuild] || !PinCache.has_rbs_collection?(gemspec, rbs_map.cache_key)
-              # cache pins even if result is zero, so we don't retry building pins
-              pins = rbs_map.pins || []
-              PinCache.serialize_rbs_collection_gem(gemspec, rbs_map.cache_key, pins)
-            end
-          end
-        rescue Gem::MissingSpecError
-          warn "Gem '#{name}' not found"
-        rescue Gem::Requirement::BadRequirementError => e
-          warn "Gem '#{name}' failed while loading"
-          warn e.message
-          # @sg-ignore Need to add nil check here
-          warn e.backtrace.join("\n")
-        end
-        warn "Documentation cached for #{names.count} gems."
+    # @param [Array<Object>] gem_names
+    def cache *gem_names
+      repo = Solargraph::Repo.new(options[:directory])
+      metagems = if gem_names.empty?
+                   if repo.bundled?
+                     repo.bundled.select(&:cacheable?)
+                   else
+                     Gem::Specification.all_names
+                                       .map { |name| Gem::Specification.find_by_full_name(name) }
+                                       .map { |gemspec| Metagem.from_specification(gemspec) }
+                   end
+                 else
+                   gem_names.each_with_object([]) do |name, result|
+                     if name == 'core'
+                       Collection::Core.uncache if options[:rebuild]
+                       puts 'Caching core'
+                       Collection::Core.load
+                     else
+                       # @todo Quick and dirty hack for solargraph-rspec require bug
+                       #   (see https://github.com/lekemula/solargraph-rspec/pull/38)
+                       #   TL;DR: `repo.find_by_path` should not be necessary
+                       found = repo.find_by_name(name) || repo.find_by_path(name)
+                       if found
+                         result.push found
+                       else
+                         warn "Gem #{name} not found"
+                       end
+                     end
+                   end
+                 end
+      metagems.each do |metagem|
+        Collection::Gem.uncache(metagem) if options[:rebuild]
+        puts "Caching #{metagem.name} #{metagem.version} (#{metagem.cache_name})"
+        Collection::Gem.load(metagem)
       end
+      puts "Documentation cached for #{metagems.count} gems."
     end
+    map 'gems' => :cache
 
     desc 'reporters', 'Get a list of diagnostics reporters'
     # @return [void]
@@ -596,27 +568,5 @@ module Solargraph
         puts pin.inspect
       end
     end
-
-    # @param gemspec [Gem::Specification, nil]
-    # @param rebuild [Boolean]
-    # @return [void]
-    def do_cache gemspec, rebuild: false
-      if gemspec.nil?
-        warn "Gem '#{gemspec&.name}' not found"
-      else
-        if rebuild || !PinCache.has_yard?(gemspec)
-          pins = GemPins.build_yard_pins(['yard-activesupport-concern'], gemspec)
-          PinCache.serialize_yard_gem(gemspec, pins)
-        end
-
-        workspace = Solargraph::Workspace.new(Dir.pwd)
-        rbs_map = RbsMap.from_gemspec(gemspec, workspace.rbs_collection_path, workspace.rbs_collection_config_path)
-        if rebuild || !PinCache.has_rbs_collection?(gemspec, rbs_map.cache_key)
-          # cache pins even if result is zero, so we don't retry building pins
-          pins = rbs_map.pins || []
-          PinCache.serialize_rbs_collection_gem(gemspec, rbs_map.cache_key, pins)
-        end
-      end
-    end
   end
 end

data/lib/solargraph/source/chain/call.rb

@@ -64,13 +64,106 @@ module Solargraph
             [stack.first].compact
           end
           pin_groups = [] if !api_map.loose_unions && pin_groups.any?(&:empty?)
-          pins = pin_groups.flatten.uniq(&:path)
+          # Several union members can end up with the same pin and return type.
+          # @sg-ignore Array#flatten returns a bare Array
+          pins = pin_groups.flatten.uniq { |p| [p.path, p.return_type.rooted_tags] }
           return [] if pins.empty?
           inferred_pins(pins, api_map, name_pin, locals)
         end
 
         private
 
+        # Checks whether a single overload signature matches the call's
+        # arguments/block and, if so, resolves its return type. Threaded
+        # through the caller's accumulator so behavior matches the
+        # original inline loop: if the overload doesn't match, the
+        # incoming type/signature are returned unchanged.
+        #
+        # @param overload [Pin::Signature]
+        # @param pin [Pin::Method]
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @param locals [::Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
+        # @param type [ComplexType]
+        # @param new_signature_pin [Pin::Signature, nil]
+        # @return [::Array(ComplexType, Pin::Signature)]
+        def match_overload_type overload, pin, api_map, name_pin, locals, type, new_signature_pin
+          return [type, new_signature_pin] unless overload.arity_matches?(arguments, with_block?)
+
+          match = true
+          atypes = []
+          arguments.each_with_index do |arg, idx|
+            param = overload.parameters[idx]
+            if param.nil?
+              match = overload.parameters.any?(&:restarg?)
+              break
+            end
+            arg_name_pin = Pin::ProxyType.anonymous(name_pin.context,
+                                                    closure: name_pin.closure,
+                                                    gates: name_pin.gates,
+                                                    source: :chain)
+            atype = atypes[idx] ||= arg.infer(api_map, arg_name_pin, locals)
+            # @sg-ignore flow sensitive typing should handle is_a? and next
+            unless param.compatible_arg?(atype, api_map) || param.restarg?
+              match = false
+              break
+            end
+          end
+          return [type, new_signature_pin] unless match
+
+          if overload.block && with_block?
+            block_atypes = overload.block.parameters.map(&:return_type)
+            # @todo Need to add nil check here
+            # @sg-ignore Need to add nil check here
+            blocktype = if block.links.map(&:class) == [BlockSymbol]
+                          # like the bar in foo(&:bar)
+                          block_symbol_call_type(api_map, name_pin.context, block_atypes, locals)
+                        else
+                          block_call_type(api_map, name_pin, locals)
+                        end
+          end
+          new_signature_pin = overload.resolve_generics_from_context_until_complete(overload.generics, atypes, nil, nil,
+                                                                                    blocktype)
+          # @todo It shouldn't be necessary to choose either generics or macros
+          # @sg-ignore Need to add nil check here
+          new_return_type = if new_signature_pin.return_type.defined?
+                              # @sg-ignore Need to add nil check here
+                              new_signature_pin.return_type
+                            else
+                              # @sg-ignore Need to add nil check here
+                              named_types = pin.parameter_names.zip(arguments.map { |arg| ComplexType.try_parse(simple_convert(arg.node).to_s) }).to_h
+                              pin.typify(api_map).expand(named_types)
+                            end
+          self_type = if head?
+                        # If we're at the head of the chain, we called a
+                        # method somewhere that marked itself as returning
+                        # self.  Given we didn't invoke this on an object,
+                        # this must be a method in this same class - so we
+                        # use our own self type
+                        name_pin.context
+                      else
+                        # if we're past the head in the chain, whatever the
+                        # type of the lhs side is what 'self' will be in its
+                        # declaration - we can't just use the type of the
+                        # method pin, as this might be a subclass of the
+                        # place where the method is defined
+                        name_pin.binder
+                      end
+          # This same logic applies to the YARD work done by
+          # 'with_params()'.
+          #
+          # qualify(), however, happens in the namespace where
+          # the docs were written - from the method pin.
+          # @todo Need to add nil check here
+          type = if new_return_type.defined?
+                   with_params(new_return_type.self_to_type(self_type), self_type).qualify(api_map, *pin.gates)
+                 else
+                   inferr_from_factory_parameters(api_map, pin)
+                 end
+          type ||= ComplexType::UNDEFINED
+          [type, new_signature_pin]
+        end
+
         # @param pins [::Enumerable<Pin::Base>]
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
@@ -96,76 +189,20 @@ module Solargraph
             # @sg-ignore flow sensitive typing should handle is_a? and next
             # @param ol [Pin::Signature]
             sorted_overloads.each do |ol|
-              next unless ol.arity_matches?(arguments, with_block?)
-              match = true
-
-              atypes = []
-              arguments.each_with_index do |arg, idx|
-                param = ol.parameters[idx]
-                if param.nil?
-                  match = ol.parameters.any?(&:restarg?)
-                  break
-                end
-                arg_name_pin = Pin::ProxyType.anonymous(name_pin.context,
-                                                        closure: name_pin.closure,
-                                                        gates: name_pin.gates,
-                                                        source: :chain)
-                atype = atypes[idx] ||= arg.infer(api_map, arg_name_pin, locals)
-                unless param.compatible_arg?(atype, api_map) || param.restarg?
-                  match = false
-                  break
-                end
-              end
-              if match
-                if ol.block && with_block?
-                  block_atypes = ol.block.parameters.map(&:return_type)
-                  # @todo Need to add nil check here
-                  blocktype = if block.links.map(&:class) == [BlockSymbol]
-                                # like the bar in foo(&:bar)
-                                block_symbol_call_type(api_map, name_pin.context, block_atypes, locals)
-                              else
-                                block_call_type(api_map, name_pin, locals)
-                              end
-                end
-                new_signature_pin = ol.resolve_generics_from_context_until_complete(ol.generics, atypes, nil, nil,
-                                                                                    blocktype)
-                # @todo It shouldn't be necessary to choose either generics or macros
-                new_return_type = if new_signature_pin.return_type.defined?
-                  new_signature_pin.return_type
-                else
-                  named_types = p.parameter_names.zip(arguments.map { |arg| ComplexType.try_parse(simple_convert(arg.node).to_s) }).to_h
-                  p.typify(api_map).expand(named_types)
-                end
-                self_type = if head?
-                              # If we're at the head of the chain, we called a
-                              # method somewhere that marked itself as returning
-                              # self.  Given we didn't invoke this on an object,
-                              # this must be a method in this same class - so we
-                              # use our own self type
-                              name_pin.context
-                            else
-                              # if we're past the head in the chain, whatever the
-                              # type of the lhs side is what 'self' will be in its
-                              # declaration - we can't just use the type of the
-                              # method pin, as this might be a subclass of the
-                              # place where the method is defined
-                              name_pin.binder
-                            end
-                # This same logic applies to the YARD work done by
-                # 'with_params()'.
-                #
-                # qualify(), however, happens in the namespace where
-                # the docs were written - from the method pin.
-                # @todo Need to add nil check here
-                if new_return_type.defined?
-                  type = with_params(new_return_type.self_to_type(self_type), self_type).qualify(api_map, *p.gates)
-                end
-                type ||= ComplexType::UNDEFINED
-              end
+              type, new_signature_pin = match_overload_type(ol, p, api_map, name_pin, locals, type, new_signature_pin)
               break if type.defined?
             end
             p = p.with_single_signature(new_signature_pin) unless new_signature_pin.nil?
             next p.proxy(type) if type.defined?
+            if !p.macros.empty?
+              result = process_macro(p, api_map, name_pin.context, locals)
+              # @sg-ignore flow sensitive typing should be able to handle redefinition
+              next result unless result.return_type.undefined?
+            elsif !p.directives.empty?
+              result = process_directive(p, api_map, name_pin.context, locals)
+              # @sg-ignore flow sensitive typing should be able to handle redefinition
+              next result unless result.return_type.undefined?
+            end
             p
           end
           logger.debug do
@@ -186,6 +223,92 @@ module Solargraph
           end
         end
 
+        # @param api_map [ApiMap]
+        # @param method_pin [Pin::Method]
+        # @return [ComplexType, nil]
+        def inferr_from_factory_parameters api_map, method_pin
+          factory_parameter = api_map.factory_parameters_for_method(method_pin).find do |factory_param|
+            method_pin.parameters.each_with_index.find do |param, index|
+              current_argument = arguments[index]
+              next unless current_argument&.literal?
+              # @type [Solargraph::Source::Chain::Literal]
+              last_link = current_argument.links.last
+              argument_value = last_link.value
+
+              param.name == factory_param.param_name && argument_value == factory_param.value
+            end
+          end
+
+          return nil if factory_parameter.nil?
+
+          factory_parameter.return_type.qualify(api_map, method_pin.namespace)
+        end
+
+        # @param pin [Pin::Base]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType, ComplexType::UniqueType]
+        # @param locals [::Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
+        # @return [Pin::Base]
+        def process_macro pin, api_map, context, locals
+          pin.macros.each do |macro|
+            # @todo 'Wrong argument type for
+            #   Solargraph::Source::Chain::Call#inner_process_macro:
+            #   macro expected YARD::Tags::MacroDirective, received
+            #   generic<Elem>' is because we lose 'rooted' information
+            #   in the 'Chain::Array' class internally, leaving
+            #   ::Array#each shadowed when it shouldn't be.
+            # @sg-ignore macro is Solargraph::YardMap::Macro, wraps a YARD::Tags::MacroDirective
+            result = inner_process_macro(pin, macro, api_map, context, locals)
+            return result unless result.return_type.undefined?
+          end
+          Pin::ProxyType.anonymous(ComplexType::UNDEFINED, source: :chain)
+        end
+
+        # @param pin [Pin::Method]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType, ComplexType::UniqueType]
+        # @param locals [::Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
+        # @return [Pin::ProxyType]
+        def process_directive pin, api_map, context, locals
+          pin.directives.each do |dir|
+            macro = api_map.named_macro(dir.tag.name)
+            next if macro.nil?
+            # @sg-ignore macro is Solargraph::YardMap::Macro, wraps a YARD::Tags::MacroDirective
+            result = inner_process_macro(pin, macro, api_map, context, locals)
+            return result unless result.return_type.undefined?
+          end
+          Pin::ProxyType.anonymous ComplexType::UNDEFINED, source: :chain
+        end
+
+        # @param pin [Pin::Base]
+        # @param macro [YARD::Tags::MacroDirective]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType, ComplexType::UniqueType]
+        # @param locals [::Array<Pin::LocalVariable, Pin::Parameter>]
+        # @return [Pin::ProxyType]
+        def inner_process_macro pin, macro, api_map, context, locals
+          vals = arguments.map { |c| Pin::ProxyType.anonymous(c.infer(api_map, pin, locals), source: :chain) }
+          txt = macro.tag.text.clone
+          # @sg-ignore Need to add nil check here
+          if txt.empty? && macro.tag.name
+            named = api_map.named_macro(macro.tag.name)
+            txt = named.tag.text.clone if named
+          end
+          i = 1
+          vals.each do |v|
+            # @sg-ignore Need to add nil check here
+            txt.gsub!(/\$#{i}/, v.context.namespace)
+            i += 1
+          end
+          # @sg-ignore Need to add nil check here
+          docstring = Solargraph::Source.parse_docstring(txt).to_docstring
+          tag = docstring.tag(:return)
+          unless tag.nil? || tag.types.nil?
+            return Pin::ProxyType.anonymous(ComplexType.try_parse(*tag.types), source: :chain)
+          end
+          Pin::ProxyType.anonymous(ComplexType::UNDEFINED, source: :chain)
+        end
+
         # @param docstring [YARD::Docstring]
         # @param context [ComplexType]
         # @return [ComplexType, nil]

data/lib/solargraph/source/chain/literal.rb

@@ -6,29 +6,29 @@ module Solargraph
   class Source
     class Chain
       class Literal < Link
-        attr_reader :word, :value
+        attr_reader :word
+
+        # @return [::String, ::Symbol]
+        attr_reader :value
+
+        # @return [Parser::AST::Node]
+        attr_reader :node
 
         # @param type [String]
         # @param node [Parser::AST::Node, Object]
         def initialize type, node
           super("<#{type}>")
+          @node = node
 
-          # @todo We might be able to do some light inference from literals and
-          #   tuples as long as literal values are intransitive.
-
-          # if node.is_a?(::Parser::AST::Node)
-          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-          #   if node.type == :true
-          #     @value = true
-          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-          #   elsif node.type == :false
-          #     @value = false
-          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-          #   elsif %i[int sym].include?(node.type)
-          #     # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-          #     @value = node.children.first
-          #   end
-          # end
+          if node.is_a?(::Parser::AST::Node)
+            if node.type == :true
+              @value = true
+            elsif node.type == :false
+              @value = false
+            elsif %i[int sym].include?(node.type)
+              @value = node.children.first
+            end
+          end
           @type = type
           # @literal_type = ComplexType.try_parse(@value.inspect)
           @literal_type = ComplexType::UNDEFINED

data/lib/solargraph/source/chain/parameter.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      # A method parameter represented as a link in a method call chain.
+      #
+      # @example
+      #   some_method('literal_value')
+      #                ^^^^^^^^^^^^^
+      class Parameter < Link
+        # @param literal [Chain::Literal] - literal argument
+        # @param method_call_chain [Chain] method call that contains the argument
+        def initialize literal, method_call_chain # rubocop:disable Lint/MissingSuper
+          @literal = literal
+          @method_call_chain = method_call_chain
+        end
+
+        def word
+          @word ||= "#{method_name}(.., #{@literal.word}, ..)"
+        end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @param locals [::Array<Pin::Parameter, Pin::LocalVariable>]
+        # @return [::Array<Pin::Base>]
+        def resolve api_map, name_pin, locals
+          # @type [Pin::Method]
+          method_pin = method_call_chain.define(api_map, name_pin, locals)&.first
+          return [] unless method_pin
+
+          # Use indexed lookup for better performance
+          api_map.factory_parameters_for_method(method_pin).select do |fp|
+            param_index = method_pin.parameters.find_index { |param| param.name == fp.param_name }
+            next if param_index.nil?
+            next false unless fp.value == literal_value
+
+            # a splat takes every argument from its position on
+            method_pin.parameters[param_index].restarg? ? current_index >= param_index : current_index == param_index
+          end
+        end
+
+        # @return [Boolean] true if this is a parameter of Kernel#require
+        def require_parameter?
+          method_call_chain.links.last.word == 'require'
+        end
+
+        private
+
+        # @return [Chain::Literal]
+        attr_reader :literal
+        # @ return [Chain]
+        attr_reader :method_call_chain
+
+        # @return [String] The name of the method that this parameter belongs to
+        def method_name
+          @method_name ||= method_call.word
+        end
+
+        # @return [Chain::Call]
+        def method_call
+          @method_call_chain.links.last
+        end
+
+        # The index of the literal in the method call chain.
+        # @return [Integer]
+        def current_index
+          @current_index ||= method_call_chain.node.children[2..].index(literal.node)
+        end
+
+        # @return [::String, ::Symbol] The literal value of the parameter
+        # @sg-ignore false "return type could not be inferred"
+        def literal_value
+          literal.node.children.first
+        end
+      end
+    end
+  end
+end