solargraph 0.54.4 → 0.57.0

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

@@ -17,7 +17,13 @@ module Solargraph
           @word = word
         end
 
-        # @sg-ignore Fix "Not enough arguments to Module#protected"
+        # @sg-ignore two problems - Declared return type
+        #   ::Solargraph::Source::Chain::Array does not match inferred
+        #   type ::Array(::Class<::Solargraph::Source::Chain::Link>,
+        #   ::String) for
+        #   Solargraph::Source::Chain::Link#equality_fields
+        #   and
+        #   Not enough arguments to Module#protected
         protected def equality_fields
           [self.class, word]
         end
@@ -39,6 +45,7 @@ module Solargraph
         end
 
         # debugging description of contents; not for machine use
+        # @return [String]
         def desc
           word
         end
@@ -74,6 +81,8 @@ module Solargraph
         end
 
         # debugging description of contents; not for machine use
+        #
+        # @return [String]
         def desc
           word
         end
@@ -82,6 +91,8 @@ module Solargraph
           "#<#{self.class} - `#{self.desc}`>"
         end
 
+        include Logging
+
         protected
 
         # Mark whether this link is the head of a chain

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'parser'
+
 module Solargraph
   class Source
     class Chain
@@ -8,9 +10,22 @@ module Solargraph
           @word ||= "<#{@type}>"
         end
 
+        attr_reader :value
+
         # @param type [String]
-        def initialize type
+        # @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
           @type = type
+          @literal_type = ComplexType.try_parse(@value.inspect)
           @complex_type = ComplexType.try_parse(type)
         end
 
@@ -20,7 +35,12 @@ module Solargraph
         end
 
         def resolve api_map, name_pin, locals
-          [Pin::ProxyType.anonymous(@complex_type)]
+          if api_map.super_and_sub?(@complex_type.name, @literal_type.name)
+            [Pin::ProxyType.anonymous(@literal_type, source: :chain)]
+          else
+            # we don't support this value as a literal type
+            [Pin::ProxyType.anonymous(@complex_type, source: :chain)]
+          end
         end
       end
     end

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

@@ -15,7 +15,7 @@ module Solargraph
 
         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))]
+          [Solargraph::Pin::ProxyType.anonymous(Solargraph::ComplexType.new(types.uniq), source: :chain)]
         end
       end
     end

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

@@ -15,7 +15,7 @@ module Solargraph
         # @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, [], with_block)
+          super(word, nil, [], with_block)
         end
 
         # @param api_map [ApiMap]

data/lib/solargraph/source/chain.rb

@@ -15,6 +15,7 @@ module Solargraph
     #
     class Chain
       include Equality
+      include Logging
 
       autoload :Link,             'solargraph/source/chain/link'
       autoload :Call,             'solargraph/source/chain/call'
@@ -39,7 +40,7 @@ module Solargraph
       @@inference_invalidation_key = nil
       @@inference_cache = {}
 
-      UNDEFINED_CALL = Chain::Call.new('<undefined>')
+      UNDEFINED_CALL = Chain::Call.new('<undefined>', nil)
       UNDEFINED_CONSTANT = Chain::Constant.new('<undefined>')
 
       # @return [::Array<Source::Chain::Link>]
@@ -76,15 +77,28 @@ module Solargraph
       # Determine potential Pins returned by this chain of words
       #
       # @param api_map [ApiMap]
-      # @param name_pin [Pin::Closure] the surrounding closure pin for
-      #   the statement represented by this chain for type resolution
-      #   and method pin lookup.
       #
-      #   For method calls (Chain::Call objects) as the first element
-      #   in the chain, 'name_pin.binder' should return the
-      #   ComplexType representing the LHS / "self type" of the call.
+      # @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.
+      #
+      #   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.
       #
-      # @param locals [::Enumerable<Pin::LocalVariable>] Any local
+      #     * 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'.
+      #
+      # @param locals [::Array<Pin::LocalVariable>] Any local
       #   variables / method parameters etc visible by the statement
       #
       # @return [::Array<Pin::Base>] Pins representing possible return
@@ -101,16 +115,25 @@ module Solargraph
         working_pin = name_pin
         links[0..-2].each do |link|
           pins = link.resolve(api_map, working_pin, locals)
-          type = infer_first_defined(pins, working_pin, api_map, locals)
-          return [] if type.undefined?
-          working_pin = Pin::ProxyType.anonymous(type)
+          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}" }
+            return []
+          end
+          # We continue to use the context from the head pin, in case
+          # we need it to, for instance, provide context for a block
+          # evaluation.  However, we use the last link's return type
+          # 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}" }
         end
         links.last.last_context = working_pin
         links.last.resolve(api_map, working_pin, locals)
       end
 
       # @param api_map [ApiMap]
-      # @param name_pin [Pin::Base]
+      # @param name_pin [Pin::Base] The pin for the closure in which this code runs
       # @param locals [::Array<Pin::LocalVariable>]
       # @return [ComplexType]
       # @sg-ignore
@@ -123,7 +146,7 @@ module Solargraph
           @@inference_invalidation_key = api_map.hash
           @@inference_cache = {}
         end
-        out = infer_uncached api_map, name_pin, locals
+        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}" }
         @@inference_cache[cache_key] = out
       end
@@ -134,8 +157,14 @@ module Solargraph
       # @return [ComplexType]
       def infer_uncached api_map, name_pin, locals
         pins = define(api_map, name_pin, locals)
-        type = infer_first_defined(pins, links.last.last_context, api_map, locals)
-        maybe_nil(type)
+        if pins.empty?
+          logger.debug { "Chain#infer_uncached(links=#{links.map(&:desc)}, locals=#{locals.map(&:desc)}) => undefined - no pins" }
+          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
       end
 
       # @return [Boolean]
@@ -166,6 +195,7 @@ module Solargraph
 
       include Logging
 
+      # @return [String]
       def desc
         links.map(&:desc).to_s
       end
@@ -174,6 +204,8 @@ module Solargraph
         desc
       end
 
+      include Logging
+
       private
 
       # @param pins [::Array<Pin::Base>]
@@ -181,8 +213,10 @@ module Solargraph
       # @param api_map [ApiMap]
       # @param locals [::Enumerable<Pin::LocalVariable>]
       # @return [ComplexType]
-      def infer_first_defined pins, context, api_map, locals
-        possibles = []
+      def infer_from_definitions pins, context, api_map, locals
+        # @type [::Array<ComplexType>]
+        types = []
+        unresolved_pins = []
         # @todo this param tag shouldn't be needed to probe the type
         # @todo ...but given it is needed, typecheck should complain that it is needed
         # @param pin [Pin::Base]
@@ -200,42 +234,45 @@ module Solargraph
               #   that accepts only [Pin::Namespace] as an argument
               type = type.resolve_generics(pin.closure, context.binder)
             end
-            if type.defined?
-              possibles.push type
-              break if pin.is_a?(Pin::Method)
-            end
+            types << type
+          else
+            unresolved_pins << pin
           end
         end
-        if possibles.empty?
-          # Limit method inference recursion
-          return ComplexType::UNDEFINED if @@inference_depth >= 10 && pins.first.is_a?(Pin::Method)
-
-          @@inference_depth += 1
-          # @param pin [Pin::Base]
-          pins.each do |pin|
-            # Avoid infinite recursion
-            next if @@inference_stack.include?(pin)
-
-            @@inference_stack.push pin
-            type = pin.probe(api_map)
-            @@inference_stack.pop
-            if type.defined?
-              possibles.push type
-              break if pin.is_a?(Pin::Method)
-            end
+
+        # Limit method inference recursion
+        if @@inference_depth >= 10 && pins.first.is_a?(Pin::Method)
+          return ComplexType::UNDEFINED
+        end
+
+        @@inference_depth += 1
+        # @param pin [Pin::Base]
+        unresolved_pins.each do |pin|
+          # Avoid infinite recursion
+          if @@inference_stack.include?(pin.identity)
+            next
           end
-          @@inference_depth -= 1
+
+          @@inference_stack.push(pin.identity)
+          type = pin.probe(api_map)
+          @@inference_stack.pop
+          types.push type if type
         end
-        return ComplexType::UNDEFINED if possibles.empty?
+        @@inference_depth -= 1
 
-        type = if possibles.length > 1
-          # Move nil to the end by convention
-          sorted = possibles.sort { |a, _| a.tag == 'nil' ? 1 : 0 }
-          ComplexType.new(sorted.uniq)
-        else
-          ComplexType.new(possibles)
+        type = if types.empty?
+                 ComplexType::UNDEFINED
+               elsif types.length > 1
+                 # Move nil to the end by convention
+                 sorted = types.flat_map(&:items).sort { |a, _| a.tag == 'nil' ? 1 : 0 }
+                 ComplexType.new(sorted.uniq)
+               else
+                 ComplexType.new(types)
+               end
+        if context.nil? || context.return_type.undefined?
+          # up to downstream to resolve self type
+          return type
         end
-        return type if context.nil? || context.return_type.undefined?
 
         type.self_to_type(context.return_type)
       end

data/lib/solargraph/source/change.rb

@@ -28,7 +28,7 @@ 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 and !range.nil? and new_text.match(/[.\[{(@$:]$/)
           [':', '@'].each do |dupable|
             next unless new_text == dupable
             offset = Position.to_offset(text, range.start)
@@ -59,7 +59,7 @@ module Solargraph
         else
           result = commit text, fixed
           off = Position.to_offset(text, range.start)
-          match = result[0, off].match(/[\.:]+\z/)
+          match = result[0, off].match(/[.:]+\z/)
           if match
             result = result[0, off].sub(/#{match[0]}\z/, ' ' * match[0].length) + result[off..-1]
           end

data/lib/solargraph/source/cursor.rb

@@ -35,7 +35,6 @@ 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 Improve resolution of String#match below
       # @return [String]
       def start_of_word
         @start_of_word ||= begin
@@ -125,7 +124,7 @@ module Solargraph
       def node_position
         @node_position ||= begin
           if start_of_word.empty?
-            match = source.code[0, offset].match(/[\s]*(\.|:+)[\s]*$/)
+            match = source.code[0, offset].match(/\s*(\.|:+)\s*$/)
             if match
               Position.from_offset(source.code, offset - match[0].length)
             else
@@ -160,7 +159,7 @@ module Solargraph
       #
       # @return [Regexp]
       def end_word_pattern
-        /^([a-z0-9_]|[^\u0000-\u007F])*[\?\!]?/i
+        /^([a-z0-9_]|[^\u0000-\u007F])*[?!]?/i
       end
     end
   end

data/lib/solargraph/source/source_chainer.rb

@@ -32,8 +32,8 @@ module Solargraph
       # @return [Source::Chain]
       def chain
         # Special handling for files that end with an integer and a period
-        return Chain.new([Chain::Literal.new('Integer'), Chain::UNDEFINED_CALL]) if phrase =~ /^[0-9]+\.$/
-        return Chain.new([Chain::Literal.new('Symbol')]) if phrase.start_with?(':') && !phrase.start_with?('::')
+        return Chain.new([Chain::Literal.new('Integer', Integer(phrase[0..-2])), Chain::UNDEFINED_CALL]) if phrase =~ /^[0-9]+\.$/
+        return Chain.new([Chain::Literal.new('Symbol', phrase[1..].to_sym)]) if phrase.start_with?(':') && !phrase.start_with?('::')
         return SourceChainer.chain(source, Position.new(position.line, position.character + 1)) if end_of_phrase.strip == '::' && source.code[Position.to_offset(source.code, position)].to_s.match?(/[a-z]/i)
         begin
           return Chain.new([]) if phrase.end_with?('..')
@@ -97,7 +97,7 @@ module Solargraph
       # @return [String]
       def end_of_phrase
         @end_of_phrase ||= begin
-          match = phrase.match(/[\s]*(\.{1}|::)[\s]*$/)
+          match = phrase.match(/\s*(\.{1}|::)\s*$/)
           if match
             match[0]
           else

data/lib/solargraph/source.rb

@@ -30,7 +30,7 @@ module Solargraph
       @node
     end
 
-    # @return [Hash{Integer => Array<String>}]
+    # @return [Hash{Integer => Solargraph::Parser::Snippet}]
     def comments
       finalize
       @comments
@@ -235,6 +235,7 @@ module Solargraph
     # @return [Hash{Integer => String}]
     def associated_comments
       @associated_comments ||= begin
+        # @type [Hash{Integer => String}]
         result = {}
         buffer = String.new('')
         # @type [Integer, nil]
@@ -317,7 +318,7 @@ module Solargraph
       @string_nodes ||= string_nodes_in(node)
     end
 
-    # @return [Array<Range>]
+    # @return [Array<Solargraph::Range>]
     def comment_ranges
       @comment_ranges ||= comments.values.map(&:range)
     end
@@ -386,6 +387,7 @@ module Solargraph
     # @return [Integer]
     attr_writer :version
 
+    # @return [void]
     def finalize
       return if @finalized && changes.empty?
 
@@ -440,6 +442,7 @@ module Solargraph
     # @return [String]
     attr_writer :repaired
 
+    # @return [String]
     def repaired
       finalize
       @repaired

data/lib/solargraph/source_map/clip.rb

@@ -11,7 +11,9 @@ module Solargraph
       def initialize api_map, cursor
         @api_map = api_map
         @cursor = cursor
-        block.rebind(api_map) if block.is_a?(Pin::Block)
+        block_pin = block
+        block_pin.rebind(api_map) if block_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(block_pin.receiver).contain?(cursor.range.start)
+        @in_block = nil
       end
 
       # @return [Array<Pin::Base>] Relevant pins for infering the type of the Cursor's position
@@ -63,7 +65,7 @@ module Solargraph
       # position. Locals can be local variables, method parameters, or block
       # parameters. The array starts with the nearest local pin.
       #
-      # @return [::Array<Solargraph::Pin::Base>]
+      # @return [::Array<Solargraph::Pin::LocalVariable>]
       def locals
         @locals ||= source_map.locals_at(location)
       end

data/lib/solargraph/source_map/data.rb

@@ -3,15 +3,18 @@
 module Solargraph
   class SourceMap
     class Data
+      # @param source [Solargraph::Source]
       def initialize source
         @source = source
       end
 
+      # @return [Array<Solargraph::Pin::Base>]
       def pins
         generate
         @pins || []
       end
 
+      # @return [Array<Solargraph::LocalVariable>]
       def locals
         generate
         @locals || []
@@ -19,6 +22,7 @@ module Solargraph
 
       private
 
+      # @return [void]
       def generate
         return if @generated
 

data/lib/solargraph/source_map/mapper.rb

@@ -41,7 +41,7 @@ module Solargraph
         s = Position.new(0, 0)
         e = Position.from_offset(code, code.length)
         location = Location.new(filename, Range.new(s, e))
-        [[Pin::Namespace.new(location: location, name: '')], []]
+        [[Pin::Namespace.new(location: location, name: '', source: :source_map)], []]
       end
 
       class << self
@@ -55,6 +55,7 @@ module Solargraph
 
       # @return [Array<Solargraph::Pin::Base>]
       def pins
+        # @type [Array<Solargraph::Pin::Base>]
         @pins ||= []
       end
 
@@ -69,6 +70,7 @@ module Solargraph
       # @param comment [String]
       # @return [void]
       def process_comment source_position, comment_position, comment
+        # @sg-ignore Wrong argument type for String#=~: object expected String::_MatchAgainst<String, undefined>, received Regexp
         return unless comment.encode('UTF-8', invalid: :replace, replace: '?') =~ DIRECTIVE_REGEXP
         cmnt = remove_inline_comment_hashes(comment)
         parse = Solargraph::Source.parse_docstring(cmnt)
@@ -140,7 +142,8 @@ module Solargraph
               scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
               visibility: :public,
               explicit: false,
-              attribute: true
+              attribute: true,
+              source: :source_map
             )
           end
           if t.nil? || t.include?('w')
@@ -151,16 +154,17 @@ module Solargraph
               comments: docstring.all.to_s,
               scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
               visibility: :public,
-              attribute: true
+              attribute: true,
+              source: :source_map
             )
             pins.push method_pin
-            method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
+            method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last, source: :source_map)
             if pins.last.return_type.defined?
               pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '), 'value')
             end
           end
         when 'visibility'
-          begin
+
             kind = directive.tag.text&.to_sym
             return unless [:private, :protected, :public].include?(kind)
 
@@ -179,7 +183,7 @@ module Solargraph
                 pin.instance_variable_set(:@visibility, kind)
               end
             end
-          end
+
         when 'parse'
           begin
             ns = closure_at(source_position)
@@ -205,7 +209,8 @@ module Solargraph
           namespace = closure_at(source_position) || Pin::ROOT_PIN
           namespace.domains.concat directive.tag.types unless directive.tag.types.nil?
         when 'override'
-          pins.push Pin::Reference::Override.new(location, directive.tag.name, docstring.tags)
+          pins.push Pin::Reference::Override.new(location, directive.tag.name, docstring.tags,
+                                                 source: :source_map)
         when 'macro'
           # @todo Handle macros
         end
@@ -240,6 +245,7 @@ module Solargraph
 
       # @return [void]
       def process_comment_directives
+        # @sg-ignore Wrong argument type for String#=~: object expected String::_MatchAgainst<String, undefined>, received Regexp
         return unless @code.encode('UTF-8', invalid: :replace, replace: '?') =~ DIRECTIVE_REGEXP
         code_lines = @code.lines
         @source.associated_comments.each do |line, comments|

data/lib/solargraph/source_map.rb

@@ -21,6 +21,11 @@ module Solargraph
       data.pins
     end
 
+    # @return [Array<Pin::Base>]
+    def all_pins
+      pins + convention_pins
+    end
+
     # @return [Array<Pin::LocalVariable>]
     def locals
       data.locals
@@ -30,13 +35,18 @@ module Solargraph
     def initialize source
       @source = source
 
-      environ.merge Convention.for_local(self) unless filename.nil?
-      self.convention_pins = environ.pins
+      conventions_environ.merge Convention.for_local(self) unless filename.nil?
+      # FIXME: unmemoizing the document_symbols in case it was called and memoized from any of conventions above
+      # this is to ensure that the convention_pins from all conventions are used in the document_symbols.
+      # solargraph-rails is known to use this method to get the document symbols. It should probably be removed.
+      @document_symbols = nil
+      self.convention_pins = conventions_environ.pins
       @pin_select_cache = {}
     end
 
-    # @param klass [Class]
-    # @return [Array<Pin::Base>]
+    # @generic T
+    # @param klass [Class<generic<T>>]
+    # @return [Array<generic<T>>]
     def pins_by_class klass
       @pin_select_cache[klass] ||= pin_class_hash.select { |key, _| key <= klass }.values.flatten
     end
@@ -67,8 +77,8 @@ module Solargraph
     end
 
     # @return [Environ]
-    def environ
-      @environ ||= Environ.new
+    def conventions_environ
+      @conventions_environ ||= Environ.new
     end
 
     # all pins except Solargraph::Pin::Reference::Reference
@@ -118,23 +128,6 @@ module Solargraph
       _locate_pin line, character, Pin::Namespace, Pin::Method, Pin::Block
     end
 
-    # @todo Candidate for deprecation
-    #
-    # @param other_map [SourceMap]
-    # @return [Boolean]
-    def try_merge! other_map
-      return false if pins.length != other_map.pins.length || locals.length != other_map.locals.length || requires.map(&:name).uniq.sort != other_map.requires.map(&:name).uniq.sort
-
-      pins.each_index do |i|
-        return false unless pins[i].try_merge!(other_map.pins[i])
-      end
-      locals.each_index do |i|
-        return false unless locals[i].try_merge!(other_map.locals[i])
-      end
-      @source = other_map.source
-      true
-    end
-
     # @param name [String]
     # @return [Array<Location>]
     def references name
@@ -175,10 +168,15 @@ module Solargraph
 
     private
 
+    # @return [Hash{Class => Array<Pin::Base>}]
+    # @return [Array<Pin::Base>]
+    attr_writer :convention_pins
+
     def pin_class_hash
       @pin_class_hash ||= pins.to_set.classify(&:class).transform_values(&:to_a)
     end
 
+    # @return [Data]
     def data
       @data ||= Data.new(source)
     end
@@ -188,14 +186,6 @@ module Solargraph
       @convention_pins || []
     end
 
-    # @param pins [Array<Pin::Base>]
-    # @return [Array<Pin::Base>]
-    def convention_pins=(pins)
-      # unmemoizing the document_symbols in case it was called from any of conventions
-      @document_symbols = nil
-      @convention_pins = pins
-    end
-
     # @param line [Integer]
     # @param character [Integer]
     # @param klasses [Array<Class>]

data/lib/solargraph/type_checker/checks.rb

@@ -50,6 +50,8 @@ module Solargraph
       # @param inferred [ComplexType]
       # @return [Boolean]
       def any_types_match? api_map, expected, inferred
+        expected = expected.downcast_to_literal_if_possible
+        inferred = inferred.downcast_to_literal_if_possible
         return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
         # walk through the union expected type and see if any members
         # of the union match the inferred type
@@ -71,6 +73,8 @@ module Solargraph
       # @param expected [ComplexType]
       # @return [Boolean]
       def all_types_match? api_map, inferred, expected
+        expected = expected.downcast_to_literal_if_possible
+        inferred = inferred.downcast_to_literal_if_possible
         return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
         inferred.each do |inf|
           next if inf.duck_type?