solargraph 0.56.1 → 0.56.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed69bea4d42d6605dab61eb153507927ac3104946f39eb1ff8380676df9d0cbc
-  data.tar.gz: 569b85b0c73b81135d93d814db90ffbb861a0c752515c689edaa60742d0d0f81
+  metadata.gz: 82754cd0869fed91a86a2bfb08ca0f54d6468f942620cddd3148bad99724ad88
+  data.tar.gz: 4e017a78936b0d24eaa6d5db7edcd01ea2b43d6cb365eb5b4892576a141ca2b7
 SHA512:
-  metadata.gz: 84ed3ec4cd5c58a28311964b7f201dc98c2aeaff25e383e96cf9b05a8d90a9a65552b818ee033c5a16a45d4c584069696c90299d5bc831b85985ae14f823718b
-  data.tar.gz: e1eb56a9f697e2cc3873ab1e60eec0608cec014d599b3ac40b832c96d3e9a90fdba4a3846127b4dc6c1270cf94344721fe0bf2d79d0db4db57cde999c418f4b2
+  metadata.gz: 304fb86181925f916d7119da44b85a3753fc33d961da8a61c5525dbcb8d814a87baeeb9767d17b7ec6548c3ffe725bfda6eafbfd7ea75e8bdddf3f1a1a5c103b
+  data.tar.gz: 73d437e753be70628008f09a7846cba5e16fd47d045017b41c0b301d8a5b34ca04a45127a37c6eada4e61287944ca1af659ecab8df4681bab42a8ecc37d73bc4

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.56.2 - July 29, 2025
+- Add support for Ruby Data.define (#970)
+- Ensure that pin locations are always populated (#965)
+- Improve struct support (#992)
+- Include Rakefile, Gemfile, and gemspec files in config by default (#984)
+- Use Open3 to cache gemspecs (#1000)
+- Eager load node processors (#1002)
+
 ## 0.56.1 - July 13, 2025
 - Library avoids blocking on pending yardoc caches (#990)
 - DocMap checks for default Gemfile (#989)

data/lib/solargraph/convention/data_definition/data_assignment_node.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    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))))
+          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

data/lib/solargraph/convention/data_definition/data_definition_node.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    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)))
+          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
+
+        # @return [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]
+        def body_node
+          node.children[2]
+        end
+
+        private
+
+        # @return [Parser::AST::Node]
+        attr_reader :node
+
+        # @return [Parser::AST::Node]
+        def data_node
+          node.children[1]
+        end
+
+        # @return [Array<Parser::AST::Node>]
+        def data_attribute_nodes
+          data_node.children[2..-1]
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/convention/data_definition.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    module DataDefinition
+      autoload :DataDefintionNode, 'solargraph/convention/data_definition/data_definition_node'
+      autoload :DataAssignmentNode, 'solargraph/convention/data_definition/data_assignment_node'
+
+      module NodeProcessors
+        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,
+              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
+
+            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
+            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 [DataDefintionNode, 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]
+          # @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

data/lib/solargraph/convention/gemspec.rb

@@ -12,7 +12,8 @@ module Solargraph
               'Gem::Specification.new',
               %(
 @yieldparam [self]
-              )
+              ),
+              source: :gemspec
             )
           ]
         )

data/lib/solargraph/convention/struct_definition/struct_assignment_node.rb

@@ -22,7 +22,7 @@ module Solargraph
           #     s(:def, :foo,
           #       s(:args),
           #       s(:send, nil, :bar))))
-          def valid?(node)
+          def match?(node)
             return false unless node&.type == :casgn
             return false if node.children[2].nil?
 

data/lib/solargraph/convention/struct_definition/struct_definition_node.rb

@@ -25,7 +25,7 @@ module Solargraph
           #     s(:def, :foo,
           #       s(:args),
           #       s(:send, nil, :bar)))
-          def valid?(node)
+          def match?(node)
             return false unless node&.type == :class
 
             struct_definition_node?(node.children[1])

data/lib/solargraph/convention/struct_definition.rb

@@ -8,8 +8,9 @@ module Solargraph
 
       module NodeProcessors
         class StructNode < Parser::NodeProcessor::Base
+          # @return [Boolean] continue processing the next processor of the same node.
           def process
-            return if struct_definition_node.nil?
+            return true if struct_definition_node.nil?
 
             loc = get_node_location(node)
             nspin = Solargraph::Pin::Namespace.new(
@@ -17,7 +18,7 @@ module Solargraph
               location: loc,
               closure: region.closure,
               name: struct_definition_node.class_name,
-              comments: comments_for(node),
+              docstring: docstring,
               visibility: :public,
               gates: region.closure.gates.freeze
             )
@@ -31,7 +32,7 @@ module Solargraph
               location: get_node_location(node),
               closure: nspin,
               visibility: :private,
-              comments: comments_for(node)
+              docstring: docstring
             )
 
             pins.push initialize_method_pin
@@ -50,49 +51,88 @@ module Solargraph
             # define attribute accessors and instance variables
             struct_definition_node.attributes.each do |attribute_node, attribute_name|
               [attribute_name, "#{attribute_name}="].each do |name|
+                docs = docstring.tags.find { |t| t.tag_name == 'param' && t.name == attribute_name }
+
                 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),
+                  # even assignments return the value
+                  comments: attribute_comment(docs, false),
                   visibility: :public
                 )
 
-                pins.push method_pin
+                if name.end_with?('=')
+                  method_pin.parameters << Pin::Parameter.new(
+                    name: attribute_name,
+                    location: get_node_location(attribute_node),
+                    closure: nspin,
+                    comments: attribute_comment(docs, true)
+                  )
 
-                next unless name.include?('=') # setter
-                pins.push Pin::InstanceVariable.new(name: "@#{attribute_name}",
-                                                    closure: method_pin,
-                                                    location: get_node_location(attribute_node),
-                                                    comments: attribute_comments(attribute_node, attribute_name))
+                  pins.push Pin::InstanceVariable.new(name: "@#{attribute_name}",
+                                    closure: method_pin,
+                                    location: get_node_location(attribute_node),
+                                    comments: attribute_comment(docs, false))
+                end
+
+                pins.push method_pin
               end
             end
 
             process_children region.update(closure: nspin, visibility: :public)
+            false
           end
 
           private
 
           # @return [StructDefintionNode, nil]
           def struct_definition_node
-            @struct_definition_node ||= if StructDefintionNode.valid?(node)
+            @struct_definition_node ||= if StructDefintionNode.match?(node)
                                           StructDefintionNode.new(node)
-                                        elsif StructAssignmentNode.valid?(node)
+                                        elsif StructAssignmentNode.match?(node)
                                           StructAssignmentNode.new(node)
                                         end
           end
 
-          # @param attribute_node [Parser::AST::Node]
-          # @return [String, nil]
-          def attribute_comments(attribute_node, attribute_name)
-            struct_comments = comments_for(attribute_node)
-            return if struct_comments.nil? || struct_comments.empty?
+          # Gets/generates the relevant docstring for this struct & it's attributes
+          # @return [YARD::Docstring]
+          def docstring
+            @docstring ||= parse_comments
+          end
+
+          # Parses any relevant comments for a struct int a yard docstring
+          # @return [YARD::Docstring]
+          def parse_comments
+            struct_comments = comments_for(node) || ''
+            struct_definition_node.attributes.each do |attr_node, attr_name|
+              comment = comments_for(attr_node)
+              next if comment.nil?
+
+              # We should support specific comments for an attribute, and that can be either a @return on an @param
+              # But since we merge into the struct_comments, then we should interpret either as a param
+              comment = '@param ' + attr_name + comment[7..] if comment.start_with?('@return')
+
+              struct_comments += "\n#{comment}"
+            end
+
+            Solargraph::Source.parse_docstring(struct_comments).to_docstring
+          end
+
+          # @param tag [YARD::Tags::Tag, nil] The param tag for this attribute. If nil, this method is a no-op
+          # @param for_setter [Boolean] If true, will return a @param tag instead of a @return tag
+          def attribute_comment(tag, for_setter)
+            return "" if tag.nil?
+
+            suffix = "[#{tag.types&.join(',') || 'undefined'}] #{tag.text}"
 
-            struct_comments.split("\n").find do |row|
-              row.include?(attribute_name)
-            end&.gsub('@param', '@return')&.gsub(attribute_name, '')
+            if for_setter
+              "@param #{tag.name} #{suffix}"
+            else
+              "@return #{suffix}"
+            end
           end
         end
       end

data/lib/solargraph/convention.rb

@@ -11,6 +11,7 @@ module Solargraph
     autoload :Gemspec, 'solargraph/convention/gemspec'
     autoload :Rakefile, 'solargraph/convention/rakefile'
     autoload :StructDefinition, 'solargraph/convention/struct_definition'
+    autoload :DataDefinition,   'solargraph/convention/data_definition'
 
     # @type [Set<Convention::Base>]
     @@conventions = Set.new

data/lib/solargraph/library.rb

@@ -2,6 +2,7 @@
 
 require 'pathname'
 require 'observer'
+require 'open3'
 
 module Solargraph
   # A Library handles coordination between a Workspace and an ApiMap.
@@ -604,16 +605,15 @@ module Solargraph
       else
         logger.info "Caching #{spec.name} #{spec.version}"
         Thread.new do
-          cache_pid = Process.spawn(workspace.command_path, 'cache', spec.name, spec.version.to_s)
           report_cache_progress spec.name, pending
-          Process.wait(cache_pid)
-          logger.info "Cached #{spec.name} #{spec.version}"
-        rescue Errno::EINVAL => _e
-          logger.info "Cached #{spec.name} #{spec.version} with EINVAL"
-        rescue StandardError => e
-          cache_errors.add spec
-          Solargraph.logger.warn "Error caching gemspec #{spec.name} #{spec.version}: [#{e.class}] #{e.message}"
-        ensure
+          _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

data/lib/solargraph/parser/node_processor/base.rb

@@ -30,9 +30,12 @@ module Solargraph
 
         # Subclasses should override this method to generate new pins.
         #
-        # @return [void]
+        # @return [Boolean] continue processing the next processor of the same node type.
+        # @return [void] In case there is only one processor registered for the node type, it can be void.
         def process
           process_children
+
+          true
         end
 
         private
@@ -64,7 +67,9 @@ module Solargraph
         # @param position [Solargraph::Position]
         # @return [Pin::Closure, nil]
         def named_path_pin position
-          pins.select{|pin| pin.is_a?(Pin::Closure) && pin.path && !pin.path.empty? && pin.location.range.contain?(position)}.last
+          pins.select do |pin|
+            pin.is_a?(Pin::Closure) && pin.path && !pin.path.empty? && pin.location.range.contain?(position)
+          end.last
         end
 
         # @todo Candidate for deprecation
@@ -72,14 +77,14 @@ module Solargraph
         # @return [Pin::Closure, nil]
         def block_pin position
           # @todo determine if this can return a Pin::Block
-          pins.select{|pin| pin.is_a?(Pin::Closure) && pin.location.range.contain?(position)}.last
+          pins.select { |pin| pin.is_a?(Pin::Closure) && pin.location.range.contain?(position) }.last
         end
 
         # @todo Candidate for deprecation
         # @param position [Solargraph::Position]
         # @return [Pin::Closure, nil]
         def closure_pin position
-          pins.select{|pin| pin.is_a?(Pin::Closure) && pin.location.range.contain?(position)}.last
+          pins.select { |pin| pin.is_a?(Pin::Closure) && pin.location.range.contain?(position) }.last
         end
       end
     end

data/lib/solargraph/parser/node_processor.rb

@@ -9,16 +9,22 @@ module Solargraph
       autoload :Base, 'solargraph/parser/node_processor/base'
 
       class << self
-        # @type [Hash{Symbol => Class<NodeProcessor::Base>}]
+        # @type [Hash<Symbol, Array<Class<NodeProcessor::Base>>>]
         @@processors ||= {}
 
-        # Register a processor for a node type.
+        # Register a processor for a node type. You can register multiple processors for the same type.
+        # If a node processor returns true, it will skip the next processor of the same node type.
         #
         # @param type [Symbol]
         # @param cls [Class<NodeProcessor::Base>]
         # @return [Class<NodeProcessor::Base>]
         def register type, cls
-          @@processors[type] = cls
+          @@processors[type] ||= []
+          @@processors[type] << cls
+        end
+
+        def deregister type, cls
+          @@processors[type].delete(cls)
         end
       end
 
@@ -36,10 +42,16 @@ module Solargraph
           )
         end
         return [pins, locals] unless Parser.is_ast_node?(node)
-        klass = @@processors[node.type] || NodeProcessor::Base
-        processor = klass.new(node, region, pins, locals)
-        processor.process
-        [processor.pins, processor.locals]
+        node_processor_classes = @@processors[node.type] || [NodeProcessor::Base]
+
+        node_processor_classes.each do |klass|
+          processor = klass.new(node, region, pins, locals)
+          process_next = processor.process
+
+          break unless process_next
+        end
+
+        [pins, locals]
       end
     end
   end

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

@@ -8,17 +8,6 @@ module Solargraph
           include ParserGem::NodeMethods
 
           def process
-            if Convention::StructDefinition::StructAssignmentNode.valid?(node)
-              process_struct_assignment
-            else
-              process_constant_assignment
-            end
-          end
-
-          private
-
-          # @return [void]
-          def process_constant_assignment
             pins.push Solargraph::Pin::Constant.new(
               location: get_node_location(node),
               closure: region.closure,
@@ -30,16 +19,7 @@ module Solargraph
             process_children
           end
 
-          # @todo Move this out of [CasgnNode] once [Solargraph::Parser::NodeProcessor] supports
-          #   multiple processors.
-          def process_struct_assignment
-            processor_klass = Convention::StructDefinition::NodeProcessors::StructNode
-            processor = processor_klass.new(node, region, pins, locals)
-            processor.process
-
-            @pins = processor.pins
-            @locals = processor.locals
-          end
+          private
 
           # @return [String]
           def const_name

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

@@ -7,6 +7,7 @@ module Solargraph
         class MasgnNode < Parser::NodeProcessor::Base
           include ParserGem::NodeMethods
 
+          # @return [void]
           def process
             # Example:
             #
@@ -40,7 +41,9 @@ module Solargraph
               # @todo in line below, nothing in typechecking alerts
               #   when a non-existant method is called on 'l'
               if pin.nil?
-                Solargraph.logger.debug { "Could not find local for masgn= value in location #{location.inspect} in #{lhs_arr} - masgn = #{masgn}, lhs.type = #{lhs.type}" }
+                Solargraph.logger.debug do
+                  "Could not find local for masgn= value in location #{location.inspect} in #{lhs_arr} - masgn = #{masgn}, lhs.type = #{lhs.type}"
+                end
                 next
               end
               pin.mass_assignment = [mass_rhs, i]

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

@@ -11,17 +11,6 @@ module Solargraph
             superclass_name = nil
             superclass_name = unpack_name(node.children[1]) if node.type == :class && node.children[1]&.type == :const
 
-            if Convention::StructDefinition::StructDefintionNode.valid?(node)
-              process_struct_definition
-            else
-              process_namespace(superclass_name)
-            end
-          end
-
-          private
-
-          # @param superclass_name [String, nil]
-          def process_namespace(superclass_name)
             loc = get_node_location(node)
             nspin = Solargraph::Pin::Namespace.new(
               type: node.type,
@@ -44,17 +33,6 @@ module Solargraph
             end
             process_children region.update(closure: nspin, visibility: :public)
           end
-
-          # @todo Move this out of [NamespaceNode] once [Solargraph::Parser::NodeProcessor] supports
-          #   multiple processors.
-          def process_struct_definition
-            processor_klass = Convention::StructDefinition::NodeProcessors::StructNode
-            processor = processor_klass.new(node, region, pins, locals)
-            processor.process
-
-            @pins = processor.pins
-            @locals = processor.locals
-          end
         end
       end
     end

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

@@ -7,6 +7,7 @@ module Solargraph
     module ParserGem
       module NodeProcessors
         class OpasgnNode < Parser::NodeProcessor::Base
+          # @return [void]
           def process
             # Parser::CurrentRuby.parse("a += 2")
             # => s(:op_asgn,

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

@@ -5,6 +5,7 @@ module Solargraph
     module ParserGem
       module NodeProcessors
         class OrasgnNode < Parser::NodeProcessor::Base
+          # @return [void]
           def process
             new_node = node.updated(node.children[0].type, node.children[0].children + [node.children[1]])
             NodeProcessor.process(new_node, region, pins, locals)

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

@@ -7,6 +7,7 @@ module Solargraph
         class ResbodyNode < Parser::NodeProcessor::Base
           include ParserGem::NodeMethods
 
+          # @return [void]
           def process
             if node.children[1] # Exception local variable name
               here = get_node_start_position(node.children[1])

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

@@ -5,6 +5,7 @@ module Solargraph
     module ParserGem
       module NodeProcessors
         class SymNode < Parser::NodeProcessor::Base
+          # @return [void]
           def process
             pins.push Solargraph::Pin::Symbol.new(
               get_node_location(node),

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

@@ -42,6 +42,8 @@ module Solargraph
       register :defs,         ParserGem::NodeProcessors::DefsNode
       register :if,           ParserGem::NodeProcessors::IfNode
       register :send,         ParserGem::NodeProcessors::SendNode
+      register :class,        Convention::StructDefinition::NodeProcessors::StructNode
+      register :class,        Convention::DataDefinition::NodeProcessors::DataNode
       register :class,        ParserGem::NodeProcessors::NamespaceNode
       register :module,       ParserGem::NodeProcessors::NamespaceNode
       register :sclass,       ParserGem::NodeProcessors::SclassNode
@@ -49,6 +51,8 @@ module Solargraph
       register :cvasgn,       ParserGem::NodeProcessors::CvasgnNode
       register :lvasgn,       ParserGem::NodeProcessors::LvasgnNode
       register :gvasgn,       ParserGem::NodeProcessors::GvasgnNode
+      register :casgn,        Convention::StructDefinition::NodeProcessors::StructNode
+      register :casgn,        Convention::DataDefinition::NodeProcessors::DataNode
       register :casgn,        ParserGem::NodeProcessors::CasgnNode
       register :masgn,        ParserGem::NodeProcessors::MasgnNode
       register :alias,        ParserGem::NodeProcessors::AliasNode

data/lib/solargraph/pin/base.rb

@@ -51,6 +51,14 @@ module Solargraph
         @docstring = docstring
         @directives = directives
         assert_source_provided
+        assert_location_provided
+      end
+
+      # @return [void]
+      def assert_location_provided
+        return unless best_location.nil? && %i[yardoc source rbs].include?(source)
+
+        Solargraph.assert_or_log(:best_location, "Neither location nor type_location provided - #{path} #{source} #{self.class}")
       end
 
       # @param other [self]
@@ -290,6 +298,9 @@ module Solargraph
         choose_pin_attr(other, attr)
       end
 
+      # @param other [self]
+      # @param attr [::Symbol]
+      # @return [undefined]
       def choose_pin_attr(other, attr)
         # @type [Pin::Base, nil]
         val1 = send(attr)
@@ -304,6 +315,7 @@ module Solargraph
         [val1, val2].compact.min_by { _1.best_location.to_s }
       end
 
+      # @return [void]
       def assert_source_provided
         Solargraph.assert_or_log(:source, "source not provided - #{@path} #{@source} #{self.class}") if source.nil?
       end
@@ -548,6 +560,7 @@ module Solargraph
         "name=#{name.inspect} return_type=#{type_desc}, context=#{context.rooted_tags}, closure=#{closure_info}, binder=#{binder_info}"
       end
 
+      # @return [String]
       def desc
         "[#{inner_desc}]"
       end
@@ -557,6 +570,7 @@ module Solargraph
         "#<#{self.class} `#{self.inner_desc}`#{all_location_text} via #{source.inspect}>"
       end
 
+      # @return [String]
       def all_location_text
         if location.nil? && type_location.nil?
           ''
@@ -569,6 +583,7 @@ module Solargraph
         end
       end
 
+      # @return [void]
       def reset_generated!
       end
 

data/lib/solargraph/pin/method.rb

@@ -199,9 +199,11 @@ module Solargraph
             )
           end
           yield_return_type = ComplexType.try_parse(*yieldreturn_tags.flat_map(&:types))
-          block = Signature.new(generics: generics, parameters: yield_parameters, return_type: yield_return_type, source: source, closure: self)
+          block = Signature.new(generics: generics, parameters: yield_parameters, return_type: yield_return_type, source: source,
+                                closure: self, location: location, type_location: type_location)
         end
-        signature = Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block, closure: self, source: source)
+        signature = Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block, closure: self, source: source,
+                                  location: location, type_location: type_location)
         block.closure = signature if block
         signature
       end

data/lib/solargraph/rbs_map/conversions.rb

@@ -22,12 +22,14 @@ module Solargraph
         end
       end
 
+      # @param loader [RBS::EnvironmentLoader]
       def initialize(loader:)
         @loader = loader
         @pins = []
         load_environment_to_pins(loader)
       end
 
+      # @return [RBS::EnvironmentLoader]
       attr_reader :loader
 
       # @return [Array<Pin::Base>]
@@ -106,14 +108,14 @@ module Solargraph
       # @param closure [Pin::Namespace]
       # @return [void]
       def convert_members_to_pins decl, closure
-        context = Context.new
+        context = Conversions::Context.new
         decl.members.each { |m| context = convert_member_to_pin(m, closure, context) }
       end
 
       # @param member [RBS::AST::Members::Base,RBS::AST::Declarations::Base]
       # @param closure [Pin::Namespace]
       # @param context [Context]
-      # @return [void]
+      # @return [Context]
       def convert_member_to_pin member, closure, context
         case member
         when RBS::AST::Members::MethodDefinition
@@ -295,6 +297,7 @@ module Solargraph
           name: name,
           closure: closure,
           comments: decl.comment&.string,
+          type_location: location_decl_to_pin_location(decl.location),
           source: :rbs
         )
         rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
@@ -316,6 +319,7 @@ module Solargraph
       #   related overrides
       # @todo externalize remaining overrides into yaml file, then
       #   allow that to be extended via .solargraph.yml
+      # @type [Hash{Array(String, Symbol, String) => Symbol}
       VISIBILITY_OVERRIDE = {
         ["Rails::Engine", :instance, "run_tasks_blocks"] => :protected,
         # Should have been marked as both instance and class method in module -e.g., 'module_function'
@@ -340,6 +344,13 @@ module Solargraph
         ["Rainbow::Presenter", :instance, "wrap_with_sgr"] => :private,
       }
 
+      # @param decl [RBS::AST::Members::MethodDefinition, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrAccessor]
+      # @param closure [Pin::Namespace]
+      # @param context [Context]
+      # @param scope [Symbol] :instance or :class
+      # @param name [String] The name of the method
+      # @sg-ignore
+      # @return [Symbol]
       def calculate_method_visibility(decl, context, closure, scope, name)
         override_key = [closure.path, scope, name]
         visibility = VISIBILITY_OVERRIDE[override_key]
@@ -414,15 +425,16 @@ module Solargraph
       # @return [void]
       def method_def_to_sigs decl, pin
         decl.overloads.map do |overload|
+          type_location = location_decl_to_pin_location(overload.method_type.location)
           generics = overload.method_type.type_params.map(&:name).map(&:to_s)
           signature_parameters, signature_return_type = parts_of_function(overload.method_type, pin)
           block = if overload.method_type.block
                     block_parameters, block_return_type = parts_of_function(overload.method_type.block, pin)
-                    Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type,
-                                       closure: pin, source: :rbs)
+                    Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type, source: :rbs,
+                                       type_location: type_location, closure: pin)
                   end
-          Pin::Signature.new(generics: generics, parameters: signature_parameters, return_type: signature_return_type, block: block,
-                             closure: pin, source: :rbs)
+          Pin::Signature.new(generics: generics, parameters: signature_parameters, return_type: signature_return_type, block: block, source: :rbs,
+                             type_location: type_location, closure: pin)
         end
       end
 
@@ -441,44 +453,52 @@ module Solargraph
       # @param pin [Pin::Method]
       # @return [Array(Array<Pin::Parameter>, ComplexType)]
       def parts_of_function type, pin
-        return [[Solargraph::Pin::Parameter.new(decl: :restarg, name: 'arg', closure: pin, source: :rbs)], ComplexType.try_parse(method_type_to_tag(type)).force_rooted] if defined?(RBS::Types::UntypedFunction) && type.type.is_a?(RBS::Types::UntypedFunction)
+        type_location = pin.type_location
+        if defined?(RBS::Types::UntypedFunction) && type.type.is_a?(RBS::Types::UntypedFunction)
+          return [
+            [Solargraph::Pin::Parameter.new(decl: :restarg, name: 'arg', closure: pin, source: :rbs, type_location: type_location)],
+            ComplexType.try_parse(method_type_to_tag(type)).force_rooted
+          ]
+        end
 
         parameters = []
         arg_num = -1
         type.type.required_positionals.each do |param|
           name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted, source: :rbs)
+          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted, source: :rbs, type_location: type_location)
         end
         type.type.optional_positionals.each do |param|
           name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :optarg, name: name, closure: pin,
                                                          return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted,
+                                                         type_location: type_location,
                                                          source: :rbs)
         end
         if type.type.rest_positionals
           name = type.type.rest_positionals.name ? type.type.rest_positionals.name.to_s : "arg_#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :restarg, name: name, closure: pin, source: :rbs)
+          parameters.push Solargraph::Pin::Parameter.new(decl: :restarg, name: name, closure: pin, source: :rbs, type_location: type_location)
         end
         type.type.trailing_positionals.each do |param|
           name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, source: :rbs)
+          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, source: :rbs, type_location: type_location)
         end
         type.type.required_keywords.each do |orig, param|
           name = orig ? orig.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :kwarg, name: name, closure: pin,
                                                          return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted,
-                                                         source: :rbs)
+                                                         source: :rbs, type_location: type_location)
         end
         type.type.optional_keywords.each do |orig, param|
           name = orig ? orig.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :kwoptarg, name: name, closure: pin,
                                                          return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted,
+                                                         type_location: type_location,
                                                          source: :rbs)
         end
         if type.type.rest_keywords
           name = type.type.rest_keywords.name ? type.type.rest_keywords.name.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :kwrestarg, name: type.type.rest_keywords.name.to_s, closure: pin,
-                                                         source: :rbs)
+                                                         source: :rbs, type_location: type_location)
         end
 
         rooted_tag = method_type_to_tag(type)
@@ -488,6 +508,7 @@ module Solargraph
 
       # @param decl [RBS::AST::Members::AttrReader,RBS::AST::Members::AttrAccessor]
       # @param closure [Pin::Namespace]
+      # @param context [Context]
       # @return [void]
       def attr_reader_to_pin(decl, closure, context)
         name = decl.name.to_s
@@ -511,14 +532,16 @@ module Solargraph
 
       # @param decl [RBS::AST::Members::AttrWriter, RBS::AST::Members::AttrAccessor]
       # @param closure [Pin::Namespace]
+      # @param context [Context]
       # @return [void]
       def attr_writer_to_pin(decl, closure, context)
         final_scope = decl.kind == :instance ? :instance : :class
         name = "#{decl.name.to_s}="
         visibility = calculate_method_visibility(decl, context, closure, final_scope, name)
+        type_location = location_decl_to_pin_location(decl.location)
         pin = Solargraph::Pin::Method.new(
           name: name,
-          type_location: location_decl_to_pin_location(decl.location),
+          type_location: type_location,
           closure: closure,
           parameters: [],
           comments: decl.comment&.string,
@@ -532,7 +555,8 @@ module Solargraph
             name: 'value',
             return_type: ComplexType.try_parse(other_type_to_tag(decl.type)).force_rooted,
             source: :rbs,
-            closure: pin
+            closure: pin,
+            type_location: type_location
           )
         rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
         pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', rooted_tag))
@@ -541,6 +565,7 @@ module Solargraph
 
       # @param decl [RBS::AST::Members::AttrAccessor]
       # @param closure [Pin::Namespace]
+      # @param context [Context]
       # @return [void]
       def attr_accessor_to_pin(decl, closure, context)
         attr_reader_to_pin(decl, closure, context)
@@ -572,6 +597,7 @@ module Solargraph
           name: name,
           closure: closure,
           comments: decl.comment&.string,
+          type_location: location_decl_to_pin_location(decl.location),
           source: :rbs
         )
         rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
@@ -588,6 +614,7 @@ module Solargraph
           name: name,
           closure: closure,
           comments: decl.comment&.string,
+          type_location: location_decl_to_pin_location(decl.location),
           source: :rbs
         )
         rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = '0.56.1'
+  VERSION = '0.56.2'
 end

data/lib/solargraph/workspace/config.rb

@@ -151,7 +151,7 @@ module Solargraph
       # @return [Hash{String => Array, Hash, Integer}]
       def default_config
         {
-          'include' => ['**/*.rb'],
+          'include' => ['Rakefile', 'Gemfile', '*.gemspec', '**/*.rb'],
           'exclude' => ['spec/**/*', 'test/**/*', 'vendor/**/*', '.bundle/**/*'],
           'require' => [],
           'domains' => [],

data/lib/solargraph/yard_map/helpers.rb

@@ -7,10 +7,38 @@ module Solargraph
       # @param spec [Gem::Specification, nil]
       # @return [Solargraph::Location, nil]
       def object_location code_object, spec
-        return nil if spec.nil? || code_object.nil? || code_object.file.nil? || code_object.line.nil?
+        if spec.nil? || code_object.nil? || code_object.file.nil? || code_object.line.nil?
+          if code_object.namespace.is_a?(YARD::CodeObjects::NamespaceObject)
+            # If the code object is a namespace, use the namespace's location
+            return object_location(code_object.namespace, spec)
+          end
+          return Solargraph::Location.new(__FILE__, Solargraph::Range.from_to(__LINE__ - 1, 0, __LINE__ - 1, 0))
+        end
         file = File.join(spec.full_gem_path, code_object.file)
         Solargraph::Location.new(file, Solargraph::Range.from_to(code_object.line - 1, 0, code_object.line - 1, 0))
       end
+
+      # @param code_object [YARD::CodeObjects::Base]
+      # @param spec [Gem::Specification, nil]
+      # @return [Solargraph::Pin::Namespace]
+      def create_closure_namespace_for(code_object, spec)
+        code_object_for_location = code_object
+        # code_object.namespace is sometimes a YARD proxy object pointing to a method path ("Object#new")
+        code_object_for_location = code_object.namespace if code_object.namespace.is_a?(YARD::CodeObjects::NamespaceObject)
+        namespace_location = object_location(code_object_for_location, spec)
+        ns_name = code_object.namespace.to_s
+        if ns_name.empty?
+          Solargraph::Pin::ROOT_PIN
+        else
+          Solargraph::Pin::Namespace.new(
+            name: ns_name,
+            closure: Pin::ROOT_PIN,
+            gates: [code_object.namespace.to_s],
+            source: :yardoc,
+            location: namespace_location
+          )
+        end
+      end
     end
   end
 end

data/lib/solargraph/yard_map/mapper/to_constant.rb

@@ -7,12 +7,12 @@ module Solargraph
         extend YardMap::Helpers
 
         # @param code_object [YARD::CodeObjects::Base]
+        # @param closure [Pin::Closure, nil]
+        # @param spec [Gem::Specification, nil]
+        # @return [Pin::Constant]
         def self.make code_object, closure = nil, spec = nil
-          closure ||= Solargraph::Pin::Namespace.new(
-            name: code_object.namespace.to_s,
-            gates: [code_object.namespace.to_s],
-            source: :yardoc,
-          )
+          closure ||= create_closure_namespace_for(code_object, spec)
+
           Pin::Constant.new(
             location: object_location(code_object, spec),
             closure: closure,

data/lib/solargraph/yard_map/mapper/to_method.rb

@@ -19,12 +19,7 @@ module Solargraph
         # @param spec [Gem::Specification, nil]
         # @return [Solargraph::Pin::Method]
         def self.make code_object, name = nil, scope = nil, visibility = nil, closure = nil, spec = nil
-          closure ||= Solargraph::Pin::Namespace.new(
-            name: code_object.namespace.to_s,
-            gates: [code_object.namespace.to_s],
-            type: code_object.namespace.is_a?(YARD::CodeObjects::ClassObject) ? :class : :module,
-            source: :yardoc,
-          )
+          closure ||= create_closure_namespace_for(code_object, spec)
           location = object_location(code_object, spec)
           name ||= code_object.name.to_s
           return_type = ComplexType::SELF if name == 'new'

data/lib/solargraph/yard_map/mapper/to_namespace.rb

@@ -7,15 +7,15 @@ module Solargraph
         extend YardMap::Helpers
 
         # @param code_object [YARD::CodeObjects::NamespaceObject]
+        # @param spec [Gem::Specification, nil]
+        # @param closure [Pin::Closure, nil]
+        # @return [Pin::Namespace]
         def self.make code_object, spec, closure = nil
-          closure ||= Solargraph::Pin::Namespace.new(
-            name: code_object.namespace.to_s,
-            closure: Pin::ROOT_PIN,
-            gates: [code_object.namespace.to_s],
-            source: :yardoc,
-          )
+          closure ||= create_closure_namespace_for(code_object, spec)
+          location = object_location(code_object, spec)
+
           Pin::Namespace.new(
-            location: object_location(code_object, spec),
+            location: location,
             name: code_object.name.to_s,
             comments: code_object.docstring ? code_object.docstring.all.to_s : '',
             type: code_object.is_a?(YARD::CodeObjects::ClassObject) ? :class : :module,

data/lib/solargraph.rb

@@ -65,6 +65,10 @@ module Solargraph
     end
   end
 
+  # @param type [Symbol] The type of assertion to perform.
+  # @param msg [String, nil] An optional message to log
+  # @param block [Proc] A block that returns a message to log
+  # @return [void]
   def self.assert_or_log(type, msg = nil, &block)
     raise (msg || block.call) if asserts_on?(type) && ![:combine_with_visibility].include?(type)
     logger.info msg, &block
@@ -79,6 +83,11 @@ module Solargraph
 
   # A helper method that runs Bundler.with_unbundled_env or falls back to
   # Bundler.with_clean_env for earlier versions of Bundler.
+  #
+  # @generic T
+  # @yieldreturn [generic<T>]
+  # @sg-ignore dynamic call, but both functions behave the same
+  # @return [generic<T>]
   def self.with_clean_env &block
     meth = if Bundler.respond_to?(:with_original_env)
       :with_original_env
@@ -88,3 +97,7 @@ module Solargraph
     Bundler.send meth, &block
   end
 end
+
+# Ensure that ParserGem node processors are properly loaded to avoid conflicts
+# with Convention node processors
+require 'solargraph/parser/parser_gem/node_processors'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: solargraph
 version: !ruby/object:Gem::Version
-  version: 0.56.1
+  version: 0.56.2
 platform: ruby
 authors:
 - Fred Snyder
 bindir: bin
 cert_chain: []
-date: 2025-07-13 00:00:00.000000000 Z
+date: 2025-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: backport
@@ -419,6 +419,9 @@ files:
 - lib/solargraph/complex_type/unique_type.rb
 - lib/solargraph/convention.rb
 - lib/solargraph/convention/base.rb
+- lib/solargraph/convention/data_definition.rb
+- lib/solargraph/convention/data_definition/data_assignment_node.rb
+- lib/solargraph/convention/data_definition/data_definition_node.rb
 - lib/solargraph/convention/gemfile.rb
 - lib/solargraph/convention/gemspec.rb
 - lib/solargraph/convention/rakefile.rb