solargraph 0.58.2 → 0.59.0.dev.1

data/lib/solargraph/parser/node_processor.rb

@@ -35,9 +35,10 @@ module Solargraph
       # @param node [Parser::AST::Node]
       # @param region [Region]
       # @param pins [Array<Pin::Base>]
-      # @param locals [Array<Pin::BaseVariable>]
-      # @return [Array(Array<Pin::Base>, Array<Pin::Base>)]
-      def self.process node, region = Region.new, pins = [], locals = []
+      # @param locals [Array<Pin::LocalVariable>]
+      # @param ivars [Array<Pin::InstanceVariable>]
+      # @return [Array(Array<Pin::Base>, Array<Pin::LocalVariable>, Array<Pin::InstanceVariable>)]
+      def self.process node, region = Region.new, pins = [], locals = [], ivars = []
         if pins.empty?
           pins.push Pin::Namespace.new(
             location: region.source.location,
@@ -45,17 +46,17 @@ module Solargraph
             source: :parser,
           )
         end
-        return [pins, locals] unless Parser.is_ast_node?(node)
+        return [pins, locals, ivars] unless Parser.is_ast_node?(node)
         node_processor_classes = @@processors[node.type] || [NodeProcessor::Base]
 
         node_processor_classes.each do |klass|
-          processor = klass.new(node, region, pins, locals)
+          processor = klass.new(node, region, pins, locals, ivars)
           process_next = processor.process
 
           break unless process_next
         end
 
-        [pins, locals]
+        [pins, locals, ivars]
       end
     end
   end

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

@@ -8,19 +8,23 @@ module Solargraph
       module ClassMethods
         # @param code [String]
         # @param filename [String, nil]
+        # @param starting_line [Integer] must be provided so that we
+        #   can find relevant local variables later even if this is just
+        #   a subset of the file in question
         # @return [Array(Parser::AST::Node, Hash{Integer => Solargraph::Parser::Snippet})]
-        def parse_with_comments code, filename = nil
-          node = parse(code, filename)
+        def parse_with_comments code, filename = nil, starting_line = 0
+          node = parse(code, filename, starting_line)
           comments = CommentRipper.new(code, filename, 0).parse
           [node, comments]
         end
 
         # @param code [String]
         # @param filename [String, nil]
-        # @param line [Integer]
+        # @param starting_line [Integer]
+        # @sg-ignore need to understand that raise does not return
         # @return [Parser::AST::Node]
-        def parse code, filename = nil, line = 0
-          buffer = ::Parser::Source::Buffer.new(filename, line)
+        def parse code, filename = nil, starting_line = 0
+          buffer = ::Parser::Source::Buffer.new(filename, starting_line)
           buffer.source = code
           parser.parse(buffer)
         rescue ::Parser::SyntaxError, ::Parser::UnknownEncodingInMagicComment => e
@@ -30,15 +34,20 @@ module Solargraph
         # @return [::Parser::Base]
         def parser
           @parser ||= Prism::Translation::Parser.new(FlawedBuilder.new).tap do |parser|
+            # @sg-ignore Unresolved call to diagnostics on Prism::Translation::Parser
             parser.diagnostics.all_errors_are_fatal = true
+            # @sg-ignore Unresolved call to diagnostics on Prism::Translation::Parser
             parser.diagnostics.ignore_warnings      = true
           end
         end
 
         # @param source [Source]
-        # @return [Array(Array<Pin::Base>, Array<Pin::Base>)]
+        # @return [Array(Array<Pin::Base>, Array<Pin::LocalVariable>)]
         def map source
-          NodeProcessor.process(source.node, Region.new(source: source))
+          # @sg-ignore Need to add nil check here
+          pins, locals, ivars = NodeProcessor.process(source.node, Region.new(source: source))
+          pins.concat(ivars)
+          [pins, locals]
         end
 
         # @param source [Source]
@@ -50,15 +59,18 @@ module Solargraph
             # @param code [String]
             # @param offset [Integer]
             # @return [Array(Integer, Integer), Array(nil, nil)]
+            # @sg-ignore Need to add nil check here
             extract_offset = ->(code, offset) { reg.match(code, offset).offset(0) }
           else
             # @param code [String]
             # @param offset [Integer]
             # @return [Array(Integer, Integer), Array(nil, nil)]
+            # @sg-ignore Need to add nil check here
             extract_offset = ->(code, offset) { [soff = code.index(name, offset), soff + name.length] }
           end
           inner_node_references(name, source.node).map do |n|
             rng = Range.from_node(n)
+            # @sg-ignore Need to add nil check here
             offset = Position.to_offset(source.code, rng.start)
             soff, eoff = extract_offset[source.code, offset]
             Location.new(
@@ -99,7 +111,7 @@ module Solargraph
           Solargraph::Parser::NodeProcessor.process *args
         end
 
-        # @param node [Parser::AST::Node]
+        # @param node [Parser::AST::Node, nil]
         # @return [String, nil]
         def infer_literal_node_type node
           NodeMethods.infer_literal_node_type node
@@ -110,7 +122,7 @@ module Solargraph
           parser.version
         end
 
-        # @param node [BasicObject]
+        # @param node [BasicObject, nil]
         # @return [Boolean]
         def is_ast_node? node
           node.is_a?(::Parser::AST::Node)
@@ -124,19 +136,25 @@ module Solargraph
           Range.new(st, en)
         end
 
-        # @param node [Parser::AST::Node]
+        # @param node [Parser::AST::Node, nil]
         # @return [Array<Range>]
         def string_ranges node
           return [] unless is_ast_node?(node)
           result = []
+          # @sg-ignore Translate to something flow sensitive typing understands
           result.push Range.from_node(node) if node.type == :str
+          # @sg-ignore Translate to something flow sensitive typing understands
           node.children.each do |child|
             result.concat string_ranges(child)
           end
+          # @sg-ignore Translate to something flow sensitive typing understands
           if node.type == :dstr && node.children.last.nil?
+            # @sg-ignore Translate to something flow sensitive typing understands
             last = node.children[-2]
+            # @sg-ignore Need to add nil check here
             unless last.nil?
               rng = Range.from_node(last)
+              # @sg-ignore Need to add nil check here
               pos = Position.new(rng.ending.line, rng.ending.column - 1)
               result.push Range.new(pos, pos)
             end

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

@@ -35,9 +35,12 @@ module Solargraph
           end
 
           # @param code [String]
+          # @param filename [String]
+          # @param starting_line [Integer]
+          #
           # @return [Source::Chain]
-          def load_string(code)
-            node = Parser.parse(code.sub(/\.$/, ''))
+          def load_string(code, filename, starting_line)
+            node = Parser.parse(code.sub(/\.$/, ''), filename, starting_line)
             chain = NodeChainer.new(node).chain
             chain.links.push(Chain::Link.new) if code.end_with?('.')
             chain
@@ -61,6 +64,7 @@ module Solargraph
               result.push Chain::Call.new(n.children[1].to_s, Location.from_node(n), node_args(n), passed_block(n))
             elsif n.children[0].nil?
               args = []
+              # @sg-ignore Need to add nil check here
               n.children[2..-1].each do |c|
                 args.push NodeChainer.chain(c, @filename, n)
               end
@@ -93,14 +97,22 @@ module Solargraph
           elsif [:lvar, :lvasgn].include?(n.type)
             result.push Chain::Call.new(n.children[0].to_s, Location.from_node(n))
           elsif [:ivar, :ivasgn].include?(n.type)
-            result.push Chain::InstanceVariable.new(n.children[0].to_s)
+            result.push Chain::InstanceVariable.new(n.children[0].to_s, n, Location.from_node(n))
           elsif [:cvar, :cvasgn].include?(n.type)
             result.push Chain::ClassVariable.new(n.children[0].to_s)
           elsif [:gvar, :gvasgn].include?(n.type)
             result.push Chain::GlobalVariable.new(n.children[0].to_s)
           elsif n.type == :or_asgn
-            new_node = n.updated(n.children[0].type, n.children[0].children + [n.children[1]])
-            result.concat generate_links new_node
+            # @bar ||= 123 translates to:
+            #
+            # s(:or_asgn,
+            #   s(:ivasgn, :@bar),
+            #   s(:int, 123))
+            lhs_chain = NodeChainer.chain n.children[0] # s(:ivasgn, :@bar)
+            rhs_chain = NodeChainer.chain n.children[1] # s(:int, 123)
+            or_link = Chain::Or.new([lhs_chain, rhs_chain])
+            # this is just for a call chain, so we don't need to record the assignment
+            result.push(or_link)
           elsif [:class, :module, :def, :defs].include?(n.type)
             # @todo Undefined or what?
             result.push Chain::UNDEFINED_CALL
@@ -109,7 +121,17 @@ module Solargraph
           elsif n.type == :or
             result.push Chain::Or.new([NodeChainer.chain(n.children[0], @filename), NodeChainer.chain(n.children[1], @filename, n)])
           elsif n.type == :if
-            result.push Chain::If.new([NodeChainer.chain(n.children[1], @filename), NodeChainer.chain(n.children[2], @filename, n)])
+            then_clause = if n.children[1]
+                            NodeChainer.chain(n.children[1], @filename, n)
+                          else
+                            Source::Chain.new([Source::Chain::Literal.new('nil', nil)], n)
+                          end
+            else_clause = if n.children[2]
+                            NodeChainer.chain(n.children[2], @filename, n)
+                          else
+                            Source::Chain.new([Source::Chain::Literal.new('nil', nil)], n)
+                          end
+            result.push Chain::If.new([then_clause, else_clause])
           elsif [:begin, :kwbegin].include?(n.type)
             result.concat generate_links(n.children.last)
           elsif n.type == :block_pass
@@ -150,12 +172,15 @@ module Solargraph
         def passed_block node
           return unless node == @node && @parent&.type == :block
 
+          # @sg-ignore Need to add nil check here
           NodeChainer.chain(@parent.children[2], @filename)
         end
 
         # @param node [Parser::AST::Node]
+        # @sg-ignore Need to add nil check here
         # @return [Array<Source::Chain>]
         def node_args node
+          # @sg-ignore Need to add nil check here
           node.children[2..-1].map do |child|
             NodeChainer.chain(child, @filename, node)
           end

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

@@ -37,7 +37,7 @@ module Solargraph
           parts
         end
 
-        # @param node [Parser::AST::Node]
+        # @param node [Parser::AST::Node, nil]
         # @return [String, nil]
         def infer_literal_node_type node
           return nil unless node.is_a?(AST::Node)
@@ -105,21 +105,24 @@ module Solargraph
           signature
         end
 
-        # @param node [Parser::AST::Node]
+        # @param node [Parser::AST::Node, nil]
         # @return [Hash{Symbol => Chain}]
         def convert_hash node
           return {} unless Parser.is_ast_node?(node)
+          # @sg-ignore Translate to something flow sensitive typing understands
           return convert_hash(node.children[0]) if node.type == :kwsplat
+          # @sg-ignore Translate to something flow sensitive typing understands
           return convert_hash(node.children[0]) if Parser.is_ast_node?(node.children[0]) && node.children[0].type == :kwsplat
+          # @sg-ignore Translate to something flow sensitive typing understands
           return {} unless node.type == :hash
           result = {}
+          # @sg-ignore Translate to something flow sensitive typing understands
           node.children.each do |pair|
             result[pair.children[0].children[0]] = Solargraph::Parser.chain(pair.children[1])
           end
           result
         end
 
-        # @sg-ignore Wrong argument type for AST::Node.new: type expected AST::_ToSym, received :nil
         NIL_NODE = ::Parser::AST::Node.new(:nil)
 
         # @param node [Parser::AST::Node]
@@ -161,12 +164,15 @@ module Solargraph
           if node.type == :block
             result.push node
             if Parser.is_ast_node?(node.children[0]) && node.children[0].children.length > 2
+              # @sg-ignore Need to add nil check here
               node.children[0].children[2..-1].each { |child| result.concat call_nodes_from(child) }
             end
+            # @sg-ignore Need to add nil check here
             node.children[1..-1].each { |child| result.concat call_nodes_from(child) }
           elsif node.type == :send
             result.push node
             result.concat call_nodes_from(node.children.first)
+            # @sg-ignore Need to add nil check here
             node.children[2..-1].each { |child| result.concat call_nodes_from(child) }
           elsif [:super, :zsuper].include?(node.type)
             result.push node
@@ -211,8 +217,10 @@ module Solargraph
           position = cursor.position
           offset = cursor.offset
           tree = if source.synchronized?
+            # @sg-ignore Need to add nil check here
             match = source.code[0..offset-1].match(/,\s*\z/)
             if match
+              # @sg-ignore Need to add nil check here
               source.tree_at(position.line, position.column - match[0].length)
             else
               source.tree_at(position.line, position.column)
@@ -225,7 +233,9 @@ module Solargraph
           tree.each do |node|
             if node.type == :send
               args = node.children[2..-1]
+              # @sg-ignore Need to add nil check here
               if !args.empty?
+                # @sg-ignore Need to add nil check here
                 return node if prev && args.include?(prev)
               else
                 if source.synchronized?
@@ -303,7 +313,6 @@ module Solargraph
         module DeepInference
           class << self
             CONDITIONAL_ALL_BUT_FIRST = [:if, :unless]
-            CONDITIONAL_ALL = [:or]
             ONLY_ONE_CHILD = [:return]
             FIRST_TWO_CHILDREN = [:rescue]
             COMPOUND_STATEMENTS = [:begin, :kwbegin]
@@ -334,7 +343,7 @@ module Solargraph
             # Look at known control statements and use them to find
             # more specific return nodes.
             #
-            # @param node [Parser::AST::Node] Statement which is in
+            # @param node [AST::Node] Statement which is in
             #    value position for a method body
             # @param include_explicit_returns [Boolean] If true,
             #    include the value nodes of the parameter of the
@@ -348,10 +357,9 @@ module Solargraph
               if COMPOUND_STATEMENTS.include?(node.type)
                 result.concat from_value_position_compound_statement node
               elsif CONDITIONAL_ALL_BUT_FIRST.include?(node.type)
+                # @sg-ignore Need to add nil check here
                 result.concat reduce_to_value_nodes(node.children[1..-1])
                 # result.push NIL_NODE unless node.children[2]
-              elsif CONDITIONAL_ALL.include?(node.type)
-                result.concat reduce_to_value_nodes(node.children)
               elsif ONLY_ONE_CHILD.include?(node.type)
                 result.concat reduce_to_value_nodes([node.children[0]])
               elsif FIRST_TWO_CHILDREN.include?(node.type)
@@ -364,6 +372,7 @@ module Solargraph
                 #   that the function is executed here.
                 result.concat explicit_return_values_from_compound_statement(node.children[2]) if include_explicit_returns
               elsif CASE_STATEMENT.include?(node.type)
+                # @sg-ignore Need to add nil check here
                 node.children[1..-1].each do |cc|
                   if cc.nil?
                     result.push NIL_NODE
@@ -460,17 +469,28 @@ module Solargraph
               nodes.each do |node|
                 if !node.is_a?(::Parser::AST::Node)
                   result.push nil
+                # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                 elsif COMPOUND_STATEMENTS.include?(node.type)
                   result.concat from_value_position_compound_statement(node)
+                # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                 elsif CONDITIONAL_ALL_BUT_FIRST.include?(node.type)
+                  # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                   result.concat reduce_to_value_nodes(node.children[1..-1])
+                # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                 elsif node.type == :return
+                  # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                   result.concat reduce_to_value_nodes([node.children[0]])
+                # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                 elsif node.type == :or
+                  # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                   result.concat reduce_to_value_nodes(node.children)
+                # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                 elsif node.type == :block
+                  # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                   result.concat explicit_return_values_from_compound_statement(node.children[2])
+                # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                 elsif node.type == :resbody
+                  # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                   result.concat reduce_to_value_nodes([node.children[2]])
                 else
                   result.push node

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

@@ -10,10 +10,10 @@ module Solargraph
           def process
             process_children
 
-            position = get_node_start_position(node)
-            # @sg-ignore https://github.com/castwide/solargraph/pull/1114
-            enclosing_breakable_pin = pins.select{|pin| pin.is_a?(Pin::Breakable) && pin.location.range.contain?(position)}.last
-            FlowSensitiveTyping.new(locals, enclosing_breakable_pin).process_and(node)
+            FlowSensitiveTyping.new(locals,
+                                    ivars,
+                                    enclosing_breakable_pin,
+                                    enclosing_compound_statement_pin).process_and(node)
           end
         end
       end

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

@@ -20,6 +20,7 @@ module Solargraph
                                 name: u.children[0].to_s,
                                 assignment: u.children[1],
                                 asgn_code: u.children[1] ? region.code_for(u.children[1]) : nil,
+                                # @sg-ignore Need to add nil check here
                                 presence: callable.location.range,
                                 decl: get_decl(u),
                                 source: :parser
@@ -40,6 +41,7 @@ module Solargraph
             locals.push Solargraph::Pin::Parameter.new(
               location: loc,
               closure: callable,
+              # @sg-ignore Need to add nil check here
               presence: region.closure.location.range,
               decl: get_decl(node),
               source: :parser

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

@@ -6,6 +6,15 @@ module Solargraph
       module NodeProcessors
         class BeginNode < Parser::NodeProcessor::Base
           def process
+            # We intentionally don't create a CompoundStatement pin
+            # here, as this is not necessarily a control flow block -
+            # e.g., a begin...end without rescue or ensure should be
+            # treated by flow sensitive typing as if the begin and end
+            # didn't exist at all.  As such, we create the
+            # CompoundStatement pins around the things which actually
+            # result in control flow changes - like
+            # if/while/rescue/etc
+
             process_children
           end
         end

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

@@ -9,23 +9,22 @@ module Solargraph
 
           def process
             location = get_node_location(node)
-            parent = if other_class_eval?
-              Solargraph::Pin::Namespace.new(
-                location: location,
-                type: :class,
-                name: unpack_name(node.children[0].children[0]),
-                source: :parser,
-              )
-            else
-              region.closure
+            scope = region.scope || region.closure.context.scope
+            if other_class_eval?
+              clazz_name = unpack_name(node.children[0].children[0])
+              # instance variables should come from the Class<T> type
+              # - i.e., treated as class instance variables
+              context = ComplexType.try_parse("Class<#{clazz_name}>")
+              scope = :class
             end
             block_pin = Solargraph::Pin::Block.new(
               location: location,
-              closure: parent,
+              closure: region.closure,
               node: node,
+              context: context,
               receiver: node.children[0],
               comments: comments_for(node),
-              scope: region.scope || region.closure.context.scope,
+              scope: scope,
               source: :parser
             )
             pins.push block_pin
@@ -37,6 +36,7 @@ module Solargraph
           def other_class_eval?
             node.children[0].type == :send &&
               node.children[0].children[1] == :class_eval &&
+              # @sg-ignore Need to add nil check here
               [:cbase, :const].include?(node.children[0].children[0]&.type)
           end
         end

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

@@ -8,10 +8,15 @@ 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,
@@ -23,6 +28,7 @@ module Solargraph
                 location: methpin.location,
                 closure: methpin.closure,
                 name: methpin.name,
+                context: method_context,
                 comments: methpin.comments,
                 scope: :class,
                 visibility: :public,
@@ -34,6 +40,7 @@ module Solargraph
                 location: methpin.location,
                 closure: methpin.closure,
                 name: methpin.name,
+                context: method_context,
                 comments: methpin.comments,
                 scope: :instance,
                 visibility: :private,

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,9 +19,10 @@ 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),
                   name: node.children[0].to_s,

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
@@ -89,7 +89,7 @@ module Solargraph
             ]
             send_node = node.updated(:send, send_children)
             new_asgn = node.updated(asgn.type, [variable_name,  send_node])
-            NodeProcessor.process(new_asgn, region, pins, locals)
+            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