solargraph 0.56.0 → 0.58.1

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

@@ -13,7 +13,7 @@ module Solargraph
         # @return [Array<Pin::Base>]
         attr_reader :pins
 
-        # @return [Array<Pin::BaseVariable>]
+        # @return [Array<Pin::LocalVariable>]
         attr_reader :locals
 
         # @param node [Parser::AST::Node]
@@ -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,26 @@ 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>]
+        # @return [Array<Class<NodeProcessor::Base>>]
         def register type, cls
-          @@processors[type] = cls
+          @@processors[type] ||= []
+          @@processors[type] << cls
+        end
+
+        # @param type [Symbol]
+        # @param cls [Class<NodeProcessor::Base>]
+        #
+        # @return [void]
+        def deregister type, cls
+          @@processors[type].delete(cls)
         end
       end
 
@@ -36,10 +46,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/class_methods.rb

@@ -2,22 +2,13 @@
 
 require 'prism'
 
-# Awaiting ability to use a version containing https://github.com/whitequark/parser/pull/1076
-#
-# @!parse
-#   class ::Parser::Base < ::Parser::Builder
-#     # @return [Integer]
-#     def version; end
-#   end
-#   class ::Parser::CurrentRuby < ::Parser::Base; end
-
 module Solargraph
   module Parser
     module ParserGem
       module ClassMethods
         # @param code [String]
         # @param filename [String, nil]
-        # @return [Array(Parser::AST::Node, Hash{Integer => String})]
+        # @return [Array(Parser::AST::Node, Hash{Integer => Solargraph::Parser::Snippet})]
         def parse_with_comments code, filename = nil
           node = parse(code, filename)
           comments = CommentRipper.new(code, filename, 0).parse
@@ -84,6 +75,7 @@ module Solargraph
         # @param top [AST::Node]
         # @return [Array<AST::Node>]
         def inner_node_references name, top
+          # @type [Array<AST::Node>]
           result = []
           if top.is_a?(AST::Node) && top.to_s.include?(":#{name}")
             result.push top if top.children.any? { |c| c.to_s == name }
@@ -137,9 +129,7 @@ module Solargraph
         def string_ranges node
           return [] unless is_ast_node?(node)
           result = []
-          if node.type == :str
-            result.push Range.from_node(node)
-          end
+          result.push Range.from_node(node) if node.type == :str
           node.children.each do |child|
             result.concat string_ranges(child)
           end

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

@@ -9,6 +9,7 @@ module Solargraph
       class FlawedBuilder < ::Parser::Builders::Default
         # @param token [::Parser::AST::Node]
         # @return [String]
+        # @sg-ignore
         def string_value(token)
           value(token)
         end

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

@@ -7,6 +7,7 @@ module Solargraph
       #
       class NodeChainer
         include NodeMethods
+
         Chain = Source::Chain
 
         # @param node [Parser::AST::Node]
@@ -98,7 +99,8 @@ module Solargraph
           elsif [:gvar, :gvasgn].include?(n.type)
             result.push Chain::GlobalVariable.new(n.children[0].to_s)
           elsif n.type == :or_asgn
-            result.concat generate_links n.children[1]
+            new_node = n.updated(n.children[0].type, n.children[0].children + [n.children[1]])
+            result.concat generate_links new_node
           elsif [:class, :module, :def, :defs].include?(n.type)
             # @todo Undefined or what?
             result.push Chain::UNDEFINED_CALL

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

@@ -3,20 +3,6 @@
 require 'parser'
 require 'ast'
 
-# Teach AST::Node#children about its generic type
-#
-# @todo contribute back to https://github.com/ruby/gem_rbs_collection/blob/main/gems/ast/2.4/ast.rbs
-#
-# @!parse
-#   module ::AST
-#     class Node
-#       # New children
-#
-#       # @return [Array<self, Integer, String, Symbol, nil>]
-#       attr_reader :children
-#     end
-#   end
-
 # https://github.com/whitequark/parser
 module Solargraph
   module Parser
@@ -120,7 +106,7 @@ module Solargraph
         end
 
         # @param node [Parser::AST::Node]
-        # @return [Hash{Parser::AST::Node => Chain}]
+        # @return [Hash{Symbol => Chain}]
         def convert_hash node
           return {} unless Parser.is_ast_node?(node)
           return convert_hash(node.children[0]) if node.type == :kwsplat
@@ -133,6 +119,7 @@ module Solargraph
           result
         end
 
+        # @sg-ignore Wrong argument type for AST::Node.new: type expected AST::_ToSym, received :nil
         NIL_NODE = ::Parser::AST::Node.new(:nil)
 
         # @param node [Parser::AST::Node]
@@ -179,6 +166,7 @@ module Solargraph
             node.children[1..-1].each { |child| result.concat call_nodes_from(child) }
           elsif node.type == :send
             result.push node
+            result.concat call_nodes_from(node.children.first)
             node.children[2..-1].each { |child| result.concat call_nodes_from(child) }
           elsif [:super, :zsuper].include?(node.type)
             result.push node
@@ -232,6 +220,7 @@ module Solargraph
           else
             source.tree_at(position.line, position.column - 1)
           end
+          # @type [AST::Node, nil]
           prev = nil
           tree.each do |node|
             if node.type == :send
@@ -242,7 +231,7 @@ module Solargraph
                 if source.synchronized?
                   return node if source.code[0..offset-1] =~ /\(\s*\z/ && source.code[offset..-1] =~ /^\s*\)/
                 else
-                  return node if source.code[0..offset-1] =~ /\([^\(]*\z/
+                  return node if source.code[0..offset-1] =~ /\([^(]*\z/
                 end
               end
             end

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

@@ -11,6 +11,7 @@ module Solargraph
             process_children
 
             position = get_node_start_position(node)
+            # @sg-ignore https://github.com/castwide/solargraph/pull/1114
             enclosing_breakable_pin = pins.select{|pin| pin.is_a?(Pin::Breakable) && pin.location.range.contain?(position)}.last
             FlowSensitiveTyping.new(locals, enclosing_breakable_pin).process_and(node)
           end

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

@@ -19,7 +19,7 @@ module Solargraph
             else
               region.closure
             end
-            pins.push Solargraph::Pin::Block.new(
+            block_pin = Solargraph::Pin::Block.new(
               location: location,
               closure: parent,
               node: node,
@@ -28,7 +28,8 @@ module Solargraph
               scope: region.scope || region.closure.context.scope,
               source: :parser
             )
-            process_children region.update(closure: pins.last)
+            pins.push block_pin
+            process_children region.update(closure: block_pin)
           end
 
           private

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

@@ -11,6 +11,8 @@ module Solargraph
             process_children
 
             position = get_node_start_position(node)
+            # @sg-ignore
+            # @type [Solargraph::Pin::Breakable, nil]
             enclosing_breakable_pin = pins.select{|pin| pin.is_a?(Pin::Breakable) && pin.location.range.contain?(position)}.last
             FlowSensitiveTyping.new(locals, enclosing_breakable_pin).process_if(node)
           end

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:
             #
@@ -21,8 +22,11 @@ module Solargraph
             #     s(:int, 2),
             #     s(:int, 3)))
             masgn = node
+            # @type [Parser::AST::Node]
             mlhs = masgn.children.fetch(0)
+            # @type [Array<Parser::AST::Node>]
             lhs_arr = mlhs.children
+            # @type [Parser::AST::Node]
             mass_rhs = node.children.fetch(1)
 
             # Get pins created for the mlhs node
@@ -40,7 +44,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,15 +7,72 @@ module Solargraph
     module ParserGem
       module NodeProcessors
         class OpasgnNode < Parser::NodeProcessor::Base
+          # @return [void]
           def process
-            # Parser::CurrentRuby.parse("a += 2")
-            # => s(:op_asgn,
-            #      s(:lvasgn, :a), :+,
-            #      s(:int, 2))
-            asgn = node.children[0]
-            variable_name = asgn.children[0]
+            target = node.children[0]
             operator = node.children[1]
             argument = node.children[2]
+            if target.type == :send
+              # @sg-ignore Need a downcast here
+              process_send_target(target, operator, argument)
+            elsif target.type.to_s.end_with?('vasgn')
+              # @sg-ignore Need a downcast here
+              process_vasgn_target(target, operator, argument)
+            else
+              Solargraph.assert_or_log(:opasgn_unknown_target,
+                                       "Unexpected op_asgn target type: #{target.type}")
+            end
+          end
+
+          # @param call [Parser::AST::Node] the target of the assignment
+          # @param operator [Symbol] the operator, e.g. :+
+          # @param argument [Parser::AST::Node] the argument of the operation
+          #
+          # @return [void]
+          def process_send_target call, operator, argument
+            # if target is a call:
+            # [10] pry(main)> Parser::CurrentRuby.parse("Foo.bar += baz")
+            # => s(:op_asgn,
+            #      s(:send, # call
+            #        s(:const, nil, :Foo), # calee
+            #        :bar), # call_method
+            #      :+, # operator
+            #      s(:send, nil, :baz)) # argument
+            # [11] pry(main)>
+            callee = call.children[0]
+            call_method = call.children[1]
+            asgn_method = :"#{call_method}="
+
+            # [8] pry(main)> Parser::CurrentRuby.parse("Foo.bar = Foo.bar + baz")
+            # => s(:send,
+            #       s(:const, nil, :Foo), # callee
+            #       :bar=, # asgn_method
+            #        s(:send,
+            #          s(:send,
+            #             s(:const, nil, :Foo), # callee
+            #             :bar), # call_method
+            #          :+, # operator
+            #          s(:send, nil, :baz))) # argument
+            new_send = node.updated(:send,
+                                    [callee,
+                                     asgn_method,
+                                     node.updated(:send, [call, operator, argument])])
+            NodeProcessor.process(new_send, region, pins, locals)
+          end
+
+          # @param asgn [Parser::AST::Node] the target of the assignment
+          # @param operator [Symbol] the operator, e.g. :+
+          # @param argument [Parser::AST::Node] the argument of the operation
+          #
+          # @return [void]
+          def process_vasgn_target asgn, operator, argument
+            # => s(:op_asgn,
+            #      s(:lvasgn, :a), # asgn
+            #      :+, # operator
+            #      s(:int, 2)) # argument
+
+            # @type [Parser::AST::Node]
+            variable_name = asgn.children[0]
             # for lvasgn, gvasgn, cvasgn, convert to lvar, gvar, cvar
             # [6] pry(main)> Parser::CurrentRuby.parse("a = a + 1")
             # => s(:lvasgn, :a,
@@ -24,9 +81,9 @@ module Solargraph
             #     s(:int, 1)))
             # [7] pry(main)>
             variable_reference_type = asgn.type.to_s.sub(/vasgn$/, 'var').to_sym
-            variable_reference = node.updated(variable_reference_type, asgn.children)
+            target_reference = node.updated(variable_reference_type, asgn.children)
             send_children = [
-              variable_reference,
+              target_reference,
               operator,
               argument
             ]

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

@@ -7,9 +7,18 @@ module Solargraph
         class SclassNode < Parser::NodeProcessor::Base
           def process
             sclass = node.children[0]
-            if sclass.is_a?(AST::Node) && sclass.type == :self
+            # @todo Changing Parser::AST::Node to AST::Node below will
+            #   cause type errors at strong level because the combined
+            #   pin for AST::Node#children has return type
+            #   "Array<AST::Node>, Array".  YARD annotations in AST
+            #   provided the Array, RBS for Array<AST::Node>.  We
+            #   should probably have a rule to combine "A, A<T>""
+            #   types to "A<T>" if the "A" comes from YARD, with the
+            #   rationale that folks tend to be less formal with types in
+            #   YARD.
+            if sclass.is_a?(::Parser::AST::Node) && sclass.type == :self
               closure = region.closure
-            elsif sclass.is_a?(AST::Node) && sclass.type == :casgn
+            elsif sclass.is_a?(::Parser::AST::Node) && sclass.type == :casgn
               names = [region.closure.namespace, region.closure.name]
               if sclass.children[0].nil? && names.last != sclass.children[1].to_s
                 names << sclass.children[1].to_s
@@ -18,7 +27,7 @@ module Solargraph
               end
               name = names.reject(&:empty?).join('::')
               closure = Solargraph::Pin::Namespace.new(name: name, location: region.closure.location, source: :parser)
-            elsif sclass.is_a?(AST::Node) && sclass.type == :const
+            elsif sclass.is_a?(::Parser::AST::Node) && sclass.type == :const
               names = [region.closure.namespace, region.closure.name]
               also = NodeMethods.unpack_name(sclass)
               if also != region.closure.name

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

@@ -8,32 +8,41 @@ module Solargraph
           include ParserGem::NodeMethods
 
           def process
+            # @sg-ignore Variable type could not be inferred for method_name
+            # @type [Symbol]
+            method_name = node.children[1]
+            # :nocov:
+            unless method_name.instance_of?(Symbol)
+              Solargraph.assert_or_log(:parser_method_name, "Expected method name to be a Symbol, got #{method_name.class} for node #{node.inspect}")
+              return process_children
+            end
+            # :nocov:
             if node.children[0].nil?
-              if [:private, :public, :protected].include?(node.children[1])
+              if [:private, :public, :protected].include?(method_name)
                 process_visibility
-              elsif node.children[1] == :module_function
+              elsif method_name == :module_function
                 process_module_function
-              elsif [:attr_reader, :attr_writer, :attr_accessor].include?(node.children[1])
+              elsif [:attr_reader, :attr_writer, :attr_accessor].include?(method_name)
                 process_attribute
-              elsif node.children[1] == :include
+              elsif method_name == :include
                 process_include
-              elsif node.children[1] == :extend
+              elsif method_name == :extend
                 process_extend
-              elsif node.children[1] == :prepend
+              elsif method_name == :prepend
                 process_prepend
-              elsif node.children[1] == :require
+              elsif method_name == :require
                 process_require
-              elsif node.children[1] == :autoload
+              elsif method_name == :autoload
                 process_autoload
-              elsif node.children[1] == :private_constant
+              elsif method_name == :private_constant
                 process_private_constant
-              elsif node.children[1] == :alias_method && node.children[2] && node.children[2] && node.children[2].type == :sym && node.children[3] && node.children[3].type == :sym
+              elsif method_name == :alias_method && node.children[2] && node.children[2] && node.children[2].type == :sym && node.children[3] && node.children[3].type == :sym
                 process_alias_method
-              elsif node.children[1] == :private_class_method && node.children[2].is_a?(AST::Node)
+              elsif method_name == :private_class_method && node.children[2].is_a?(AST::Node)
                 # Processing a private class can potentially handle children on its own
                 return if process_private_class_method
               end
-            elsif node.children[1] == :require && node.children[0].to_s == '(const nil :Bundler)'
+            elsif method_name == :require && node.children[0].to_s == '(const nil :Bundler)'
               pins.push Pin::Reference::Require.new(Solargraph::Location.new(region.filename, Solargraph::Range.from_to(0, 0, 0, 0)), 'bundler/require', source: :parser)
             end
             process_children
@@ -45,15 +54,24 @@ module Solargraph
           def process_visibility
             if (node.children.length > 2)
               node.children[2..-1].each do |child|
-                if child.is_a?(AST::Node) && (child.type == :sym || child.type == :str)
+                # @sg-ignore Variable type could not be inferred for method_name
+                # @type [Symbol]
+                visibility = node.children[1]
+                # :nocov:
+                unless visibility.instance_of?(Symbol)
+                  Solargraph.assert_or_log(:parser_visibility, "Expected visibility name to be a Symbol, got #{visibility.class} for node #{node.inspect}")
+                  return process_children
+                end
+                # :nocov:
+                if child.is_a?(::Parser::AST::Node) && (child.type == :sym || child.type == :str)
                   name = child.children[0].to_s
                   matches = pins.select{ |pin| pin.is_a?(Pin::Method) && pin.name == name && pin.namespace == region.closure.full_context.namespace && pin.context.scope == (region.scope || :instance)}
                   matches.each do |pin|
                     # @todo Smelly instance variable access
-                    pin.instance_variable_set(:@visibility, node.children[1])
+                    pin.instance_variable_set(:@visibility, visibility)
                   end
                 else
-                  process_children region.update(visibility: node.children[1])
+                  process_children region.update(visibility: visibility)
                 end
               end
             else
@@ -177,7 +195,7 @@ module Solargraph
             elsif node.children[2].type == :sym || node.children[2].type == :str
               node.children[2..-1].each do |x|
                 cn = x.children[0].to_s
-                # @type [Pin::Method]
+                # @type [Pin::Method, nil]
                 ref = pins.find { |p| p.is_a?(Pin::Method) && p.namespace == region.closure.full_context.namespace && p.name == cn }
                 unless ref.nil?
                   pins.delete ref
@@ -210,6 +228,7 @@ module Solargraph
                       closure: cm,
                       name: ivar.name,
                       comments: ivar.comments,
+                      # @sg-ignore https://github.com/castwide/solargraph/pull/1114
                       assignment: ivar.assignment,
                       source: :parser
                     )
@@ -218,6 +237,7 @@ module Solargraph
                       closure: mm,
                       name: ivar.name,
                       comments: ivar.comments,
+                      # @sg-ignore https://github.com/castwide/solargraph/pull/1114
                       assignment: ivar.assignment,
                       source: :parser
                     )

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