solargraph 0.58.0 → 0.59.0.dev.1

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

@@ -1,59 +1,61 @@
-# 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
+# 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 }
+                    elsif lhs.type == :ivasgn
+                      # ivasgn is an instance variable assignment
+                      ivars.find { |iv| iv.location == location }
+                    else
+                      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/opasgn_node.rb

@@ -1,98 +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
+# 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, ivars)
+          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, ivars)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class OrNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            process_children
+
+            FlowSensitiveTyping.new(locals,
+                                    ivars,
+                                    enclosing_breakable_pin,
+                                    enclosing_compound_statement_pin).process_or(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,17 +1,17 @@
-# 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
+# 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, ivars)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,38 +1,39 @@
-# 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
+# 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])
+              # @sg-ignore Need to add nil check here
+              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, ivars)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,52 +1,53 @@
-# 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
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class SclassNode < Parser::NodeProcessor::Base
+          # @sg-ignore @override is adding, not overriding
+          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