solargraph 0.60.4 → 0.62.0

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,57 +589,35 @@ module Solargraph
     def cache_next_gemspec
       return if @cache_progress
 
-      spec = cacheable_specs.first
+      spec = (api_map.unloaded_gems - cache_errors).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)"
-        queued_gemspec_cache.push(spec)
-        return if pending - queued_gemspec_cache.length < 1
+      logger.info "Caching #{spec.name} #{spec.version}"
+      Thread.new do
+        report_cache_progress spec.name, pending
 
-        # Try the next cacheable gemspec. This method is always called
-        # from inside sync_catalog's mutex (either directly or via this
-        # same recursive call), so recursing through sync_catalog here
-        # would try to re-lock a mutex this thread already holds and
-        # deadlock (https://github.com/castwide/solargraph/issues/1111).
-        cache_next_gemspec
-      else
-        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)
-          if s.success?
-            logger.info "Cached #{spec.name} #{spec.version}"
-          else
-            cache_errors.add spec
-            logger.warn "Error caching gemspec #{spec.name} #{spec.version}"
-            logger.warn e
-          end
-          end_cache_progress
-          catalog
-          sync_catalog
+        cmd = [workspace.command_path, 'cache', spec.name]
+        cmd.push('--directory', workspace.directory) if workspace.directory
+        begin
+          _o, e, s = Open3.capture3(*cmd)
+        rescue SystemCallError => e
+          # The command could not start, e.g. Errno::ENOENT - handled below
         end
+        if s&.success?
+          logger.info "Cached #{spec.name} #{spec.version}"
+        else
+          cache_errors.add spec
+          logger.warn "Error caching gemspec #{spec.name} #{spec.version}"
+          logger.warn e
+        end
+        end_cache_progress
+        catalog
+        sync_catalog
       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 ||= []
-    end
-
     # @param gem_name [String]
     # @param pending [Integer]
     # @return [void]
@@ -696,8 +668,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/node_processor/base.rb

@@ -91,6 +91,12 @@ module Solargraph
           region.source.comments_for(node)
         end
 
+        # @param node [Parser::AST::Node]
+        # @return [String, nil]
+        def type_assertion_for node
+          region.source.type_assertion_for(node)
+        end
+
         # @param position [Solargraph::Position]
         # @return [Pin::Closure, nil]
         def named_path_pin position

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_methods.rb

@@ -197,6 +197,18 @@ module Solargraph
           nodes.any? { |n| splatted_call?(n) }
         end
 
+        # Anonymous `*`, `**` and `...` arguments pass on whatever the
+        # enclosing method received, so neither count nor types are known.
+        #
+        # @param nodes [Enumerable<Parser::AST::Node>]
+        def any_forwarded_args? nodes
+          nodes.any? do |n|
+            next false unless Parser.is_ast_node?(n)
+            next true if %i[forwarded_args forwarded_restarg].include?(n.type)
+            n.type == :hash && n.children.any? { |c| Parser.is_ast_node?(c) && c.type == :forwarded_kwrestarg }
+          end
+        end
+
         # @todo Temporarily here for testing. Move to Solargraph::Parser.
         # @param node [Parser::AST::Node]
         # @return [Array<Parser::AST::Node>]
@@ -442,6 +454,11 @@ module Solargraph
             CONDITIONAL_ALL_BUT_FIRST = %i[if unless].freeze
             ONLY_ONE_CHILD = [:return].freeze
             FIRST_TWO_CHILDREN = [:rescue].freeze
+            # :ensure's value is always its body's value (first
+            # child); the ensure clause itself (second child) never
+            # contributes to the method's return value unless it
+            # explicitly returns.
+            ENSURE = [:ensure].freeze
             COMPOUND_STATEMENTS = %i[begin kwbegin].freeze
             SKIPPABLE = %i[def defs class sclass module].freeze
             FUNCTION_VALUE = [:block].freeze
@@ -488,6 +505,13 @@ module Solargraph
                 result.concat reduce_to_value_nodes([node.children[0]])
               elsif FIRST_TWO_CHILDREN.include?(node.type)
                 result.concat reduce_to_value_nodes([node.children[0], node.children[1]])
+              elsif ENSURE.include?(node.type)
+                result.concat reduce_to_value_nodes([node.children[0]])
+                ensure_body = node.children[1]
+                if include_explicit_returns && ensure_body.is_a?(::Parser::AST::Node)
+                  # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+                  result.concat explicit_return_values_from_compound_statement(ensure_body)
+                end
               elsif FUNCTION_VALUE.include?(node.type)
                 # the block itself is a first class value that could be returned
                 result.push node
@@ -605,14 +629,13 @@ module Solargraph
                 elsif CONDITIONAL_ALL_BUT_FIRST.include?(node.type)
                   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                   result.concat reduce_to_value_nodes(node.children[1..])
-                # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-                elsif node.type == :return
+                elsif ONLY_ONE_CHILD.include?(node.type) || ENSURE.include?(node.type)
                   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                   result.concat reduce_to_value_nodes([node.children[0]])
-                # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-                elsif node.type == :or
-                  # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-                  result.concat reduce_to_value_nodes(node.children)
+                elsif FIRST_TWO_CHILDREN.include?(node.type)
+                  # a :rescue node's value is its body's value or the
+                  # value of whichever resbody handled the exception
+                  result.concat reduce_to_value_nodes([node.children[0], node.children[1]])
                 # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                 elsif node.type == :block
                   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check

data/lib/solargraph/parser/parser_gem/node_processors/class_definition/class_assignment_node.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        module ClassDefinition
+          # A node wrapper for a class definition via const assignment.
+          # @example
+          #   MyError = Class.new(StandardError) do
+          #     def retry_after; 5; end
+          #   end
+          class ClassAssignmentNode
+            class << self
+              # @example
+              #   s(:casgn, nil, :Foo,
+              #     s(:block,
+              #       s(:send,
+              #         s(:const, nil, :Class), :new,
+              #         s(:const, nil, :StandardError)),
+              #       s(:args),
+              #       s(:def, :retry_after, s(:args), s(:int, 5))))
+              #
+              # @param node [Parser::AST::Node]
+              # @return [Boolean]
+              def match? node
+                return false unless node&.type == :casgn
+
+                class_new_node?(new_node(node))
+              end
+
+              # The `Class.new(...)` send node, whether or not a block is attached.
+              #
+              # @param node [Parser::AST::Node]
+              # @return [Parser::AST::Node, nil]
+              def new_node node
+                value = node.children[2]
+                return nil if value.nil?
+                return value unless value.type == :block
+
+                value.children[0]
+              end
+
+              private
+
+              # @param send_node [Parser::AST::Node, nil]
+              # @return [Boolean]
+              def class_new_node? send_node
+                return false if send_node.nil?
+                return false unless send_node.type == :send
+                return false unless send_node.children[1] == :new
+
+                receiver = send_node.children[0]
+                return false if receiver.nil?
+                return false unless receiver.type == :const
+
+                receiver.children[1] == :Class
+              end
+            end
+
+            # @param node [Parser::AST::Node]
+            def initialize node
+              @node = node
+            end
+
+            # @return [String]
+            def class_name
+              namespace = node.children[0]
+              return node.children[1].to_s if namespace.nil?
+
+              "#{Parser::NodeMethods.unpack_name(namespace)}::#{node.children[1]}"
+            end
+
+            # The superclass, when it is written as a constant. `Class.new(expr)`
+            # with a non-constant argument yields nil (superclass stays Object).
+            #
+            # @return [String, nil]
+            def superclass_name
+              send_node = self.class.new_node(node)
+              return nil if send_node.nil?
+
+              arg = send_node.children[2]
+              return nil if arg.nil?
+              return nil unless arg.type == :const
+
+              Parser::NodeMethods.unpack_name(arg)
+            end
+
+            private
+
+            # @return [Parser::AST::Node]
+            attr_reader :node
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        module ClassDefinition
+          autoload :ClassAssignmentNode, 'solargraph/parser/parser_gem/node_processors/class_definition/class_assignment_node'
+
+          class ClassNode < Parser::NodeProcessor::Base
+            # @return [Boolean] continue processing the next processor of the same node.
+            def process
+              definition_node = class_definition_node
+              return true if definition_node.nil?
+
+              loc = get_node_location(node)
+              nspin = Solargraph::Pin::Namespace.new(
+                type: :class,
+                location: loc,
+                closure: region.closure,
+                name: definition_node.class_name,
+                comments: comments_for(node),
+                visibility: :public,
+                gates: region.closure.gates.freeze,
+                source: :class_definition
+              )
+              pins.push nspin
+
+              superclass_name = definition_node.superclass_name
+              if superclass_name
+                pins.push Pin::Reference::Superclass.new(
+                  location: loc,
+                  closure: nspin,
+                  name: superclass_name,
+                  source: :class_definition
+                )
+              end
+
+              process_children region.update(closure: nspin, visibility: :public)
+              false
+            end
+
+            private
+
+            # @return [ClassDefinition::ClassAssignmentNode, nil]
+            def class_definition_node
+              @class_definition_node ||= ClassAssignmentNode.new(node) if ClassAssignmentNode.match?(node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -12,6 +12,7 @@ module Solargraph
               closure: region.closure,
               name: node.children[0].to_s,
               comments: comments_for(node),
+              type_assertion: type_assertion_for(node),
               assignment: node.children[1],
               source: :parser
             )

data/lib/solargraph/parser/parser_gem/node_processors/data_definition/data_assignment_node.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        module DataDefinition
+          # A node wrapper for a Data definition via const assignment.
+          # @example
+          #   MyData = Data.new(:bar, :baz) do
+          #     def foo
+          #     end
+          #   end
+          class DataAssignmentNode < DataDefintionNode
+            class << self
+              # @example
+              # s(:casgn, nil, :Foo,
+              #   s(:block,
+              #     s(:send,
+              #       s(:const, nil, :Data), :define,
+              #       s(:sym, :bar),
+              #       s(:sym, :baz)),
+              #     s(:args),
+              #     s(:def, :foo,
+              #       s(:args),
+              #       s(:send, nil, :bar))))
+              # @param node [::Parser::AST::Node]
+              def match? node
+                return false unless node&.type == :casgn
+                return false if node.children[2].nil?
+
+                data_node = if node.children[2].type == :block
+                              node.children[2].children[0]
+                            else
+                              node.children[2]
+                            end
+
+                data_definition_node?(data_node)
+              end
+            end
+
+            def class_name
+              if node.children[0]
+                Parser::NodeMethods.unpack_name(node.children[0]) + "::#{node.children[1]}"
+              else
+                node.children[1].to_s
+              end
+            end
+
+            private
+
+            # @return [Parser::AST::Node]
+            def data_node
+              if node.children[2].type == :block
+                node.children[2].children[0]
+              else
+                node.children[2]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_processors/data_definition/data_definition_node.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        module DataDefinition
+          # A node wrapper for a Data definition via inheritance.
+          # @example
+          #   class MyData < Data.new(:bar, :baz)
+          #     def foo
+          #     end
+          #   end
+          class DataDefintionNode
+            class << self
+              # @example
+              #   s(:class,
+              #     s(:const, nil, :Foo),
+              #     s(:send,
+              #       s(:const, nil, :Data), :define,
+              #       s(:sym, :bar),
+              #       s(:sym, :baz)),
+              #       s(:hash,
+              #         s(:pair,
+              #           s(:sym, :keyword_init),
+              #           s(:true)))),
+              #     s(:def, :foo,
+              #       s(:args),
+              #       s(:send, nil, :bar)))
+              #
+              # @param node [Parser::AST::Node]
+              def match? node
+                return false unless node&.type == :class
+
+                data_definition_node?(node.children[1])
+              end
+
+              private
+
+              # @param data_node [Parser::AST::Node]
+              # @return [Boolean]
+              def data_definition_node? data_node
+                return false unless data_node.is_a?(::Parser::AST::Node)
+                return false unless data_node&.type == :send
+                return false unless data_node.children[0]&.type == :const
+                return false unless data_node.children[0].children[1] == :Data
+                return false unless data_node.children[1] == :define
+
+                true
+              end
+            end
+
+            # @param node [Parser::AST::Node]
+            def initialize node
+              @node = node
+            end
+
+            # @return [String]
+            def class_name
+              Parser::NodeMethods.unpack_name(node)
+            end
+
+            # @return [Array<Array(Parser::AST::Node, String)>]
+            def attributes
+              data_attribute_nodes.map do |data_def_param|
+                next unless data_def_param.type == :sym
+                [data_def_param, data_def_param.children[0].to_s]
+              end.compact
+            end
+
+            # @return [Parser::AST::Node, nil]
+            def body_node
+              node.children[2]
+            end
+
+            private
+
+            # @return [Parser::AST::Node]
+            attr_reader :node
+
+            # @return [Parser::AST::Node, nil]
+            def data_node
+              node.children[1]
+            end
+
+            # @sg-ignore Need to add nil check here
+            # @return [Array<Parser::AST::Node>]
+            def data_attribute_nodes
+              # @sg-ignore Need to add nil check here
+              data_node.children[2..]
+            end
+          end
+        end
+      end
+    end
+  end
+end