solargraph 0.56.0 → 0.56.2

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.0'
+  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/workspace.rb

@@ -155,6 +155,14 @@ module Solargraph
       server['commandPath'] || 'solargraph'
     end
 
+    # True if the workspace has a root Gemfile.
+    #
+    # @todo Handle projects with custom Bundler/Gemfile setups (see DocMap#gemspecs_required_from_bundler)
+    #
+    def gemfile?
+      directory && File.file?(File.join(directory, 'Gemfile'))
+    end
+
     private
 
     # The language server configuration (or an empty hash if the workspace was

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/yardoc.rb

@@ -30,6 +30,8 @@ module Solargraph
       File.exist?(yardoc)
     end
 
+    # True if another process is currently building the yardoc cache.
+    #
     def processing?(gemspec)
       yardoc = File.join(PinCache.yardoc_path(gemspec), 'processing')
       File.exist?(yardoc)

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'

data/solargraph.gemspec

@@ -35,7 +35,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'ostruct', '~> 0.6'
   s.add_runtime_dependency 'parser', '~> 3.0'
   s.add_runtime_dependency 'prism', '~> 1.4'
-  s.add_runtime_dependency 'rbs', '~> 3.3'
+  s.add_runtime_dependency 'rbs', '~> 3.6.1'
   s.add_runtime_dependency 'reverse_markdown', '~> 3.0'
   s.add_runtime_dependency 'rubocop', '~> 1.38'
   s.add_runtime_dependency 'thor', '~> 1.0'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: solargraph
 version: !ruby/object:Gem::Version
-  version: 0.56.0
+  version: 0.56.2
 platform: ruby
 authors:
 - Fred Snyder
 bindir: bin
 cert_chain: []
-date: 2025-07-01 00:00:00.000000000 Z
+date: 2025-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: backport
@@ -189,14 +189,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: 3.6.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: 3.6.1
 - !ruby/object:Gem::Dependency
   name: reverse_markdown
   requirement: !ruby/object:Gem::Requirement
@@ -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