solargraph 0.58.3 → 0.59.2

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

@@ -1,20 +1,20 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class SymNode < Parser::NodeProcessor::Base
-          # @return [void]
-          def process
-            pins.push Solargraph::Pin::Symbol.new(
-              get_node_location(node),
-              ":#{node.children[0]}",
-              source: :parser
-            )
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class SymNode < Parser::NodeProcessor::Base
+          # @return [void]
+          def process
+            pins.push Solargraph::Pin::Symbol.new(
+              get_node_location(node),
+              ":#{node.children[0]}",
+              source: :parser
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -18,7 +18,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/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

data/lib/solargraph/parser/parser_gem.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Solargraph
   module Parser
     module ParserGem

data/lib/solargraph/parser/region.rb

@@ -22,7 +22,6 @@ module Solargraph
       attr_reader :lvars
 
       # @param source [Source]
-      # @param namespace [String]
       # @param closure [Pin::Closure, nil]
       # @param scope [Symbol, nil]
       # @param visibility [Symbol]
@@ -30,18 +29,25 @@ module Solargraph
       def initialize source: Solargraph::Source.load_string(''), closure: nil,
                      scope: nil, visibility: :public, lvars: []
         @source = source
-        # @closure = closure
         @closure = closure || Pin::Namespace.new(name: '', location: source.location, source: :parser)
         @scope = scope
         @visibility = visibility
         @lvars = lvars
       end
 
-      # @return [String]
+      # @return [String, nil]
       def filename
         source.filename
       end
 
+      # @return [Pin::Namespace, nil]
+      def namespace_pin
+        ns = closure
+        # @sg-ignore flow sensitive typing needs to handle while
+        ns = ns.closure while ns && !ns.is_a?(Pin::Namespace)
+        ns
+      end
+
       # Generate a new Region with the provided attribute changes.
       #
       # @param closure [Pin::Closure, nil]

data/lib/solargraph/parser/snippet.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Solargraph
   module Parser
     class Snippet
-      # @return [Range]
+      # @return [Solargraph::Range]
       attr_reader :range
       # @return [String]
       attr_reader :text

data/lib/solargraph/parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Solargraph
   module Parser
     autoload :CommentRipper, 'solargraph/parser/comment_ripper'