solargraph 0.54.4 → 0.58.3

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

@@ -1,53 +1,59 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class MasgnNode < Parser::NodeProcessor::Base
-          include ParserGem::NodeMethods
-
-          def process
-            # Example:
-            #
-            # s(:masgn,
-            #   s(:mlhs,
-            #     s(:send,
-            #       s(:send, nil, :a), :b=),
-            #     s(:lvasgn, :b),
-            #     s(:ivasgn, :@c)),
-            #   s(:array,
-            #     s(:int, 1),
-            #     s(:int, 2),
-            #     s(:int, 3)))
-            masgn = node
-            mlhs = masgn.children.fetch(0)
-            lhs_arr = mlhs.children
-            mass_rhs = node.children.fetch(1)
-
-            # Get pins created for the mlhs node
-            process_children
-
-            lhs_arr.each_with_index do |lhs, i|
-              location = get_node_location(lhs)
-              pin = if lhs.type == :lvasgn
-                      # lvasgn is a local variable
-                      locals.find { |l| l.location == location }
-                    else
-                      # e.g., ivasgn is an instance variable, etc
-                      pins.find { |iv| iv.location == location && iv.is_a?(Pin::BaseVariable) }
-                    end
-              # @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}" }
-                next
-              end
-              pin.mass_assignment = [mass_rhs, i]
-            end
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class MasgnNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          # @return [void]
+          def process
+            # Example:
+            #
+            # s(:masgn,
+            #   s(:mlhs,
+            #     s(:send,
+            #       s(:send, nil, :a), :b=),
+            #     s(:lvasgn, :b),
+            #     s(:ivasgn, :@c)),
+            #   s(:array,
+            #     s(:int, 1),
+            #     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
+            process_children
+
+            lhs_arr.each_with_index do |lhs, i|
+              location = get_node_location(lhs)
+              pin = if lhs.type == :lvasgn
+                      # lvasgn is a local variable
+                      locals.find { |l| l.location == location }
+                    else
+                      # e.g., ivasgn is an instance variable, etc
+                      pins.find { |iv| iv.location == location && iv.is_a?(Pin::BaseVariable) }
+                    end
+              # @todo in line below, nothing in typechecking alerts
+              #   when a non-existant method is called on 'l'
+              if pin.nil?
+                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]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,10 +8,9 @@ module Solargraph
           include ParserGem::NodeMethods
 
           def process
-            sc = nil
-            if node.type == :class and !node.children[1].nil?
-              sc = unpack_name(node.children[1])
-            end
+            superclass_name = nil
+            superclass_name = unpack_name(node.children[1]) if node.type == :class && node.children[1]&.type == :const
+
             loc = get_node_location(node)
             nspin = Solargraph::Pin::Namespace.new(
               type: node.type,
@@ -20,14 +19,16 @@ module Solargraph
               name: unpack_name(node.children[0]),
               comments: comments_for(node),
               visibility: :public,
-              gates: region.closure.gates.freeze
+              gates: region.closure.gates.freeze,
+              source: :parser
             )
             pins.push nspin
-            unless sc.nil?
+            unless superclass_name.nil?
               pins.push Pin::Reference::Superclass.new(
                 location: loc,
                 closure: pins.last,
-                name: sc
+                name: superclass_name,
+                source: :parser
               )
             end
             process_children region.update(closure: nspin, visibility: :public)

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'parser'
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class OpasgnNode < Parser::NodeProcessor::Base
+          # @return [void]
+          def process
+            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,
+            #   s(:send,
+            #     s(:lvar, :a), :+,
+            #     s(:int, 1)))
+            # [7] pry(main)>
+            variable_reference_type = asgn.type.to_s.sub(/vasgn$/, 'var').to_sym
+            target_reference = node.updated(variable_reference_type, asgn.children)
+            send_children = [
+              target_reference,
+              operator,
+              argument
+            ]
+            send_node = node.updated(:send, send_children)
+            new_asgn = node.updated(asgn.type, [variable_name,  send_node])
+            NodeProcessor.process(new_asgn, region, pins, locals)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,16 +1,17 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class OrasgnNode < Parser::NodeProcessor::Base
-          def process
-            new_node = node.updated(node.children[0].type, node.children[0].children + [node.children[1]])
-            NodeProcessor.process(new_node, region, pins, locals)
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    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)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,36 +1,38 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class ResbodyNode < Parser::NodeProcessor::Base
-          include ParserGem::NodeMethods
-
-          def process
-            if node.children[1] # Exception local variable name
-              here = get_node_start_position(node.children[1])
-              presence = Range.new(here, region.closure.location.range.ending)
-              loc = get_node_location(node.children[1])
-              types = if node.children[0].nil?
-                        ['Exception']
-                      else
-                        node.children[0].children.map do |child|
-                          unpack_name(child)
-                        end
-                      end
-              locals.push Solargraph::Pin::LocalVariable.new(
-                location: loc,
-                closure: region.closure,
-                name: node.children[1].children[0].to_s,
-                comments: "@type [#{types.join(',')}]",
-                presence: presence
-              )
-            end
-            NodeProcessor.process(node.children[2], region, pins, locals)
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        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])
+              presence = Range.new(here, region.closure.location.range.ending)
+              loc = get_node_location(node.children[1])
+              types = if node.children[0].nil?
+                        ['Exception']
+                      else
+                        node.children[0].children.map do |child|
+                          unpack_name(child)
+                        end
+                      end
+              locals.push Solargraph::Pin::LocalVariable.new(
+                location: loc,
+                closure: region.closure,
+                name: node.children[1].children[0].to_s,
+                comments: "@type [#{types.join(',')}]",
+                presence: presence,
+                source: :parser
+              )
+            end
+            NodeProcessor.process(node.children[2], region, pins, locals)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,42 +1,52 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class SclassNode < Parser::NodeProcessor::Base
-          def process
-            sclass = node.children[0]
-            if sclass.is_a?(AST::Node) && sclass.type == :self
-              closure = region.closure
-            elsif sclass.is_a?(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
-              else
-                names.concat [NodeMethods.unpack_name(sclass.children[0]), sclass.children[1].to_s]
-              end
-              name = names.reject(&:empty?).join('::')
-              closure = Solargraph::Pin::Namespace.new(name: name, location: region.closure.location)
-            elsif sclass.is_a?(AST::Node) && sclass.type == :const
-              names = [region.closure.namespace, region.closure.name]
-              also = NodeMethods.unpack_name(sclass)
-              if also != region.closure.name
-                names << also
-              end
-              name = names.reject(&:empty?).join('::')
-              closure = Solargraph::Pin::Namespace.new(name: name, location: region.closure.location)
-            else
-              return
-            end
-            pins.push Solargraph::Pin::Singleton.new(
-              location: get_node_location(node),
-              closure: closure
-            )
-            process_children region.update(visibility: :public, scope: :class, closure: pins.last)
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class SclassNode < Parser::NodeProcessor::Base
+          def process
+            sclass = node.children[0]
+            # @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?(::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
+              else
+                names.concat [NodeMethods.unpack_name(sclass.children[0]), sclass.children[1].to_s]
+              end
+              name = names.reject(&:empty?).join('::')
+              closure = Solargraph::Pin::Namespace.new(name: name, location: region.closure.location, source: :parser)
+            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
+                names << also
+              end
+              name = names.reject(&:empty?).join('::')
+              closure = Solargraph::Pin::Namespace.new(name: name, location: region.closure.location, source: :parser)
+            else
+              return
+            end
+            pins.push Solargraph::Pin::Singleton.new(
+              location: get_node_location(node),
+              closure: closure,
+              source: :parser,
+            )
+            process_children region.update(visibility: :public, scope: :class, closure: pins.last)
+          end
+        end
+      end
+    end
+  end
+end