solargraph 0.58.3 → 0.60.4

data/lib/solargraph/source/chain/literal.rb

@@ -6,31 +6,38 @@ module Solargraph
   class Source
     class Chain
       class Literal < Link
-        def word
-          @word ||= "<#{@type}>"
-        end
-
-        attr_reader :value
+        attr_reader :word, :value
 
         # @param type [String]
         # @param node [Parser::AST::Node, Object]
         def initialize type, node
-          if node.is_a?(::Parser::AST::Node)
-            if node.type == :true
-              @value = true
-            elsif node.type == :false
-              @value = false
-            elsif [:int, :sym].include?(node.type)
-              @value = node.children.first
-            end
-          end
+          super("<#{type}>")
+
+          # @todo We might be able to do some light inference from literals and
+          #   tuples as long as literal values are intransitive.
+
+          # if node.is_a?(::Parser::AST::Node)
+          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+          #   if node.type == :true
+          #     @value = true
+          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+          #   elsif node.type == :false
+          #     @value = false
+          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+          #   elsif %i[int sym].include?(node.type)
+          #     # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+          #     @value = node.children.first
+          #   end
+          # end
           @type = type
-          @literal_type = ComplexType.try_parse(@value.inspect)
+          # @literal_type = ComplexType.try_parse(@value.inspect)
+          @literal_type = ComplexType::UNDEFINED
           @complex_type = ComplexType.try_parse(type)
         end
 
         # @sg-ignore Fix "Not enough arguments to Module#protected"
         protected def equality_fields
+          # @sg-ignore literal arrays in this module turn into ::Solargraph::Source::Chain::Array
           super + [@value, @type, @literal_type, @complex_type]
         end
 

data/lib/solargraph/source/chain/or.rb

@@ -4,18 +4,24 @@ module Solargraph
   class Source
     class Chain
       class Or < Link
-        def word
-          '<or>'
-        end
+        attr_reader :links
 
         # @param links [::Array<Chain>]
         def initialize links
+          super('<or>')
+
           @links = links
         end
 
         def resolve api_map, name_pin, locals
           types = @links.map { |link| link.infer(api_map, name_pin, locals) }
-          [Solargraph::Pin::ProxyType.anonymous(Solargraph::ComplexType.new(types.uniq), source: :chain)]
+          combined_type = Solargraph::ComplexType.new(types)
+          unless types.all?(&:nullable?)
+            # @sg-ignore flow sensitive typing should be able to handle redefinition
+            combined_type = combined_type.without_nil
+          end
+
+          [Solargraph::Pin::ProxyType.anonymous(combined_type, source: :chain)]
         end
       end
     end

data/lib/solargraph/source/chain/q_call.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Solargraph
   class Source
     class Chain

data/lib/solargraph/source/chain/variable.rb

@@ -5,7 +5,9 @@ module Solargraph
     class Chain
       class Variable < Link
         def resolve api_map, name_pin, locals
-          api_map.get_instance_variable_pins(name_pin.context.namespace, name_pin.context.scope).select{|p| p.name == word}
+          api_map.get_instance_variable_pins(name_pin.context.namespace, name_pin.context.scope).select do |p|
+            p.name == word
+          end
         end
       end
     end

data/lib/solargraph/source/chain/z_super.rb

@@ -11,9 +11,7 @@ module Solargraph
         attr_reader :arguments
 
         # @param word [String]
-        # @param arguments [::Array<Chain>]
         # @param with_block [Boolean] True if the chain is inside a block
-        # @param head [Boolean] True if the call is the start of its chain
         def initialize word, with_block = false
           super(word, nil, [], with_block)
         end
@@ -22,7 +20,7 @@ module Solargraph
         # @param name_pin [Pin::Base]
         # @param locals [::Array<Pin::Base>]
         def resolve api_map, name_pin, locals
-          return super_pins(api_map, name_pin)
+          super_pins(api_map, name_pin)
         end
       end
     end

data/lib/solargraph/source/chain.rb

@@ -48,11 +48,6 @@ module Solargraph
 
       attr_reader :node
 
-      # @sg-ignore Fix "Not enough arguments to Module#protected"
-      protected def equality_fields
-        [links, node]
-      end
-
       # @param node [Parser::AST::Node, nil]
       # @param links [::Array<Chain::Link>]
       # @param splat [Boolean]
@@ -71,6 +66,7 @@ module Solargraph
 
       # @return [Chain]
       def base
+        # @sg-ignore Need to add nil check here
         @base ||= Chain.new(links[0..-2])
       end
 
@@ -78,25 +74,25 @@ module Solargraph
       #
       # @param api_map [ApiMap]
       #
-      # @param name_pin [Pin::Base] A pin
-      # representing the place in which expression is evaluated (e.g.,
-      # a Method pin, or a Module or Class pin if not run within a
-      # method - both in terms of the closure around the chain, as well
-      # as the self type used for any method calls in head position.
+      # @param name_pin [Pin::Base] A pin representing the closure in
+      #   which expression is evaluated (e.g., a Method pin, or a
+      #   Module or Class pin if not run within a method - both in
+      #   terms of the closure around the chain, as well as the self
+      #   type used for any method calls in head position.
       #
       #   Requirements for name_pin:
       #
       #     * name_pin.context: This should be a type representing the
-      #       namespace where we can look up non-local variables and
-      #       method names.  If it is a Class<X>, we will look up
-      #       :class scoped methods/variables.
+      #       namespace where we can look up non-local variables.  If
+      #       it is a Class<X>, we will look up :class scoped
+      #       instance variables.
       #
       #     * name_pin.binder: Used for method call lookups only
       #       (Chain::Call links).  For method calls as the first
       #       element in the chain, 'name_pin.binder' should be the
       #       same as name_pin.context above.  For method calls later
-      #       in the chain (e.g., 'b' in a.b.c), it should represent
-      #       'a'.
+      #       in the chain, it changes.  (e.g., for 'b' in a.b.c, it
+      #       should represent the type of 'a').
       #
       # @param locals [::Array<Pin::LocalVariable>] Any local
       #   variables / method parameters etc visible by the statement
@@ -113,11 +109,14 @@ module Solargraph
         #
         # @todo ProxyType uses 'type' for the binder, but '
         working_pin = name_pin
+        # @sg-ignore Need to add nil check here
         links[0..-2].each do |link|
           pins = link.resolve(api_map, working_pin, locals)
           type = infer_from_definitions(pins, working_pin, api_map, locals)
           if type.undefined?
-            logger.debug { "Chain#define(links=#{links.map(&:desc)}, name_pin=#{name_pin.inspect}, locals=#{locals}) => [] - undefined type from #{link.desc}" }
+            logger.debug do
+              "Chain#define(links=#{links.map(&:desc)}, name_pin=#{name_pin.inspect}, locals=#{locals}) => [] - undefined type from #{link.desc}"
+            end
             return []
           end
           # We continue to use the context from the head pin, in case
@@ -126,7 +125,9 @@ module Solargraph
           # for the binder, as this is chaining off of it, and the
           # binder is now the lhs of the rhs we are evaluating.
           working_pin = Pin::ProxyType.anonymous(name_pin.context, binder: type, closure: name_pin, source: :chain)
-          logger.debug { "Chain#define(links=#{links.map(&:desc)}, name_pin=#{name_pin.inspect}, locals=#{locals}) - after processing #{link.desc}, new working_pin=#{working_pin} with binder #{working_pin.binder}" }
+          logger.debug do
+            "Chain#define(links=#{links.map(&:desc)}, name_pin=#{name_pin.inspect}, locals=#{locals}) - after processing #{link.desc}, new working_pin=#{working_pin} with binder #{working_pin.binder}"
+          end
         end
         links.last.last_context = working_pin
         links.last.resolve(api_map, working_pin, locals)
@@ -138,7 +139,8 @@ module Solargraph
       # @return [ComplexType]
       # @sg-ignore
       def infer api_map, name_pin, locals
-        cache_key = [node, node&.location, links, name_pin&.return_type, locals]
+        # includes binder as it is mutable in Pin::Block
+        cache_key = [node, node&.location, links, name_pin&.return_type, name_pin&.binder, locals]
         if @@inference_invalidation_key == api_map.hash
           cached = @@inference_cache[cache_key]
           return cached if cached
@@ -147,23 +149,31 @@ module Solargraph
           @@inference_cache = {}
         end
         out = infer_uncached(api_map, name_pin, locals).downcast_to_literal_if_possible
-        logger.debug { "Chain#infer() - caching result - cache_key_hash=#{cache_key.hash}, links.map(&:hash)=#{links.map(&:hash)}, links=#{links}, cache_key.map(&:hash) = #{cache_key.map(&:hash)}, cache_key=#{cache_key}" }
+        logger.debug do
+          "Chain#infer() - caching result - cache_key_hash=#{cache_key.hash}, links.map(&:hash)=#{links.map(&:hash)}, links=#{links}, cache_key.map(&:hash) = #{cache_key.map(&:hash)}, cache_key=#{cache_key}"
+        end
         @@inference_cache[cache_key] = out
       end
 
       # @param api_map [ApiMap]
       # @param name_pin [Pin::Base]
       # @param locals [::Array<Pin::LocalVariable>]
-      # @return [ComplexType]
+      # @return [ComplexType, ComplexType::UniqueType]
       def infer_uncached api_map, name_pin, locals
         pins = define(api_map, name_pin, locals)
         if pins.empty?
-          logger.debug { "Chain#infer_uncached(links=#{links.map(&:desc)}, locals=#{locals.map(&:desc)}) => undefined - no pins" }
+          logger.debug do
+            "Chain#infer_uncached(links=#{links.map(&:desc)}, locals=#{locals.map(&:desc)}) => undefined - no pins"
+          end
           return ComplexType::UNDEFINED
         end
         type = infer_from_definitions(pins, links.last.last_context, api_map, locals)
-        out = maybe_nil(type)
-        logger.debug { "Chain#infer_uncached(links=#{self.links.map(&:desc)}, locals=#{locals.map(&:desc)}, name_pin=#{name_pin}, name_pin.closure=#{name_pin.closure.inspect}, name_pin.binder=#{name_pin.binder}) => #{out.rooted_tags.inspect}" }
+        out = maybe_nil(type, api_map)
+        logger.debug do
+          "Chain#infer_uncached(links=#{links.map(&:desc)}, locals=#{locals.map(&:desc)}, " \
+            "name_pin=#{name_pin}, name_pin.closure=#{name_pin&.closure&.inspect}, " \
+            "name_pin.binder=#{name_pin&.binder}) => #{out.rooted_tags.inspect}"
+        end
         out
       end
 
@@ -189,8 +199,38 @@ module Solargraph
         @splat
       end
 
-      def nullable?
-        links.any?(&:nullable?)
+      # Whether this chain's inferred type should have nil added to it
+      # because a `&.` earlier in the chain might have short-circuited
+      # evaluation to nil.
+      #
+      # A `&.` only makes the *immediate* call nil-or-normal-result; a
+      # later, non-safe-navigated call in the same chain is still
+      # invoked on whatever that produced. If receiver is nil at that
+      # point, Ruby calls the method on nil itself instead of skipping
+      # it - so nil only continues to flow through subsequent links
+      # that NilClass defines as returning `self` (e.g., #tap,
+      # #itself). Any other subsequent call resolves to a concrete,
+      # non-nil-including type (e.g. NilClass#== returns Boolean), and
+      # nil no longer needs to be tracked past that point (unless a
+      # later `&.` reintroduces it).
+      #
+      # @param api_map [ApiMap]
+      # @return [Boolean]
+      def nullable? api_map
+        currently_nullable = false
+        links.each do |link|
+          if link.nullable?
+            currently_nullable = true
+            next
+          end
+          next unless currently_nullable
+          next unless link.is_a?(Chain::Call)
+
+          pin = api_map.get_method_stack('NilClass', link.word, scope: :instance).first
+          # @sg-ignore Need to add nil check here
+          currently_nullable = pin.nil? || pin.return_type.tag == 'self'
+        end
+        currently_nullable
       end
 
       include Logging
@@ -209,12 +249,12 @@ module Solargraph
       private
 
       # @param pins [::Array<Pin::Base>]
-      # @param context [Pin::Base]
+      # @param name_pin [Pin::Base]
       # @param api_map [ApiMap]
       # @param locals [::Enumerable<Pin::LocalVariable>]
-      # @return [ComplexType]
-      def infer_from_definitions pins, context, api_map, locals
-        # @type [::Array<ComplexType>]
+      # @return [ComplexType, ComplexType::UniqueType]
+      def infer_from_definitions pins, name_pin, api_map, locals
+        # @type [::Array<ComplexType, ComplexType::UniqueType>]
         types = []
         unresolved_pins = []
         # @todo this param tag shouldn't be needed to probe the type
@@ -232,7 +272,8 @@ module Solargraph
               # @todo even at strong, no typechecking complaint
               #   happens when a [Pin::Base,nil] is passed into a method
               #   that accepts only [Pin::Namespace] as an argument
-              type = type.resolve_generics(pin.closure, context.binder)
+              # @sg-ignore Need to add nil check here
+              type = type.resolve_generics(pin.closure, name_pin.binder)
             end
             types << type
           else
@@ -241,17 +282,13 @@ module Solargraph
         end
 
         # Limit method inference recursion
-        if @@inference_depth >= 10 && pins.first.is_a?(Pin::Method)
-          return ComplexType::UNDEFINED
-        end
+        return ComplexType::UNDEFINED if @@inference_depth >= 10 && pins.first.is_a?(Pin::Method)
 
         @@inference_depth += 1
         # @param pin [Pin::Base]
         unresolved_pins.each do |pin|
           # Avoid infinite recursion
-          if @@inference_stack.include?(pin.identity)
-            next
-          end
+          next if @@inference_stack.include?(pin.identity)
 
           @@inference_stack.push(pin.identity)
           type = pin.probe(api_map)
@@ -271,21 +308,28 @@ module Solargraph
                else
                  ComplexType.new(types)
                end
-        if context.nil? || context.return_type.undefined?
+        if name_pin.nil? || name_pin.context.undefined?
           # up to downstream to resolve self type
           return type
         end
-
-        type.self_to_type(context.return_type)
+        type.self_to_type(name_pin.context)
       end
 
-      # @param type [ComplexType]
-      # @return [ComplexType]
-      def maybe_nil type
+      # @param type [ComplexType, ComplexType::UniqueType]
+      # @param api_map [ApiMap]
+      # @return [ComplexType, ComplexType::UniqueType]
+      def maybe_nil type, api_map
         return type if type.undefined? || type.void? || type.nullable?
-        return type unless nullable?
+        return type unless nullable?(api_map)
         ComplexType.new(type.items + [ComplexType::NIL])
       end
+
+      protected
+
+      # @sg-ignore Fix "Not enough arguments to Module#protected"
+      def equality_fields
+        [links, node]
+      end
     end
   end
 end

data/lib/solargraph/source/change.rb

@@ -7,13 +7,13 @@ module Solargraph
     class Change
       include EncodingFixes
 
-      # @return [Range]
+      # @return [Range, nil]
       attr_reader :range
 
       # @return [String]
       attr_reader :new_text
 
-      # @param range [Range] The starting and ending positions of the change.
+      # @param range [Range, nil] The starting and ending positions of the change.
       #   If nil, the original text will be overwritten.
       # @param new_text [String] The text to be changed.
       def initialize range, new_text
@@ -28,12 +28,14 @@ module Solargraph
       #   syntax errors will be repaired.
       # @return [String] The updated text.
       def write text, nullable = false
-        if nullable and !range.nil? and new_text.match(/[.\[{(@$:]$/)
+        if nullable && !range.nil? && new_text.match(/[.\[{(@$:]$/)
           [':', '@'].each do |dupable|
             next unless new_text == dupable
+            # @sg-ignore flow sensitive typing needs to handle attrs
             offset = Position.to_offset(text, range.start)
             if text[offset - 1] == dupable
               p = Position.from_offset(text, offset - 1)
+              # @sg-ignore flow sensitive typing needs to handle attrs
               r = Change.new(Range.new(p, range.start), ' ')
               text = r.write(text)
             end
@@ -58,10 +60,13 @@ module Solargraph
           fixed
         else
           result = commit text, fixed
+          # @sg-ignore flow sensitive typing needs to handle attrs
           off = Position.to_offset(text, range.start)
+          # @sg-ignore Need to add nil check here
           match = result[0, off].match(/[.:]+\z/)
           if match
-            result = result[0, off].sub(/#{match[0]}\z/, ' ' * match[0].length) + result[off..-1]
+            # @sg-ignore flow sensitive typing should be able to handle redefinition
+            result = result[0, off].sub(/#{match[0]}\z/, ' ' * match[0].length) + result[off..]
           end
           result
         end
@@ -73,9 +78,11 @@ module Solargraph
       # @param insert [String]
       # @return [String]
       def commit text, insert
+        # @sg-ignore Need to add nil check here
         start_offset = Position.to_offset(text, range.start)
+        # @sg-ignore Need to add nil check here
         end_offset = Position.to_offset(text, range.ending)
-        (start_offset == 0 ? '' : text[0..start_offset-1].to_s) + normalize(insert) + text[end_offset..-1].to_s
+        (start_offset.zero? ? '' : text[0..(start_offset - 1)].to_s) + normalize(insert) + text[end_offset..].to_s
       end
     end
   end

data/lib/solargraph/source/cursor.rb

@@ -19,7 +19,7 @@ module Solargraph
         @position = Position.normalize(position)
       end
 
-      # @return [String]
+      # @return [String, nil]
       def filename
         source.filename
       end
@@ -35,13 +35,17 @@ module Solargraph
       # The part of the word before the current position. Given the text
       # `foo.bar`, the start_of_word at position(0, 6) is `ba`.
       #
+      # @sg-ignore Need to add nil check here
       # @return [String]
       def start_of_word
         @start_of_word ||= begin
-          match = source.code[0..offset-1].to_s.match(start_word_pattern)
+          match = source.code[0..(offset - 1)].to_s.match(start_word_pattern)
           result = (match ? match[0] : '')
           # Including the preceding colon if the word appears to be a symbol
-          result = ":#{result}" if source.code[0..offset-result.length-1].end_with?(':') and !source.code[0..offset-result.length-1].end_with?('::')
+          # @sg-ignore Need to add nil check here
+          if source.code[0..(offset - result.length - 1)].end_with?(':') && !source.code[0..(offset - result.length - 1)].end_with?('::')
+            result = ":#{result}"
+          end
           result
         end
       end
@@ -50,16 +54,17 @@ module Solargraph
       # `foo.bar`, the end_of_word at position (0,6) is `r`.
       #
       # @return [String]
+      # @sg-ignore Need to add nil check here
       def end_of_word
         @end_of_word ||= begin
-          match = source.code[offset..-1].to_s.match(end_word_pattern)
+          match = source.code[offset..].to_s.match(end_word_pattern)
           match ? match[0] : ''
         end
       end
 
       # @return [Boolean]
       def start_of_constant?
-        source.code[offset-2, 2] == '::'
+        source.code[offset - 2, 2] == '::'
       end
 
       # The range of the word at the current position.
@@ -110,7 +115,17 @@ module Solargraph
       def recipient
         @recipient ||= begin
           node = recipient_node
-          node ? Cursor.new(source, Range.from_node(node).ending) : nil
+          if node.nil?
+            nil
+          else
+            rng = Range.from_node(node)
+            if rng
+              Cursor.new(source, rng.ending)
+            else
+              pos = Position.new(position.line, [position.column - 1, 0].max)
+              Cursor.new(source, pos)
+            end
+          end
         end
       end
       alias receiver recipient
@@ -122,18 +137,18 @@ module Solargraph
 
       # @return [Position]
       def node_position
-        @node_position ||= begin
-          if start_of_word.empty?
-            match = source.code[0, offset].match(/\s*(\.|:+)\s*$/)
-            if match
-              Position.from_offset(source.code, offset - match[0].length)
-            else
-              position
-            end
-          else
-            position
-          end
-        end
+        @node_position ||= if start_of_word.empty?
+                             # @sg-ignore Need to add nil check here
+                             match = source.code[0, offset].match(/\s*(\.|:+)\s*$/)
+                             if match
+                               # @sg-ignore Need to add nil check here
+                               Position.from_offset(source.code, offset - match[0].length)
+                             else
+                               position
+                             end
+                           else
+                             position
+                           end
       end
 
       # @return [Parser::AST::Node, nil]

data/lib/solargraph/source/encoding_fixes.rb

@@ -10,13 +10,12 @@ module Solargraph
       # @param string [String]
       # @return [String]
       def normalize string
-        begin
-          string.dup.force_encoding('UTF-8')
-        rescue ::Encoding::CompatibilityError, ::Encoding::UndefinedConversionError, ::Encoding::InvalidByteSequenceError => e
-          # @todo Improve error handling
-          Solargraph::Logging.logger.warn "Normalize error: #{e.message}"
-          string
-        end
+        string.dup.force_encoding('UTF-8')
+      rescue ::Encoding::CompatibilityError, ::Encoding::UndefinedConversionError,
+             ::Encoding::InvalidByteSequenceError => e
+        # @todo Improve error handling
+        Solargraph::Logging.logger.warn "Normalize error: #{e.message}"
+        string
       end
     end
   end