solargraph 0.61.0 → 0.62.0

data/lib/solargraph/language_server/host/dispatch.rb

@@ -118,11 +118,13 @@ module Solargraph
                                                   .tap { |lib| lib.add_observer self }
         end
 
-        # @param progress [Solargraph::LanguageServer::Progress, nil]
+        # The Library observer callback that #generic_library registers.
         #
+        # @abstract
+        # @param progress [Solargraph::LanguageServer::Progress, nil]
         # @return [void]
         def update progress
-          progress&.send(self)
+          raise NotImplementedError, 'Host::Dispatch requires an update method'
         end
       end
     end

data/lib/solargraph/language_server/host.rb

@@ -495,7 +495,7 @@ module Solargraph
           )
           result.concat(library.locate_pins(location).select { |pin| pin.name == params['label'] })
         end
-        if params['data']['path']
+        if params['data']['path'] && !params['data']['path'].empty?
           result.concat library.path_pins(params['data']['path'])
           # @todo This exception is necessary because `Library#path_pins` does
           #   not perform a namespace method query, so the implicit `.new` pin
@@ -706,6 +706,15 @@ module Solargraph
         client_capabilities['window'] && client_capabilities['window']['workDoneProgress']
       end
 
+      # The Library observer callback that sends a library's progress to
+      # the client.
+      #
+      # @param progress [Solargraph::LanguageServer::Progress, nil]
+      # @return [void]
+      def update progress
+        progress&.send(self)
+      end
+
       private
 
       # @return [Array<Integer>]
@@ -736,7 +745,6 @@ module Solargraph
       # @return [String]
       def normalize_separators path
         return path if File::ALT_SEPARATOR.nil?
-        # @sg-ignore flow sensitive typing needs to handle constants
         path.gsub(File::ALT_SEPARATOR, File::SEPARATOR)
       end
 

data/lib/solargraph/language_server/message/completion_item/resolve.rb

@@ -7,6 +7,12 @@ module Solargraph
         # completionItem/resolve message handler
         #
         class Resolve < Base
+          # Properties that must not be changed during completionItem/resolve
+          # according to the LSP specification.
+          #
+          # @see https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_completion
+          IMMUTABLE_FIELDS = %i[label kind sortText filterText insertText textEdit data].freeze
+
           def process
             pins = host.locate_pins(params)
             set_result merge(pins)
@@ -17,14 +23,15 @@ module Solargraph
           # @param pins [Array<Pin::Base>]
           # @return [Hash]
           def merge pins
-            return params if pins.empty?
+            original = params.transform_keys(&:to_sym)
+            return original if pins.empty?
             docs = pins
                    .reject { |pin| pin.documentation.empty? && pin.return_type.undefined? }
-            result = params
-                     .transform_keys(&:to_sym)
+            result = original
                      .merge(pins.first.resolve_completion_item)
                      .merge(documentation: markup_content(join_docs(docs)))
             result[:detail] = pins.first.detail
+            IMMUTABLE_FIELDS.each { |field| result[field] = original[field] }
             result
           end
 

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

@@ -15,7 +15,7 @@ module Solargraph
 
           # @return [Array<Hash>, nil]
           def code_location
-            suggestions = host.definitions_at(params['textDocument']['uri'], @line, @column)
+            suggestions = host.definitions_at(params['textDocument']['uri'], @line, @column) || []
             # @sg-ignore Need to add nil check here
             return nil if suggestions.empty?
             # @sg-ignore Need to add nil check here

data/lib/solargraph/library.rb

@@ -589,49 +589,35 @@ module Solargraph
     def cache_next_gemspec
       return if @cache_progress
 
-      spec = api_map.unloaded_gems.first
+      spec = (api_map.unloaded_gems - cache_errors).first
       return end_cache_progress unless spec
 
       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
-
-          cmd = [workspace.command_path, 'cache', spec.name]
-          cmd.push('--directory', workspace.directory) if workspace.directory
+        cmd = [workspace.command_path, 'cache', spec.name]
+        cmd.push('--directory', workspace.directory) if workspace.directory
+        begin
           _o, e, s = Open3.capture3(*cmd)
-          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
+        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 queued_gemspec_cache
-      @queued_gemspec_cache ||= []
-    end
-
     # @param gem_name [String]
     # @param pending [Integer]
     # @return [void]

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_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

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        module DataDefinition
+          autoload :DataDefintionNode, 'solargraph/parser/parser_gem/node_processors/data_definition/data_definition_node'
+          autoload :DataAssignmentNode, 'solargraph/parser/parser_gem/node_processors/data_definition/data_assignment_node'
+
+          class DataNode < Parser::NodeProcessor::Base
+            # @return [Boolean] continue processing the next processor of the same node.
+            def process
+              return true if data_definition_node.nil?
+
+              loc = get_node_location(node)
+              nspin = Solargraph::Pin::Namespace.new(
+                type: :class,
+                location: loc,
+                closure: region.closure,
+                # @sg-ignore flow sensitive typing needs to handle attrs
+                name: data_definition_node.class_name,
+                comments: comments_for(node),
+                visibility: :public,
+                gates: region.closure.gates.freeze
+              )
+              pins.push nspin
+
+              # define initialize method
+              initialize_method_pin = Pin::Method.new(
+                name: 'initialize',
+                parameters: [],
+                scope: :instance,
+                location: get_node_location(node),
+                closure: nspin,
+                visibility: :private,
+                comments: comments_for(node)
+              )
+
+              # @todo Support both arg and kwarg initializers for Data.define
+              # Solargraph::SourceMap::Clip#complete_keyword_parameters does not seem to currently take into account [Pin::Method#signatures] hence we only one for :kwarg
+              pins.push initialize_method_pin
+
+              # @sg-ignore flow sensitive typing needs to handle attrs
+              data_definition_node.attributes.map do |attribute_node, attribute_name|
+                initialize_method_pin.parameters.push(
+                  Pin::Parameter.new(
+                    name: attribute_name,
+                    decl: :kwarg,
+                    location: get_node_location(attribute_node),
+                    closure: initialize_method_pin
+                  )
+                )
+              end
+
+              # define attribute readers and instance variables
+              # @sg-ignore flow sensitive typing needs to handle attrs
+              data_definition_node.attributes.each do |attribute_node, attribute_name|
+                name = attribute_name.to_s
+                method_pin = Pin::Method.new(
+                  name: name,
+                  parameters: [],
+                  scope: :instance,
+                  location: get_node_location(attribute_node),
+                  closure: nspin,
+                  comments: attribute_comments(attribute_node, attribute_name),
+                  visibility: :public
+                )
+
+                pins.push method_pin
+
+                pins.push Pin::InstanceVariable.new(name: "@#{attribute_name}",
+                                                    closure: method_pin,
+                                                    location: get_node_location(attribute_node),
+                                                    comments: attribute_comments(attribute_node, attribute_name))
+              end
+
+              process_children region.update(closure: nspin, visibility: :public)
+
+              false
+            end
+
+            private
+
+            # @return [DataDefinition::DataDefintionNode, DataDefinition::DataAssignmentNode, nil]
+            def data_definition_node
+              @data_definition_node ||= if DataDefintionNode.match?(node)
+                                          DataDefintionNode.new(node)
+                                        elsif DataAssignmentNode.match?(node)
+                                          DataAssignmentNode.new(node)
+                                        end
+            end
+
+            # @param attribute_node [Parser::AST::Node]
+            # @param attribute_name [String]
+            # @return [String, nil]
+            def attribute_comments attribute_node, attribute_name
+              data_comments = comments_for(attribute_node)
+              return if data_comments.nil? || data_comments.empty?
+
+              data_comments.split("\n").find do |row|
+                row.include?(attribute_name)
+              end&.gsub('@param', '@return')&.gsub(attribute_name, '')
+            end
+          end
+        end
+      end
+    end
+  end
+end