solargraph 0.60.3 → 0.61.0

data/lib/solargraph/complex_type.rb

@@ -227,7 +227,7 @@ module Solargraph
       expected = expected.downcast_to_literal_if_possible
       inferred = downcast_to_literal_if_possible
 
-      return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
+      return duck_types_match?(api_map, expected, inferred, rules) if expected.duck_type?
 
       if rules.include? :allow_any_match
         inferred.any? do |inf|
@@ -245,18 +245,31 @@ module Solargraph
     # @param api_map [ApiMap]
     # @param expected [ComplexType, UniqueType]
     # @param inferred [ComplexType, UniqueType]
+    # @param rules [Array<Symbol>]
     # @return [Boolean]
-    def duck_types_match? api_map, expected, inferred
+    def duck_types_match? api_map, expected, inferred, rules = []
       raise ArgumentError, 'Expected type must be duck type' unless expected.duck_type?
+      allow_any_match = rules.include?(:allow_any_match)
       expected.each do |exp|
         next unless exp.duck_type?
-        quack = exp.to_s[1..]
-        # @sg-ignore Need to add nil check here
-        return false if api_map.get_method_stack(inferred.namespace, quack, scope: inferred.scope).empty?
+        quack = exp.to_s[1..] || ''
+        matched = allow_any_match ? inferred.any? { |inf| duck_type_provides?(api_map, inf, quack) } : inferred.all? { |inf| duck_type_provides?(api_map, inf, quack) }
+        return false unless matched
       end
       true
     end
 
+    # @param api_map [ApiMap]
+    # @param inf [UniqueType]
+    # @param quack [String]
+    # @return [Boolean]
+    def duck_type_provides? api_map, inf, quack
+      return true if inf.duck_type? && inf.to_s[1..] == quack
+
+      !api_map.get_method_stack(inf.namespace, quack, scope: inf.scope).empty?
+    end
+    private :duck_type_provides?
+
     # @return [String]
     def rooted_tags
       map(&:rooted_tag).join(', ')

data/lib/solargraph/convention.rb

@@ -38,12 +38,14 @@ module Solargraph
       result
     end
 
-    # @param doc_map [DocMap]
+    # @todo Determine what argument needs to be passed here
+    #
+    # @param object [Object]
     # @return [Environ]
-    def self.for_global doc_map
+    def self.for_global object
       result = Environ.new
       @@conventions.each do |conv|
-        result.merge conv.global(doc_map)
+        result.merge conv.global(object)
       end
       result
     end

data/lib/solargraph/diagnostics/require_not_found.rb

@@ -13,10 +13,6 @@ module Solargraph
         # @sg-ignore Need to add nil check here
         map = api_map.source_map(source.filename)
         map.requires.each { |ref| refs[ref.name] = ref }
-        api_map.missing_docs.each do |r|
-          next unless refs.key?(r)
-          result.push docs_error(r, refs[r].location)
-        end
         api_map.unresolved_requires.each do |r|
           next unless refs.key?(r)
           result.push require_error(r, refs[r].location)

data/lib/solargraph/external.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Solargraph
+  # @todo This class might need a way to track changes to the repo, e.g.,
+  #   bundle or dependency updates
+  #
+  class External
+    # @return [String]
+    attr_reader :directory
+
+    # @return [Array<String>]
+    attr_reader :requires
+
+    # @param directory [String]
+    # @param requires [Array<String>]
+    def initialize directory, requires
+      @repo = Repo.new(directory)
+      @directory = directory
+      @requires = requires
+      update!
+    end
+
+    def unresolved_requires
+      @unresolved_requires ||= []
+    end
+
+    def unresolved_dependencies
+      @unresolved_dependencies ||= []
+    end
+
+    def loaded_gems
+      @loaded_gems ||= Set.new
+    end
+
+    def unloaded_gems
+      @unloaded_gems ||= Set.new
+    end
+
+    def pins
+      @pins ||= []
+    end
+
+    # @return [Integer] incremented whenever the external pin set is rebuilt
+    def generation
+      @generation ||= 0
+    end
+
+    # @param new_requires [Array<String>]
+    # @return [Boolean]
+    def update new_requires
+      return false if requires == new_requires && !cache_changed?
+
+      requires.replace new_requires
+      update!
+      true
+    end
+
+    # @return [Array<String>]
+    def rbs_collection_paths
+      @rbs_collection_paths ||= read_rbs_collection_paths
+    end
+
+    # @return [String, nil]
+    def rbs_collection_config_path
+      # @todo Get rid of the '*' case
+      @rbs_collection_config_path ||= unless directory.nil? || directory.empty? || directory == '*'
+                                        yaml_file = File.join(directory, 'rbs_collection.yaml')
+                                        yaml_file if File.file?(yaml_file)
+                                      end
+    end
+
+    private
+
+    def update!
+      @generation = generation + 1
+      clear_all
+      load_requires
+      load_rbs_collection
+    end
+
+    def cache_changed?
+      unloaded_gems.any? { |gem| Collection::Gem.cached?(gem) }
+    end
+
+    def load_requires
+      bundler_require = false
+
+      requires.uniq.each do |path|
+        if path == 'bundler/require'
+          bundler_require = true
+        end
+        if RbsMap::Stdlib.has?(path)
+          pins.concat Collection::Stdlib.load(path)
+        else
+          metagem = @repo.find_by_path(path)
+          next unresolved_requires.push(path) unless metagem
+          process_gem metagem
+        end
+      end
+
+      return unless bundler_require
+
+      @repo.find_by_group(:default).each { |metagem| process_gem metagem }
+    end
+
+    def load_rbs_collection
+      rbs_collection_pins = rbs_collection_paths.flat_map { |path| Collection::Rbs.load(path) }
+      pins.replace RbsMap::Helpers.combine(pins, rbs_collection_pins)
+    end
+
+    def clear_all
+      pins.clear
+      unresolved_requires.clear
+      unresolved_dependencies.clear
+      loaded_gems.clear
+      unloaded_gems.clear
+    end
+
+    def process_gem metagem
+      return if loaded_gems.include?(metagem) || unloaded_gems.include?(metagem)
+
+      if metagem.cacheable?
+        if Collection::Gem.cached?(metagem)
+          loaded_gems.add metagem
+          pins.concat Collection::Gem.load(metagem)
+        else
+          unloaded_gems.add metagem
+        end
+      else
+        loaded_gems.add metagem
+        pins.concat Collection::Gem.load(metagem)
+      end
+      load_dependencies metagem
+    end
+
+    def load_dependencies parent
+      parent.dependencies.each do |name|
+        next if loaded_gems.map(&:name).include?(name) || unloaded_gems.map(&:name).include?(name)
+        metagem = @repo.find_by_name(name)
+        next unresolved_dependencies.push(name) unless metagem
+        process_gem metagem
+      end
+    end
+
+    # @return [Array<String>]
+    def read_rbs_collection_paths
+      return [] unless rbs_collection_config_path
+
+      yaml = YAML.load_file(rbs_collection_config_path)
+      [File.expand_path(yaml.fetch('path'), directory)].concat(
+        yaml.fetch('sources', [])
+            .select { |source| source['type'] == 'local' && source['path'] }
+            .map { |source| File.expand_path(source['path'], directory) }
+      ).compact
+    end
+  end
+end

data/lib/solargraph/language_server/message/text_document/definition.rb

@@ -29,7 +29,10 @@ module Solargraph
 
           # @return [Array<Hash>, nil]
           def require_location
-            # @todo Terrible hack
+            # @todo Terrible hack - move this logic to [Solargraph::Source::Chain::Parameter]
+            #   @example
+            #     require 'click_me'
+            #             ^^^^^^^^^^
             lib = host.library_for(params['textDocument']['uri'])
             rloc = Solargraph::Location.new(uri_to_file(params['textDocument']['uri']),
                                             Solargraph::Range.from_to(@line, @column, @line, @column))

data/lib/solargraph/language_server/message/text_document/hover.rb

@@ -11,8 +11,7 @@ module Solargraph
             contents = []
             suggestions = host.definitions_at(params['textDocument']['uri'], line, col)
             last_link = nil
-            # @sg-ignore Need to add nil check here
-            suggestions.each do |pin|
+            suggestions&.each do |pin|
               parts = []
               this_link = host.options['enablePages'] ? pin.link_documentation : pin.text_documentation
               parts.push this_link if !this_link.nil? && this_link != last_link

data/lib/solargraph/library.rb

@@ -576,14 +576,8 @@ module Solargraph
       return unless source
       # @sg-ignore Wrong argument type for Solargraph::Workspace#has_file?: filename expected String, received String, nil
       return unless @current == source || workspace.has_file?(source.filename)
-      if source_map_hash.key?(source.filename)
-        new_map = Solargraph::SourceMap.map(source)
-        # @sg-ignore OK if source.filename is nil
-        source_map_hash[source.filename] = new_map
-      else
-        # @sg-ignore OK if source.filename is nil
-        source_map_hash[source.filename] = Solargraph::SourceMap.map(source)
-      end
+      # @sg-ignore OK if source.filename is nil
+      source_map_hash[source.filename] = Solargraph::SourceMap.map(source)
     end
 
     # @return [Set<Gem::Specification>]
@@ -595,10 +589,10 @@ module Solargraph
     def cache_next_gemspec
       return if @cache_progress
 
-      spec = cacheable_specs.first
+      spec = api_map.unloaded_gems.first
       return end_cache_progress unless spec
 
-      pending = api_map.uncached_gemspecs.length - cache_errors.length - 1
+      pending = api_map.unloaded_gems.length - cache_errors.length - 1
 
       if Yardoc.processing?(spec)
         logger.info "Enqueuing cache of #{spec.name} #{spec.version} (already being processed)"
@@ -615,7 +609,10 @@ module Solargraph
         logger.info "Caching #{spec.name} #{spec.version}"
         Thread.new do
           report_cache_progress spec.name, pending
-          _o, e, s = Open3.capture3(workspace.command_path, 'cache', spec.name, spec.version.to_s)
+
+          cmd = [workspace.command_path, 'cache', spec.name]
+          cmd.push('--directory', workspace.directory) if workspace.directory
+          _o, e, s = Open3.capture3(*cmd)
           if s.success?
             logger.info "Cached #{spec.name} #{spec.version}"
           else
@@ -630,17 +627,6 @@ module Solargraph
       end
     end
 
-    # @return [Array<Gem::Specification>]
-    def cacheable_specs
-      cacheable = api_map.uncached_yard_gemspecs +
-                  api_map.uncached_rbs_collection_gemspecs -
-                  queued_gemspec_cache -
-                  cache_errors.to_a
-      return cacheable unless cacheable.empty?
-
-      queued_gemspec_cache
-    end
-
     # @return [Array<Gem::Specification>]
     def queued_gemspec_cache
       @queued_gemspec_cache ||= []
@@ -696,8 +682,9 @@ module Solargraph
         source_map_hash.each_value { |map| find_external_requires(map) }
         api_map.catalog bench
         logger.info "Catalog complete (#{api_map.source_maps.length} files, #{api_map.pins.length} pins)"
-        logger.info "#{api_map.uncached_yard_gemspecs.length} uncached YARD gemspecs"
-        logger.info "#{api_map.uncached_rbs_collection_gemspecs.length} uncached RBS collection gemspecs"
+        # @todo This needs work
+        # logger.info "#{api_map.uncached_yard_gemspecs.length} uncached YARD gemspecs"
+        # logger.info "#{api_map.uncached_rbs_collection_gemspecs.length} uncached RBS collection gemspecs"
         cache_next_gemspec
         @sync_count = 0
       end

data/lib/solargraph/metagem.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Metagem
+    include Equality
+
+    # @return [String]
+    attr_reader :name
+
+    # @return [String]
+    attr_reader :full_path
+
+    # @return [String]
+    attr_reader :spec_file
+
+    # @return [String]
+    attr_reader :source
+
+    # @return [String]
+    attr_reader :version
+
+    # @return [Array<String>]
+    attr_reader :require_paths
+
+    # @return [Array<String>]
+    attr_reader :dependencies
+
+    # @return [String]
+    attr_reader :cache_name
+
+    def initialize name:, full_path:, spec_file:, source:, version:, require_paths:, dependencies:
+      @name = name
+      @full_path = full_path
+      @spec_file = spec_file
+      @source = source
+      @version = version
+      @require_paths = require_paths
+      @dependencies = dependencies
+      # @todo Possible change to cache names to make them more specific to sources
+      # @cache_name = "#{File.basename(full_path)}__#{source.gsub(/[^a-z0-9\-_]/i, '_')}" unless source.end_with?('Path')
+      # @todo Better path source detection
+      @cache_name = File.basename(full_path) unless source.start_with?('source at') || source.to_s.end_with?('::Path')
+    end
+
+    def cacheable?
+      !!@cache_name
+    end
+
+    def require? path
+      require_paths.any? do |req|
+        File.file?(File.join(full_path, req, "#{path}.rb"))
+      end
+    end
+
+    def to_specification
+      Gem::Specification.load(spec_file)
+    end
+
+    alias full_gem_path full_path
+
+    # @return [Array]
+    def equality_fields
+      # A version arrives as a String from a bundle definition and as a
+      # Gem::Version from a specification, so compare its string form.
+      [name, version.to_s, full_path, source]
+    end
+
+    # @param gem [Gem::Specification]
+    # @return [Metagem]
+    def self.from_specification gem
+      Metagem.new(name: gem.name,
+                  full_path: gem.full_gem_path,
+                  spec_file: gem.spec_file,
+                  source: gem.source.to_s,
+                  version: gem.version,
+                  require_paths: gem.require_paths,
+                  dependencies: gem.runtime_dependencies.map(&:name))
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_chainer.rb

@@ -13,10 +13,12 @@ module Solargraph
         # @param node [Parser::AST::Node]
         # @param filename [String, nil]
         # @param parent [Parser::AST::Node, nil]
-        def initialize node, filename = nil, parent = nil
+        # @param tree [Array<Parser::AST::Node>, nil]
+        def initialize node, filename = nil, parent = nil, tree = nil
           @node = node
           @filename = filename
           @parent = parent
+          @tree = tree
         end
 
         # @return [Source::Chain]
@@ -29,9 +31,10 @@ module Solargraph
           # @param node [Parser::AST::Node]
           # @param filename [String, nil]
           # @param parent [Parser::AST::Node, nil]
+          # @param tree [Parser::AST::Node, nil]
           # @return [Source::Chain]
-          def chain node, filename = nil, parent = nil
-            NodeChainer.new(node, filename, parent).chain
+          def chain node, filename = nil, parent = nil, tree = nil
+            NodeChainer.new(node, filename, parent, tree).chain
           end
 
           # @param code [String]
@@ -150,6 +153,13 @@ module Solargraph
           elsif n.type == :array
             chained_children = n.children.map { |c| NodeChainer.chain(c) }
             result.push Source::Chain::Array.new(chained_children, n)
+          elsif inside_method_call? # If the node is inside a method call, it may be a parameter.
+            lit = infer_literal_node_type(n)
+            if lit
+              method_call_chain = NodeChainer.chain(send_node, @filename, nil, [])
+              literal = Chain::Literal.new(lit, n)
+              result.push Chain::Parameter.new(literal, method_call_chain)
+            end
           else
             lit = infer_literal_node_type(n)
             result.push(lit ? Chain::Literal.new(lit, n) : Chain::Link.new)
@@ -158,6 +168,15 @@ module Solargraph
           result
         end
 
+        def inside_method_call?
+          !send_node.nil? && send_node != @node
+        end
+
+        # @return [Parser::AST::Node, nil]
+        def send_node
+          @send_node ||= @tree&.find { |n| n.type == :send }
+        end
+
         # @param node [Parser::AST::Node]
         def hash_is_splatted? node
           return false unless Parser.is_ast_node?(node) && node.type == :hash

data/lib/solargraph/parser/parser_gem/node_processors/namespace_node.rb

@@ -27,7 +27,6 @@ module Solargraph
               source: :parser
             )
             pins.push nspin
-            Solargraph.logger.warn "Superclass: #{superclass_name}" if superclass_name&.start_with?('Array')
             if superclass_name
               pins.push Pin::Reference::Superclass.new(
                 location: loc,
@@ -41,12 +40,22 @@ module Solargraph
 
           private
 
-          # @param comments [String]
+          # Type arguments for a generic superclass in inline RBS syntax, e.g.,
+          # `class Foo < Array #[String]`. Only recognized where RBS defines
+          # it: directly after the superclass, on the same line, with no space
+          # between `#` and `[`. Anything else is an ordinary comment.
+          #
           # @return [String, nil]
           def parameters_from_inline_rbs
-            source = region.source.code_for(node)
-            match = source.match(/[^\n]*?#\s?+\[([^\]]*)/)
-            return unless match && match[1]
+            superclass = node.children[1]
+            return unless superclass
+
+            source = region.source.code
+            pos = get_node_end_position(superclass)
+            offset = Position.line_char_to_offset(source, pos.line, pos.character)
+            eol = source.index("\n", offset) || source.length
+            match = source[offset...eol].to_s.match(/\A\s*#\[([^\]]*)\]/)
+            return unless match
 
             code = match[1].strip
             return if code.empty?

data/lib/solargraph/pin/closure.rb

@@ -6,6 +6,23 @@ module Solargraph
       # @return [::Symbol] :class or :instance
       attr_reader :scope
 
+      # Override the pin's scope.
+      #
+      # Scope is normally determined by the syntax that declared the pin, but
+      # YARD's `@!scope` directive can change it after the fact. Any values
+      # derived from the scope, such as the pin's path and context, are
+      # recalculated.
+      #
+      # @param scope [::Symbol] :class or :instance
+      # @return [void]
+      def scope= scope
+        return if @scope == scope
+
+        @scope = scope
+        # remove cached values generated from scope
+        reset_generated!
+      end
+
       # @param scope [::Symbol] :class or :instance
       # @param generics [::Array<Pin::String>, nil]
       # @param generic_defaults [Hash{String => ComplexType}]

data/lib/solargraph/pin/factory_parameter.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    # A method parameter with a literal value used in a factory method.
+    #
+    # @example
+    #   RSpec.shared_examples 'some examples'
+    #
+    #   FactoryParameter.new(
+    #     method_name: 'shared_examples',
+    #     method_namespace: 'RSpec',
+    #     method_scope: :class,
+    #     param_name: 'name',
+    #     value: 'some examples',
+    #     decl: :arg,
+    #     return_type: 'void'
+    #   )
+    class FactoryParameter < Base
+      # @return [String]
+      attr_reader :method_name
+      # @return [String]
+      attr_reader :method_namespace
+      # @return [Symbol] :class or :instance
+      attr_reader :method_scope
+      # @return [String, nil]
+      attr_reader :param_name
+      # @return [::String, ::Symbol] The literal value
+      attr_reader :value
+      # @return [::Symbol] :arg, :optarg, :kwarg, :kwoptarg, :restarg, :kwrestarg, :block, :blockarg
+      attr_reader :decl
+      # @return [Location, nil]
+      attr_reader :location
+
+      # @param method_name [String] The name of the method that this parameter belongs to
+      # @param method_namespace [String] The class of the method that this parameter belongs to
+      # @param method_scope [Symbol] The scope of the method, either :class or :instance
+      # @param param_name [String, nil] The name of the parameter
+      # @param value [String, Symbol] The value of the parameter
+      # @param decl [::Symbol] :arg, :kwarg
+      # @param location [Location, nil] The location of the parameter in the source code
+      # @param return_type [String, nil] The return type of the method that this parameter belongs to
+      def initialize method_name:,
+                     method_namespace:,
+                     method_scope:,
+                     param_name:,
+                     value:,
+                     return_type:,
+                     decl: :arg,
+                     location: nil
+        super(location: location)
+        @method_name = method_name
+        @method_namespace = method_namespace
+        @method_scope = method_scope
+        @param_name = param_name
+        @value = value
+        @decl = decl
+        @return_type = return_type
+      end
+
+      def name
+        param_name
+      end
+
+      def text_documentation
+        "#{method_path}(#{param_name}) = #{value.inspect}"
+      end
+
+      # @return [String]
+      def method_path
+        # @sg-ignore false failure on method_scope "Wrong argument type for Solargraph::Pin::Base#==: other expected
+        # Solargraph::Pin::Base, received :instance"
+        @method_path ||= "#{method_namespace}#{method_scope == :instance ? '#' : '.'}#{method_name}"
+      end
+
+      private
+
+      def inner_desc
+        "method_path=#{method_path}, value=#{value.inspect}, decl=#{decl.inspect}, " \
+          "return_type=#{return_type&.to_s || 'nil'}"
+      end
+    end
+  end
+end

data/lib/solargraph/pin/method.rb

@@ -148,12 +148,13 @@ module Solargraph
 
       # @param parameters [::Array<Parameter>]
       # @param return_type [ComplexType, nil]
+      # @param tag_docstring [YARD::Docstring] source of @yieldparam/@yieldreturn tags; pass an @overload tag's own docstring here
       # @return [Signature]
-      def generate_signature parameters, return_type
+      def generate_signature parameters, return_type, tag_docstring = docstring
         # @type [Pin::Signature, nil]
         block = nil
-        yieldparam_tags = docstring.tags(:yieldparam)
-        yieldreturn_tags = docstring.tags(:yieldreturn)
+        yieldparam_tags = tag_docstring.tags(:yieldparam)
+        yieldreturn_tags = tag_docstring.tags(:yieldreturn)
         generics = docstring.tags(:generic).map(&:name)
         needs_block_param_signature =
           parameters.last&.block? || !yieldreturn_tags.empty? || !yieldparam_tags.empty?
@@ -747,7 +748,9 @@ module Solargraph
         top_type = generate_complex_type
         result = []
         result.push generate_signature(parameters, top_type) if top_type.defined?
-        result.concat(overloads.map { |meth| generate_signature(meth.parameters, meth.return_type) }) unless overloads.empty?
+        # @param meth [Pin::Signature]
+        # @param tag [YARD::Tags::OverloadTag]
+        result.concat(overloads.zip(docstring.tags(:overload).select(&:parameters)).map { |meth, tag| generate_signature(meth.parameters, meth.return_type, tag.docstring) }) unless overloads.empty?
         result.push generate_signature(parameters, @return_type || ComplexType::UNDEFINED) if result.empty?
         result
       end

data/lib/solargraph/pin.rb

@@ -38,6 +38,7 @@ module Solargraph
     autoload :Until,            'solargraph/pin/until'
     autoload :While,            'solargraph/pin/while'
     autoload :Callable,         'solargraph/pin/callable'
+    autoload :FactoryParameter, 'solargraph/pin/factory_parameter'
     autoload :CompoundStatement,
              'solargraph/pin/compound_statement'
 

data/lib/solargraph/rbs_map/base.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module RbsMap
+    class Base
+      def pins
+        @pins ||= RbsMap::Conversions.new(loader: loader).pins
+      end
+
+      # @return [RBS::Repository]
+      def repository
+        @repository ||= RBS::Repository.new(no_stdlib: true)
+      end
+
+      # @return [RBS::EnvironmentLoader]
+      def loader
+        @loader ||= RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
+      end
+
+      # @param path [String]
+      # @return [Array<Pin::Base>]
+      def path_pins path
+        pins.select { |p| p.path == path }
+      end
+
+      def self.pins(...)
+        new(...).pins
+      end
+    end
+  end
+end