solargraph 0.58.3 → 0.59.2

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

@@ -1,36 +1,36 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class CasgnNode < Parser::NodeProcessor::Base
-          include ParserGem::NodeMethods
-
-          def process
-            pins.push Solargraph::Pin::Constant.new(
-              location: get_node_location(node),
-              closure: region.closure,
-              name: const_name,
-              comments: comments_for(node),
-              assignment: node.children[2],
-              source: :parser
-            )
-            process_children
-          end
-
-          private
-
-          # @return [String]
-          def const_name
-            if node.children[0]
-              Parser::NodeMethods.unpack_name(node.children[0]) + "::#{node.children[1]}"
-            else
-              node.children[1].to_s
-            end
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class CasgnNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            pins.push Solargraph::Pin::Constant.new(
+              location: get_node_location(node),
+              closure: region.closure,
+              name: const_name,
+              comments: comments_for(node),
+              assignment: node.children[2],
+              source: :parser
+            )
+            process_children
+          end
+
+          private
+
+          # @return [String]
+          def const_name
+            if node.children[0]
+              Parser::NodeMethods.unpack_name(node.children[0]) + "::#{node.children[1]}"
+            else
+              node.children[1].to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,24 +1,24 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class CvasgnNode < Parser::NodeProcessor::Base
-          def process
-            loc = get_node_location(node)
-            pins.push Solargraph::Pin::ClassVariable.new(
-              location: loc,
-              closure: region.closure,
-              name: node.children[0].to_s,
-              comments: comments_for(node),
-              assignment: node.children[1],
-              source: :parser
-            )
-            process_children
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class CvasgnNode < Parser::NodeProcessor::Base
+          def process
+            loc = get_node_location(node)
+            pins.push Solargraph::Pin::ClassVariable.new(
+              location: loc,
+              closure: region.closure,
+              name: node.children[0].to_s,
+              comments: comments_for(node),
+              assignment: node.children[1],
+              source: :parser
+            )
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,38 +8,45 @@ module Solargraph
           def process
             name = node.children[0].to_s
             scope = region.scope || (region.closure.is_a?(Pin::Singleton) ? :class : :instance)
+            # specify context explicitly instead of relying on
+            # closure, as they may differ (e.g., defs inside
+            # class_eval)
+            method_context = scope == :instance ? region.closure.binder.namespace_type : region.closure.binder
             methpin = Solargraph::Pin::Method.new(
               location: get_node_location(node),
               closure: region.closure,
               name: name,
+              context: method_context,
               comments: comments_for(node),
               scope: scope,
               visibility: scope == :instance && name == 'initialize' ? :private : region.visibility,
               node: node,
-              source: :parser,
+              source: :parser
             )
             if region.visibility == :module_function
               pins.push Solargraph::Pin::Method.new(
                 location: methpin.location,
                 closure: methpin.closure,
                 name: methpin.name,
+                context: method_context,
                 comments: methpin.comments,
                 scope: :class,
                 visibility: :public,
                 parameters: methpin.parameters,
                 node: methpin.node,
-                source: :parser,
+                source: :parser
               )
               pins.push Solargraph::Pin::Method.new(
                 location: methpin.location,
                 closure: methpin.closure,
                 name: methpin.name,
+                context: method_context,
                 comments: methpin.comments,
                 scope: :instance,
                 visibility: :private,
                 parameters: methpin.parameters,
                 node: methpin.node,
-                source: :parser,
+                source: :parser
               )
             else
               pins.push methpin

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

@@ -11,13 +11,14 @@ module Solargraph
             s_visi = region.visibility
             s_visi = :public if s_visi == :module_function || region.scope != :class
             loc = get_node_location(node)
-            if node.children[0].is_a?(AST::Node) && node.children[0].type == :self
-              closure = region.closure
-            else
-              closure = Solargraph::Pin::Namespace.new(
-                name: unpack_name(node.children[0])
-              )
-            end
+            closure = if node.children[0].is_a?(AST::Node) && node.children[0].type == :self
+                        region.closure
+                      else
+                        Solargraph::Pin::Namespace.new(
+                          name: unpack_name(node.children[0]),
+                          source: :parser
+                        )
+                      end
             pins.push Solargraph::Pin::Method.new(
               location: loc,
               closure: closure,
@@ -26,7 +27,7 @@ module Solargraph
               scope: :class,
               visibility: s_visi,
               node: node,
-              source: :parser,
+              source: :parser
             )
             process_children region.update(closure: pins.last, scope: :class)
           end

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

@@ -1,24 +1,24 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class GvasgnNode < Parser::NodeProcessor::Base
-          def process
-            loc = get_node_location(node)
-            pins.push Solargraph::Pin::GlobalVariable.new(
-              location: loc,
-              closure: region.closure,
-              name: node.children[0].to_s,
-              comments: comments_for(node),
-              assignment: node.children[1],
-              source: :parser
-            )
-            process_children
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class GvasgnNode < Parser::NodeProcessor::Base
+          def process
+            loc = get_node_location(node)
+            pins.push Solargraph::Pin::GlobalVariable.new(
+              location: loc,
+              closure: region.closure,
+              name: node.children[0].to_s,
+              comments: comments_for(node),
+              assignment: node.children[1],
+              source: :parser
+            )
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,13 +8,43 @@ module Solargraph
           include ParserGem::NodeMethods
 
           def process
-            process_children
+            FlowSensitiveTyping.new(locals,
+                                    ivars,
+                                    enclosing_breakable_pin,
+                                    enclosing_compound_statement_pin).process_if(node)
+            condition_node = node.children[0]
+            if condition_node
+              pins.push Solargraph::Pin::CompoundStatement.new(
+                location: get_node_location(condition_node),
+                closure: region.closure,
+                node: condition_node,
+                source: :parser
+              )
+              NodeProcessor.process(condition_node, region, pins, locals, ivars)
+            end
+            then_node = node.children[1]
+            if then_node
+              pins.push Solargraph::Pin::CompoundStatement.new(
+                location: get_node_location(then_node),
+                closure: region.closure,
+                node: then_node,
+                source: :parser
+              )
+              NodeProcessor.process(then_node, region, pins, locals, ivars)
+            end
 
-            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)
+            else_node = node.children[2]
+            if else_node
+              pins.push Solargraph::Pin::CompoundStatement.new(
+                location: get_node_location(else_node),
+                closure: region.closure,
+                node: else_node,
+                source: :parser
+              )
+              NodeProcessor.process(else_node, region, pins, locals, ivars)
+            end
+
+            true
           end
         end
       end

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

@@ -1,40 +1,40 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class NamespaceNode < Parser::NodeProcessor::Base
-          include ParserGem::NodeMethods
-
-          def process
-            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,
-              location: loc,
-              closure: region.closure,
-              name: unpack_name(node.children[0]),
-              comments: comments_for(node),
-              visibility: :public,
-              gates: region.closure.gates.freeze,
-              source: :parser
-            )
-            pins.push nspin
-            unless superclass_name.nil?
-              pins.push Pin::Reference::Superclass.new(
-                location: loc,
-                closure: pins.last,
-                name: superclass_name,
-                source: :parser
-              )
-            end
-            process_children region.update(closure: nspin, visibility: :public)
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class NamespaceNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            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,
+              location: loc,
+              closure: region.closure,
+              name: unpack_name(node.children[0]),
+              comments: comments_for(node),
+              visibility: :public,
+              gates: region.closure.gates.freeze,
+              source: :parser
+            )
+            pins.push nspin
+            unless superclass_name.nil?
+              pins.push Pin::Reference::Superclass.new(
+                location: loc,
+                closure: pins.last,
+                name: superclass_name,
+                source: :parser
+              )
+            end
+            process_children region.update(closure: nspin, visibility: :public)
+          end
+        end
+      end
+    end
+  end
+end

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