solargraph 0.54.0 → 0.55.0

data/lib/solargraph/library.rb

@@ -27,11 +27,11 @@ module Solargraph
     def initialize workspace = Solargraph::Workspace.new, name = nil
       @workspace = workspace
       @name = name
-      @threads = []
       # @type [Integer, nil]
       @total = nil
       # @type [Source, nil]
       @current = nil
+      @sync_count = 0
     end
 
     def inspect
@@ -44,7 +44,7 @@ module Solargraph
     #
     # @return [Boolean]
     def synchronized?
-      !mutex.locked?
+      @sync_count < 2
     end
 
     # Attach a source to the library.
@@ -132,6 +132,7 @@ module Solargraph
       result = false
       filenames.each do |filename|
         detach filename
+        source_map_hash.delete(filename)
         result ||= workspace.remove(filename)
       end
       result
@@ -174,9 +175,9 @@ module Solargraph
     # @return [Array<Solargraph::Pin::Base>, nil]
     # @todo Take filename/position instead of filename/line/column
     def definitions_at filename, line, column
+      sync_catalog
       position = Position.new(line, column)
       cursor = Source::Cursor.new(read(filename), position)
-      sync_catalog
       if cursor.comment?
         source = read(filename)
         offset = Solargraph::Position.to_offset(source.code, Solargraph::Position.new(line, column))
@@ -190,7 +191,10 @@ module Solargraph
           []
         end
       else
-        mutex.synchronize { api_map.clip(cursor).define.map { |pin| pin.realize(api_map) } }
+        mutex.synchronize do
+          clip = api_map.clip(cursor)
+          clip.define.map { |pin| pin.realize(api_map) }
+        end
       end
     rescue FileNotFoundError => e
       handle_file_not_found(filename, e)
@@ -205,9 +209,9 @@ module Solargraph
     # @return [Array<Solargraph::Pin::Base>, nil]
     # @todo Take filename/position instead of filename/line/column
     def type_definitions_at filename, line, column
+      sync_catalog
       position = Position.new(line, column)
       cursor = Source::Cursor.new(read(filename), position)
-      sync_catalog
       mutex.synchronize { api_map.clip(cursor).types }
     rescue FileNotFoundError => e
       handle_file_not_found filename, e
@@ -222,9 +226,9 @@ module Solargraph
     # @return [Array<Solargraph::Pin::Base>]
     # @todo Take filename/position instead of filename/line/column
     def signatures_at filename, line, column
+      sync_catalog
       position = Position.new(line, column)
       cursor = Source::Cursor.new(read(filename), position)
-      sync_catalog
       mutex.synchronize { api_map.clip(cursor).signify }
     end
 
@@ -233,7 +237,7 @@ module Solargraph
     # @param column [Integer]
     # @param strip [Boolean] Strip special characters from variable names
     # @param only [Boolean] Search for references in the current file only
-    # @return [Array<Solargraph::Range>]
+    # @return [Array<Solargraph::Location>]
     # @todo Take a Location instead of filename/line/column
     def references_from filename, line, column, strip: false, only: false
       sync_catalog
@@ -391,6 +395,8 @@ module Solargraph
       return [] unless open?(filename)
       result = []
       source = read(filename)
+
+      # @type [Hash{Class<Solargraph::Diagnostics::Base> => Array<String>}]
       repargs = {}
       workspace.config.reporters.each do |line|
         if line == 'all!'
@@ -416,20 +422,7 @@ module Solargraph
     #
     # @return [void]
     def catalog
-      @threads.delete_if(&:stop?)
-      @threads.push(Thread.new do
-        sleep 0.05 if RUBY_PLATFORM =~ /mingw/
-        next unless @threads.last == Thread.current
-
-        mutex.synchronize do
-          logger.info "Cataloging #{workspace.directory.empty? ? 'generic workspace' : workspace.directory}"
-          api_map.catalog bench
-          logger.info "Catalog complete (#{api_map.source_maps.length} files, #{api_map.pins.length} pins)"
-          logger.info "#{api_map.uncached_gemspecs.length} uncached gemspecs"
-          cache_next_gemspec
-        end
-      end)
-      @threads.last.run if RUBY_PLATFORM =~ /mingw/
+      @sync_count += 1
     end
 
     # @return [Bench]
@@ -437,7 +430,8 @@ module Solargraph
       Bench.new(
         source_maps: source_map_hash.values,
         workspace: workspace,
-        external_requires: external_requires
+        external_requires: external_requires,
+        live_map: @current ? source_map_hash[@current.filename] : nil
       )
     end
 
@@ -467,7 +461,6 @@ module Solargraph
     # @param source [Source]
     # @return [Boolean] True if the source was merged into the workspace.
     def merge source
-      Logging.logger.debug "Merging source: #{source.filename}"
       result = workspace.merge(source)
       maybe_map source
       result
@@ -489,7 +482,6 @@ module Solargraph
       if src
         Logging.logger.debug "Mapping #{src.filename}"
         source_map_hash[src.filename] = Solargraph::SourceMap.map(src)
-        find_external_requires(source_map_hash[src.filename])
         source_map_hash[src.filename]
       else
         false
@@ -500,7 +492,7 @@ module Solargraph
     def map!
       workspace.sources.each do |src|
         source_map_hash[src.filename] = Solargraph::SourceMap.map(src)
-        find_external_requires(source_map_hash[src.filename])
+        find_external_requires source_map_hash[src.filename]
       end
       self
     end
@@ -580,22 +572,10 @@ module Solargraph
       return unless source
       return unless @current == source || workspace.has_file?(source.filename)
       if source_map_hash.key?(source.filename)
-        return if source_map_hash[source.filename].code == source.code &&
-          source_map_hash[source.filename].source.synchronized? &&
-          source.synchronized?
-        if source.synchronized?
-          new_map = Solargraph::SourceMap.map(source)
-          unless source_map_hash[source.filename].try_merge!(new_map)
-            source_map_hash[source.filename] = new_map
-            find_external_requires(source_map_hash[source.filename])
-          end
-        else
-          # @todo Smelly instance variable access
-          source_map_hash[source.filename].instance_variable_set(:@source, source)
-        end
+        new_map = Solargraph::SourceMap.map(source)
+        source_map_hash[source.filename] = new_map
       else
         source_map_hash[source.filename] = Solargraph::SourceMap.map(source)
-        find_external_requires(source_map_hash[source.filename])
       end
     end
 
@@ -625,6 +605,7 @@ module Solargraph
       ensure
         end_cache_progress
         catalog
+        sync_catalog
       end
     end
 
@@ -666,8 +647,17 @@ module Solargraph
     end
 
     def sync_catalog
-      @threads.delete_if(&:stop?)
-              .last&.join
+      return if @sync_count == 0
+
+      mutex.synchronize do
+        logger.info "Cataloging #{workspace.directory.empty? ? 'generic workspace' : workspace.directory}"
+        api_map.catalog bench
+        source_map_hash.values.each { |map| find_external_requires(map) }
+        logger.info "Catalog complete (#{api_map.source_maps.length} files, #{api_map.pins.length} pins)"
+        logger.info "#{api_map.uncached_gemspecs.length} uncached gemspecs"
+        cache_next_gemspec
+        @sync_count = 0
+      end
     end
   end
 end

data/lib/solargraph/location.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
 module Solargraph
-  # A section of text identified by its filename and range.
+  # A pointer to a section of source text identified by its filename
+  # and Range.
   #
   class Location
+    include Equality
+
     # @return [String]
     attr_reader :filename
 
@@ -17,6 +20,24 @@ module Solargraph
       @range = range
     end
 
+    # @sg-ignore Fix "Not enough arguments to Module#protected"
+    protected def equality_fields
+      [filename, range]
+    end
+
+    # @param location [self]
+    def contain? location
+      range.contain?(location.range.start) && range.contain?(location.range.ending) && filename == location.filename
+    end
+
+    def inspect
+      "<#{self.class.name}: filename=#{filename}, range=#{range.inspect}>"
+    end
+
+    def to_s
+      inspect
+    end
+
     # @return [Hash]
     def to_hash
       {
@@ -25,6 +46,13 @@ module Solargraph
       }
     end
 
+    # @param node [Parser::AST::Node, nil]
+    def self.from_node(node)
+      return nil if node.nil? || node.loc.nil?
+      range = Range.from_node(node)
+      self.new(node.loc.expression.source_buffer.name, range)
+    end
+
     # @param other [BasicObject]
     def == other
       return false unless other.is_a?(Location)

data/lib/solargraph/parser/comment_ripper.rb

@@ -13,6 +13,7 @@ module Solargraph
       end
 
       def on_comment *args
+        # @type [Array(Symbol, String, Array([Integer, nil], [Integer, nil]))]
         result = super
         if @buffer_lines[result[2][0]][0..result[2][1]].strip =~ /^#/
           chomped = result[1].chomp
@@ -24,24 +25,28 @@ module Solargraph
         result
       end
 
+      # @param result [Array(Symbol, String, Array([Integer, nil], [Integer, nil]))]
+      # @return [void]
+      def create_snippet(result)
+        chomped = result[1].chomp
+        @comments[result[2][0]] = Snippet.new(Range.from_to(result[2][0] || 0, result[2][1] || 0, result[2][0] || 0, (result[2][1] || 0) + chomped.length), chomped)
+      end
+
       def on_embdoc_beg *args
         result = super
-        chomped = result[1].chomp
-        @comments[result[2][0]] = Snippet.new(Range.from_to(result[2][0], result[2][1], result[2][0], result[2][1] + chomped.length), chomped)
+        create_snippet(result)
         result
       end
 
       def on_embdoc *args
         result = super
-        chomped = result[1].chomp
-        @comments[result[2][0]] = Snippet.new(Range.from_to(result[2][0], result[2][1], result[2][0], result[2][1] + chomped.length), chomped)
+        create_snippet(result)
         result
       end
 
       def on_embdoc_end *args
         result = super
-        chomped = result[1].chomp
-        @comments[result[2][0]] = Snippet.new(Range.from_to(result[2][0], result[2][1], result[2][0], result[2][1] + chomped.length), chomped)
+        create_snippet(result)
         result
       end
 

data/lib/solargraph/parser/flow_sensitive_typing.rb

@@ -0,0 +1,226 @@
+module Solargraph
+  module Parser
+    class FlowSensitiveTyping
+      include Solargraph::Parser::NodeMethods
+
+      # @param locals [Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
+      def initialize(locals, enclosing_breakable_pin = nil)
+        @locals = locals
+        @enclosing_breakable_pin = enclosing_breakable_pin
+      end
+
+      # @param and_node [Parser::AST::Node]
+      def process_and(and_node, true_ranges = [])
+        lhs = and_node.children[0]
+        rhs = and_node.children[1]
+
+        before_rhs_loc = rhs.location.expression.adjust(begin_pos: -1)
+        before_rhs_pos = Position.new(before_rhs_loc.line, before_rhs_loc.column)
+
+        rhs_presence = Range.new(before_rhs_pos,
+                                 get_node_end_position(rhs))
+        process_isa(lhs, true_ranges + [rhs_presence])
+      end
+
+      # @param if_node [Parser::AST::Node]
+      def process_if(if_node)
+        #
+        # See if we can refine a type based on the result of 'if foo.nil?'
+        #
+        # [3] pry(main)> require 'parser/current'; Parser::CurrentRuby.parse("if foo.is_a? Baz; then foo; else bar; end")
+        # => s(:if,
+        #   s(:send,
+        #     s(:send, nil, :foo), :is_a?,
+        #     s(:const, nil, :Baz)),
+        #   s(:send, nil, :foo),
+        #   s(:send, nil, :bar))
+        # [4] pry(main)>
+        conditional_node = if_node.children[0]
+        then_clause = if_node.children[1]
+        else_clause = if_node.children[2]
+
+        true_ranges = []
+        if always_breaks?(else_clause)
+          unless enclosing_breakable_pin.nil?
+            rest_of_breakable_body = Range.new(get_node_end_position(if_node),
+                                               get_node_end_position(enclosing_breakable_pin.node))
+            true_ranges << rest_of_breakable_body
+          end
+        end
+
+        unless then_clause.nil?
+          #
+          # Add specialized locals for the then clause range
+          #
+          before_then_clause_loc = then_clause.location.expression.adjust(begin_pos: -1)
+          before_then_clause_pos = Position.new(before_then_clause_loc.line, before_then_clause_loc.column)
+          true_ranges << Range.new(before_then_clause_pos,
+                                   get_node_end_position(then_clause))
+        end
+
+        process_conditional(conditional_node, true_ranges)
+      end
+
+      class << self
+        include Logging
+      end
+
+      # Find a variable pin by name and where it is used.
+      #
+      # Resolves our most specific view of this variable's type by
+      # preferring pins created by flow-sensitive typing when we have
+      # them based on the Closure and Location.
+      #
+      # @param pins [Array<Pin::LocalVariable>]
+      # @param closure [Pin::Closure]
+      # @param location [Location]
+      def self.visible_pins(pins, name, closure, location)
+        logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location})" }
+        pins_with_name = pins.select { |p| p.name == name }
+        if pins_with_name.empty?
+          logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location}) => [] - no pins with name" }
+          return []
+        end
+        pins_with_specific_visibility = pins.select { |p| p.name == name && p.presence && p.visible_at?(closure, location) }
+        if pins_with_specific_visibility.empty?
+          logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location}) => #{pins_with_name} - no pins with specific visibility" }
+          return pins_with_name
+        end
+        visible_pins_specific_to_this_closure = pins_with_specific_visibility.select { |p| p.closure == closure }
+        if visible_pins_specific_to_this_closure.empty?
+          logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location}) => #{pins_with_specific_visibility} - no visible pins specific to this closure (#{closure})}" }
+          return pins_with_specific_visibility
+        end
+        flow_defined_pins = pins_with_specific_visibility.select { |p| p.presence_certain? }
+        if flow_defined_pins.empty?
+          logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location}) => #{visible_pins_specific_to_this_closure} - no flow-defined pins" }
+          return visible_pins_specific_to_this_closure
+        end
+
+        logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location}) => #{flow_defined_pins}" }
+
+        flow_defined_pins
+      end
+
+      include Logging
+
+      private
+
+      # @param pin [Pin::LocalVariable]
+      # @param if_node [Parser::AST::Node]
+      def add_downcast_local(pin, downcast_type_name, presence)
+        # @todo Create pin#update method
+        new_pin = Solargraph::Pin::LocalVariable.new(
+          location: pin.location,
+          closure: pin.closure,
+          name: pin.name,
+          assignment: pin.assignment,
+          comments: pin.comments,
+          presence: presence,
+          return_type: ComplexType.try_parse(downcast_type_name),
+          presence_certain: true
+        )
+        locals.push(new_pin)
+      end
+
+      # @param facts_by_pin [Hash{Pin::LocalVariable => Array<Hash{Symbol => String}>}]
+      # @param presences [Array<Range>]
+      # @return [void]
+      def process_facts(facts_by_pin, presences)
+        #
+        # Add specialized locals for the rest of the block
+        #
+        facts_by_pin.each_pair do |pin, facts|
+          facts.each do |fact|
+            downcast_type_name = fact.fetch(:type)
+            presences.each do |presence|
+              add_downcast_local(pin, downcast_type_name, presence)
+            end
+          end
+        end
+      end
+
+      # @param conditional_node [Parser::AST::Node]
+      def process_conditional(conditional_node, true_ranges)
+        if conditional_node.type == :send
+          process_isa(conditional_node, true_ranges)
+        elsif conditional_node.type == :and
+          process_and(conditional_node, true_ranges)
+        end
+      end
+
+      # @param isa_node [Parser::AST::Node]
+      # @return [Array(String, String)]
+      def parse_isa(isa_node)
+        return unless isa_node.type == :send && isa_node.children[1] == :is_a?
+        # Check if conditional node follows this pattern:
+        #   s(:send,
+        #     s(:send, nil, :foo), :is_a?,
+        #     s(:const, nil, :Baz)),
+        isa_receiver = isa_node.children[0]
+        isa_type_name = type_name(isa_node.children[2])
+        return unless isa_type_name
+
+        # check if isa_receiver looks like this:
+        #  s(:send, nil, :foo)
+        # and set variable_name to :foo
+        if isa_receiver.type == :send && isa_receiver.children[0].nil? && isa_receiver.children[1].is_a?(Symbol)
+          variable_name = isa_receiver.children[1].to_s
+        end
+        # or like this:
+        # (lvar :repr)
+        variable_name = isa_receiver.children[0].to_s if isa_receiver.type == :lvar
+        return unless variable_name
+
+        [isa_type_name, variable_name]
+      end
+
+      def find_local(variable_name, position)
+        pins = locals.select { |pin| pin.name == variable_name && pin.presence.include?(position) }
+        return unless pins.length == 1
+        pins.first
+      end
+
+      def process_isa(isa_node, true_presences)
+        isa_type_name, variable_name = parse_isa(isa_node)
+        return if variable_name.nil? || variable_name.empty?
+        isa_position = Range.from_node(isa_node).start
+
+        pin = find_local(variable_name, isa_position)
+        return unless pin
+
+        if_true = {}
+        if_true[pin] ||= []
+        if_true[pin] << { type: isa_type_name }
+        process_facts(if_true, true_presences)
+      end
+
+      # @param node [Parser::AST::Node]
+      def type_name(node)
+        # e.g.,
+        #  s(:const, nil, :Baz)
+        return unless node.type == :const
+        module_node = node.children[0]
+        class_node = node.children[1]
+
+        return class_node.to_s if module_node.nil?
+
+        module_type_name = type_name(module_node)
+        return unless module_type_name
+
+        "#{module_type_name}::#{class_node}"
+      end
+
+      # @todo "return type could not be inferred" should not trigger here
+      # @sg-ignore
+      # @param clause_node [Parser::AST::Node]
+      def always_breaks?(clause_node)
+        clause_node&.type == :break
+      end
+
+      attr_reader :locals
+
+      attr_reader :enclosing_breakable_pin
+    end
+  end
+end

data/lib/solargraph/parser/node_methods.rb

@@ -74,10 +74,24 @@ module Solargraph
 
       # @abstract
       # @param node [Parser::AST::Node]
-      # @return [Hash{Parser::AST::Node => Chain}]
+      # @return [Hash{Parser::AST::Node => Source::Chain}]
       def convert_hash node
         raise NotImplementedError
       end
+
+      # @abstract
+      # @param node [Parser::AST::Node]
+      # @return [Position]
+      def get_node_start_position(node)
+        raise NotImplementedError
+      end
+
+      # @abstract
+      # @param node [Parser::AST::Node]
+      # @return [Position]
+      def get_node_end_position(node)
+        raise NotImplementedError
+      end
     end
   end
 end

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

@@ -3,6 +3,15 @@
 require 'parser/current'
 require 'parser/source/buffer'
 
+# Awaiting ability to use a version containing https://github.com/whitequark/parser/pull/1076
+#
+# @!parse
+#   class ::Parser::Base < ::Parser::Builder
+#     # @return [Integer]
+#     def version; end
+#   end
+#   class ::Parser::CurrentRuby < ::Parser::Base; end
+
 module Solargraph
   module Parser
     module ParserGem
@@ -11,13 +20,9 @@ module Solargraph
         # @param filename [String, nil]
         # @return [Array(Parser::AST::Node, Hash{Integer => String})]
         def parse_with_comments code, filename = nil
-          buffer = ::Parser::Source::Buffer.new(filename, 0)
-          buffer.source = code
-          node = parser.parse(buffer)
+          node = parse(code, filename)
           comments = CommentRipper.new(code, filename, 0).parse
           [node, comments]
-        rescue ::Parser::SyntaxError => e
-          raise Parser::SyntaxError, e.message
         end
 
         # @param code [String]
@@ -28,7 +33,7 @@ module Solargraph
           buffer = ::Parser::Source::Buffer.new(filename, line)
           buffer.source = code
           parser.parse(buffer)
-        rescue ::Parser::SyntaxError => e
+        rescue ::Parser::SyntaxError, ::Parser::UnknownEncodingInMagicComment => e
           raise Parser::SyntaxError, e.message
         end
 

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

@@ -57,22 +57,22 @@ module Solargraph
           elsif n.type == :send
             if n.children[0].is_a?(::Parser::AST::Node)
               result.concat generate_links(n.children[0])
-              result.push Chain::Call.new(n.children[1].to_s, node_args(n), passed_block(n))
+              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 = []
               n.children[2..-1].each do |c|
                 args.push NodeChainer.chain(c, @filename, n)
               end
-              result.push Chain::Call.new(n.children[1].to_s, node_args(n), passed_block(n))
+              result.push Chain::Call.new(n.children[1].to_s, Location.from_node(n), node_args(n), passed_block(n))
             else
               raise "No idea what to do with #{n}"
             end
           elsif n.type == :csend
             if n.children[0].is_a?(::Parser::AST::Node)
               result.concat generate_links(n.children[0])
-              result.push Chain::QCall.new(n.children[1].to_s, node_args(n))
+              result.push Chain::QCall.new(n.children[1].to_s, Location.from_node(n), node_args(n))
             elsif n.children[0].nil?
-              result.push Chain::QCall.new(n.children[1].to_s, node_args(n))
+              result.push Chain::QCall.new(n.children[1].to_s, Location.from_node(n), node_args(n))
             else
               raise "No idea what to do with #{n}"
             end
@@ -82,15 +82,15 @@ module Solargraph
             result.push Chain::ZSuper.new('super')
           elsif n.type == :super
             args = n.children.map { |c| NodeChainer.chain(c, @filename, n) }
-            result.push Chain::Call.new('super', args)
+            result.push Chain::Call.new('super', Location.from_node(n), args)
           elsif n.type == :yield
             args = n.children.map { |c| NodeChainer.chain(c, @filename, n) }
-            result.push Chain::Call.new('yield', args)
+            result.push Chain::Call.new('yield', Location.from_node(n), args)
           elsif n.type == :const
             const = unpack_name(n)
             result.push Chain::Constant.new(const)
           elsif [:lvar, :lvasgn].include?(n.type)
-            result.push Chain::Call.new(n.children[0].to_s)
+            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)
           elsif [:cvar, :cvasgn].include?(n.type)
@@ -124,13 +124,13 @@ module Solargraph
               end
             end
           elsif n.type == :hash
-            result.push Chain::Hash.new('::Hash', hash_is_splatted?(n))
+            result.push Chain::Hash.new('::Hash', n, hash_is_splatted?(n))
           elsif n.type == :array
             chained_children = n.children.map { |c| NodeChainer.chain(c) }
-            result.push Source::Chain::Array.new(chained_children)
+            result.push Source::Chain::Array.new(chained_children, n)
           else
             lit = infer_literal_node_type(n)
-            result.push (lit ? Chain::Literal.new(lit) : Chain::Link.new)
+            result.push (lit ? Chain::Literal.new(lit, n) : Chain::Link.new)
           end
           result
         end

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

@@ -12,7 +12,7 @@ require 'ast'
 #     class Node
 #       # New children
 #
-#       # @return [Array<AST::Node>]
+#       # @return [Array<self>]
 #       attr_reader :children
 #     end
 #   end
@@ -40,7 +40,7 @@ module Solargraph
               if n.is_a?(AST::Node)
                 if n.type == :cbase
                   parts = [''] + pack_name(n)
-                else
+                elsif n.type == :const
                   parts += pack_name(n)
                 end
               else
@@ -59,6 +59,8 @@ module Solargraph
             return '::String'
           elsif node.type == :array
             return '::Array'
+          elsif node.type == :nil
+            return '::NilClass'
           elsif node.type == :hash
             return '::Hash'
           elsif node.type == :int
@@ -311,7 +313,7 @@ module Solargraph
         #    statements in value positions.
         module DeepInference
           class << self
-            CONDITIONAL_ALL_BUT_FIRST = [:if, :unless, :or_asgn]
+            CONDITIONAL_ALL_BUT_FIRST = [:if, :unless]
             CONDITIONAL_ALL = [:or]
             ONLY_ONE_CHILD = [:return]
             FIRST_TWO_CHILDREN = [:rescue]
@@ -462,7 +464,7 @@ module Solargraph
               result
             end
 
-            # @param nodes [Enumerable<Parser::AST::Node, BaseObject>]
+            # @param nodes [Enumerable<Parser::AST::Node, BasicObject>]
             # @return [Array<Parser::AST::Node, nil>]
             def reduce_to_value_nodes nodes
               result = []