solargraph 0.58.2 → 0.59.0.dev.2

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

@@ -9,7 +9,7 @@ module Solargraph
 
           def process
             loc = get_node_location(node)
-            pins.push Solargraph::Pin::InstanceVariable.new(
+            ivars.push Solargraph::Pin::InstanceVariable.new(
               location: loc,
               closure: region.closure,
               name: node.children[0].to_s,
@@ -19,11 +19,13 @@ module Solargraph
             )
             if region.visibility == :module_function
               here = get_node_start_position(node)
+              # @type [Pin::Closure, nil]
               named_path = named_path_pin(here)
               if named_path.is_a?(Pin::Method)
-                pins.push Solargraph::Pin::InstanceVariable.new(
+                ivars.push Solargraph::Pin::InstanceVariable.new(
                   location: loc,
-                  closure: Pin::Namespace.new(type: :module, closure: region.closure.closure, name: region.closure.name),
+                  closure: Pin::Namespace.new(type: :module, closure: region.closure.closure,
+                                              name: region.closure.name),
                   name: node.children[0].to_s,
                   comments: comments_for(node),
                   assignment: node.children[1],

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

@@ -9,6 +9,7 @@ module Solargraph
 
           def process
             here = get_node_start_position(node)
+            # @sg-ignore Need to add nil check here
             presence = Range.new(here, region.closure.location.range.ending)
             loc = get_node_location(node)
             locals.push Solargraph::Pin::LocalVariable.new(

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

@@ -37,8 +37,10 @@ module Solargraph
               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
-                      # 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

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

@@ -57,7 +57,7 @@ module Solargraph
                                     [callee,
                                      asgn_method,
                                      node.updated(:send, [call, operator, argument])])
-            NodeProcessor.process(new_send, region, pins, locals)
+            NodeProcessor.process(new_send, region, pins, locals, ivars)
           end
 
           # @param asgn [Parser::AST::Node] the target of the assignment
@@ -88,8 +88,8 @@ module Solargraph
               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)
+            new_asgn = node.updated(asgn.type, [variable_name, send_node])
+            NodeProcessor.process(new_asgn, region, pins, locals, ivars)
           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

@@ -8,7 +8,7 @@ module Solargraph
           # @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)
+            NodeProcessor.process(new_node, region, pins, locals, ivars)
           end
         end
       end

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

@@ -11,6 +11,7 @@ module Solargraph
           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?
@@ -29,7 +30,7 @@ module Solargraph
                 source: :parser
               )
             end
-            NodeProcessor.process(node.children[2], region, pins, locals)
+            NodeProcessor.process(node.children[2], region, pins, locals, ivars)
           end
         end
       end

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

@@ -5,6 +5,7 @@ module Solargraph
     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
@@ -23,16 +24,14 @@ module Solargraph
               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]
+                names.push 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
+              names << also if also != region.closure.name
               name = names.reject(&:empty?).join('::')
               closure = Solargraph::Pin::Namespace.new(name: name, location: region.closure.location, source: :parser)
             else
@@ -41,7 +40,7 @@ module Solargraph
             pins.push Solargraph::Pin::Singleton.new(
               location: get_node_location(node),
               closure: closure,
-              source: :parser,
+              source: :parser
             )
             process_children region.update(visibility: :public, scope: :class, closure: pins.last)
           end

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

@@ -7,22 +7,24 @@ module Solargraph
         class SendNode < Parser::NodeProcessor::Base
           include ParserGem::NodeMethods
 
+          # @sg-ignore @override is adding, not overriding
           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}")
+              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?(method_name)
+              if %i[private public protected].include?(method_name)
                 process_visibility
               elsif method_name == :module_function
                 process_module_function
-              elsif [:attr_reader, :attr_writer, :attr_accessor].include?(method_name)
+              elsif %i[attr_reader attr_writer attr_accessor].include?(method_name)
                 process_attribute
               elsif method_name == :include
                 process_include
@@ -43,7 +45,10 @@ module Solargraph
                 return if process_private_class_method
               end
             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)
+              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
           end
@@ -52,20 +57,22 @@ module Solargraph
 
           # @return [void]
           def process_visibility
-            if (node.children.length > 2)
-              node.children[2..-1].each do |child|
+            if node.children.length > 2
+              # @sg-ignore Need to add nil check here
+              node.children[2..].each do |child|
                 # @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}")
+                  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)
+                if child.is_a?(::Parser::AST::Node) && %i[sym str].include?(child.type)
                   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 = 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, visibility)
@@ -82,11 +89,12 @@ module Solargraph
 
           # @return [void]
           def process_attribute
-            node.children[2..-1].each do |a|
+            # @sg-ignore Need to add nil check here
+            node.children[2..].each do |a|
               loc = get_node_location(node)
               clos = region.closure
               cmnt = comments_for(node)
-              if node.children[1] == :attr_reader || node.children[1] == :attr_accessor
+              if %i[attr_reader attr_accessor].include?(node.children[1])
                 pins.push Solargraph::Pin::Method.new(
                   location: loc,
                   closure: clos,
@@ -98,60 +106,62 @@ module Solargraph
                   source: :parser
                 )
               end
-              if node.children[1] == :attr_writer || node.children[1] == :attr_accessor
-                method_pin = Solargraph::Pin::Method.new(
-                  location: loc,
-                  closure: clos,
-                  name: "#{a.children[0]}=",
-                  comments: cmnt,
-                  scope: region.scope || :instance,
-                  visibility: region.visibility,
-                  attribute: true,
-                  source: :parser
-                )
-                pins.push method_pin
-                method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last, source: :parser)
-                if method_pin.return_type.defined?
-                  pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.items.map(&:rooted_tags), 'value')
-                end
+              next unless %i[attr_writer attr_accessor].include?(node.children[1])
+              method_pin = Solargraph::Pin::Method.new(
+                location: loc,
+                closure: clos,
+                name: "#{a.children[0]}=",
+                comments: cmnt,
+                scope: region.scope || :instance,
+                visibility: region.visibility,
+                attribute: true,
+                source: :parser
+              )
+              pins.push method_pin
+              method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last,
+                                                            source: :parser)
+              if method_pin.return_type.defined?
+                pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '',
+                                                                pins.last.return_type.items.map(&:rooted_tags), 'value')
               end
             end
           end
 
           # @return [void]
           def process_include
-            if node.children[2].is_a?(AST::Node) && node.children[2].type == :const
-              cp = region.closure
-              node.children[2..-1].each do |i|
-                type = region.scope == :class ? Pin::Reference::Extend : Pin::Reference::Include
-                pins.push type.new(
-                  location: get_node_location(i),
-                  closure: cp,
-                  name: unpack_name(i),
-                  source: :parser
-                )
-              end
+            return unless node.children[2].is_a?(AST::Node) && node.children[2].type == :const
+            cp = region.closure
+            # @sg-ignore Need to add nil check here
+            node.children[2..].each do |i|
+              type = region.scope == :class ? Pin::Reference::Extend : Pin::Reference::Include
+              pins.push type.new(
+                location: get_node_location(i),
+                closure: cp,
+                name: unpack_name(i),
+                source: :parser
+              )
             end
           end
 
           # @return [void]
           def process_prepend
-            if node.children[2].is_a?(AST::Node) && node.children[2].type == :const
-              cp = region.closure
-              node.children[2..-1].each do |i|
-                pins.push Pin::Reference::Prepend.new(
-                  location: get_node_location(i),
-                  closure: cp,
-                  name: unpack_name(i),
-                  source: :parser
-                )
-              end
+            return unless node.children[2].is_a?(AST::Node) && node.children[2].type == :const
+            cp = region.closure
+            # @sg-ignore Need to add nil check here
+            node.children[2..].each do |i|
+              pins.push Pin::Reference::Prepend.new(
+                location: get_node_location(i),
+                closure: cp,
+                name: unpack_name(i),
+                source: :parser
+              )
             end
           end
 
           # @return [void]
           def process_extend
-            node.children[2..-1].each do |i|
+            # @sg-ignore Need to add nil check here
+            node.children[2..].each do |i|
               loc = get_node_location(node)
               if i.type == :self
                 pins.push Pin::Reference::Extend.new(
@@ -173,18 +183,16 @@ module Solargraph
 
           # @return [void]
           def process_require
-            if node.children[2].is_a?(AST::Node) && node.children[2].type == :str
-              path = node.children[2].children[0].to_s
-              pins.push Pin::Reference::Require.new(get_node_location(node), path, source: :parser)
-            end
+            return unless node.children[2].is_a?(AST::Node) && node.children[2].type == :str
+            path = node.children[2].children[0].to_s
+            pins.push Pin::Reference::Require.new(get_node_location(node), path, source: :parser)
           end
 
           # @return [void]
           def process_autoload
-            if node.children[3].is_a?(AST::Node) && node.children[3].type == :str
-              path = node.children[3].children[0].to_s
-              pins.push Pin::Reference::Require.new(get_node_location(node), path, source: :parser)
-            end
+            return unless node.children[3].is_a?(AST::Node) && node.children[3].type == :str
+            path = node.children[3].children[0].to_s
+            pins.push Pin::Reference::Require.new(get_node_location(node), path, source: :parser)
           end
 
           # @return [void]
@@ -192,76 +200,77 @@ module Solargraph
             if node.children[2].nil?
               # @todo Smelly instance variable access
               region.instance_variable_set(:@visibility, :module_function)
-            elsif node.children[2].type == :sym || node.children[2].type == :str
-              node.children[2..-1].each do |x|
+            elsif %i[sym str].include?(node.children[2].type)
+              # @sg-ignore Need to add nil check here
+              node.children[2..].each do |x|
                 cn = x.children[0].to_s
                 # @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
-                  mm = Solargraph::Pin::Method.new(
-                    location: ref.location,
-                    closure: ref.closure,
-                    name: ref.name,
-                    parameters: ref.parameters,
-                    comments: ref.comments,
-                    scope: :class,
-                    visibility: :public,
-                    node: ref.node,
+                next if ref.nil?
+                pins.delete ref
+                mm = Solargraph::Pin::Method.new(
+                  location: ref.location,
+                  closure: ref.closure,
+                  name: ref.name,
+                  parameters: ref.parameters,
+                  comments: ref.comments,
+                  scope: :class,
+                  visibility: :public,
+                  node: ref.node,
+                  source: :parser
+                )
+                cm = Solargraph::Pin::Method.new(
+                  location: ref.location,
+                  closure: ref.closure,
+                  name: ref.name,
+                  parameters: ref.parameters,
+                  comments: ref.comments,
+                  scope: :instance,
+                  visibility: :private,
+                  node: ref.node,
+                  source: :parser
+                )
+                pins.push mm, cm
+                ivars.select { |pin| pin.is_a?(Pin::InstanceVariable) && pin.closure.path == ref.path }.each do |ivar|
+                  ivars.delete ivar
+                  ivars.push Solargraph::Pin::InstanceVariable.new(
+                    location: ivar.location,
+                    closure: cm,
+                    name: ivar.name,
+                    comments: ivar.comments,
+                    assignment: ivar.assignment,
+                    source: :parser
+                  )
+                  ivars.push Solargraph::Pin::InstanceVariable.new(
+                    location: ivar.location,
+                    closure: mm,
+                    name: ivar.name,
+                    comments: ivar.comments,
+                    assignment: ivar.assignment,
                     source: :parser
                   )
-                  cm = Solargraph::Pin::Method.new(
-                    location: ref.location,
-                    closure: ref.closure,
-                    name: ref.name,
-                    parameters: ref.parameters,
-                    comments: ref.comments,
-                    scope: :instance,
-                    visibility: :private,
-                    node: ref.node,
-                    source: :parser)
-                  pins.push mm, cm
-                  pins.select{|pin| pin.is_a?(Pin::InstanceVariable) && pin.closure.path == ref.path}.each do |ivar|
-                    pins.delete ivar
-                    pins.push Solargraph::Pin::InstanceVariable.new(
-                      location: ivar.location,
-                      closure: cm,
-                      name: ivar.name,
-                      comments: ivar.comments,
-                      # @sg-ignore https://github.com/castwide/solargraph/pull/1114
-                      assignment: ivar.assignment,
-                      source: :parser
-                    )
-                    pins.push Solargraph::Pin::InstanceVariable.new(
-                      location: ivar.location,
-                      closure: mm,
-                      name: ivar.name,
-                      comments: ivar.comments,
-                      # @sg-ignore https://github.com/castwide/solargraph/pull/1114
-                      assignment: ivar.assignment,
-                      source: :parser
-                    )
-                  end
                 end
               end
             elsif node.children[2].type == :def
-              NodeProcessor.process node.children[2], region.update(visibility: :module_function), pins, locals
+              NodeProcessor.process node.children[2], region.update(visibility: :module_function), pins, locals, ivars
             end
           end
 
           # @return [void]
           def process_private_constant
-            if node.children[2] && (node.children[2].type == :sym || node.children[2].type == :str)
-              cn = node.children[2].children[0].to_s
-              ref = pins.select{|p| [Solargraph::Pin::Namespace, Solargraph::Pin::Constant].include?(p.class) && p.namespace == region.closure.full_context.namespace && p.name == cn}.first
-              # HACK: Smelly instance variable access
-              ref.instance_variable_set(:@visibility, :private) unless ref.nil?
-            end
+            return unless node.children[2] && %i[sym str].include?(node.children[2].type)
+            cn = node.children[2].children[0].to_s
+            ref = pins.select do |p|
+              [Solargraph::Pin::Namespace,
+               Solargraph::Pin::Constant].include?(p.class) && p.namespace == region.closure.full_context.namespace && p.name == cn
+            end.first
+            # HACK: Smelly instance variable access
+            ref&.instance_variable_set(:@visibility, :private)
           end
 
           # @return [void]
           def process_alias_method
-            loc = get_node_location(node)
+            get_node_location(node)
             pins.push Solargraph::Pin::MethodAlias.new(
               location: get_node_location(node),
               closure: region.closure,
@@ -274,10 +283,12 @@ module Solargraph
 
           # @return [Boolean]
           def process_private_class_method
-            if node.children[2].type == :sym || node.children[2].type == :str
-              ref = pins.select { |p| p.is_a?(Pin::Method) && p.namespace == region.closure.full_context.namespace && p.name == node.children[2].children[0].to_s }.first
+            if %i[sym str].include?(node.children[2].type)
+              ref = pins.select do |p|
+                p.is_a?(Pin::Method) && p.namespace == region.closure.full_context.namespace && p.name == node.children[2].children[0].to_s
+              end.first
               # HACK: Smelly instance variable access
-              ref.instance_variable_set(:@visibility, :private) unless ref.nil?
+              ref&.instance_variable_set(:@visibility, :private)
               false
             else
               process_children region.update(scope: :class, visibility: :private)

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

@@ -1,29 +1,29 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class UntilNode < Parser::NodeProcessor::Base
-          include ParserGem::NodeMethods
-
-          def process
-            location = get_node_location(node)
-            # Note - this should not be considered a block, as the
-            # until statement doesn't create a closure - e.g.,
-            # variables created inside can be seen from outside as
-            # well
-            pins.push Solargraph::Pin::Until.new(
-              location: location,
-              closure: region.closure,
-              node: node,
-              comments: comments_for(node),
-              source: :parser,
-            )
-            process_children region
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class UntilNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            location = get_node_location(node)
+            # Note - this should not be considered a block, as the
+            # until statement doesn't create a closure - e.g.,
+            # variables created inside can be seen from outside as
+            # well
+            pins.push Solargraph::Pin::Until.new(
+              location: location,
+              closure: region.closure,
+              node: node,
+              comments: comments_for(node),
+              source: :parser
+            )
+            process_children region
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class WhenNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            pins.push Solargraph::Pin::CompoundStatement.new(
+              location: get_node_location(node),
+              closure: region.closure,
+              node: node,
+              source: :parser
+            )
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,7 +8,11 @@ module Solargraph
           include ParserGem::NodeMethods
 
           def process
-            location = get_node_location(node)
+            FlowSensitiveTyping.new(locals,
+                                    ivars,
+                                    enclosing_breakable_pin,
+                                    enclosing_compound_statement_pin).process_while(node)
+
             # Note - this should not be considered a block, as the
             # while statement doesn't create a closure - e.g.,
             # variables created inside can be seen from outside as
@@ -18,7 +22,7 @@ module Solargraph
               closure: region.closure,
               node: node,
               comments: comments_for(node),
-              source: :parser,
+              source: :parser
             )
             process_children region
           end

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

@@ -27,8 +27,10 @@ module Solargraph
         autoload :SymNode,       'solargraph/parser/parser_gem/node_processors/sym_node'
         autoload :ResbodyNode,   'solargraph/parser/parser_gem/node_processors/resbody_node'
         autoload :UntilNode,     'solargraph/parser/parser_gem/node_processors/until_node'
+        autoload :WhenNode,      'solargraph/parser/parser_gem/node_processors/when_node'
         autoload :WhileNode,     'solargraph/parser/parser_gem/node_processors/while_node'
         autoload :AndNode,       'solargraph/parser/parser_gem/node_processors/and_node'
+        autoload :OrNode,        'solargraph/parser/parser_gem/node_processors/or_node'
       end
     end
 
@@ -63,8 +65,10 @@ module Solargraph
       register :op_asgn,      ParserGem::NodeProcessors::OpasgnNode
       register :sym,          ParserGem::NodeProcessors::SymNode
       register :until,        ParserGem::NodeProcessors::UntilNode
+      register :when,         ParserGem::NodeProcessors::WhenNode
       register :while,        ParserGem::NodeProcessors::WhileNode
       register :and,          ParserGem::NodeProcessors::AndNode
+      register :or,           ParserGem::NodeProcessors::OrNode
     end
   end
 end