solargraph 0.58.3 → 0.60.4

data/lib/solargraph/complex_type.rb

@@ -4,11 +4,12 @@ module Solargraph
   # A container for type data based on YARD type tags.
   #
   class ComplexType
-    GENERIC_TAG_NAME = 'generic'.freeze
+    GENERIC_TAG_NAME = 'generic'
     # @!parse
     #   include TypeMethods
     include Equality
 
+    autoload :Conformance, 'solargraph/complex_type/conformance'
     autoload :TypeMethods, 'solargraph/complex_type/type_methods'
     autoload :UniqueType,  'solargraph/complex_type/unique_type'
 
@@ -18,39 +19,41 @@ module Solargraph
       # @type [Array<UniqueType>]
       items = types.flat_map(&:items).uniq(&:to_s)
       if items.any? { |i| i.name == 'false' } && items.any? { |i| i.name == 'true' }
-        items.delete_if { |i| i.name == 'false' || i.name == 'true' }
-        items.unshift(ComplexType::BOOLEAN)
+        items.delete_if { |i| %w[false true].include?(i.name) }
+        items.unshift(UniqueType::BOOLEAN)
       end
+      # @type [Array<UniqueType>]
       items = [UniqueType::UNDEFINED] if items.any?(&:undefined?)
+      # @todo shouldn't need this cast - if statement above adds an 'Array' type
+      # @type [Array<UniqueType>]
       @items = items
     end
 
-    # @sg-ignore Fix "Not enough arguments to Module#protected"
-    protected def equality_fields
-      [self.class, items]
-    end
-
     # @param api_map [ApiMap]
-    # @param context [String]
+    # @param gates [Array<String>]
+    #
     # @return [ComplexType]
     def qualify api_map, *gates
       red = reduce_object
       types = red.items.map do |t|
-        next t if ['nil', 'void', 'undefined'].include?(t.name)
+        next t if %w[nil void undefined].include?(t.name)
         next t if ['::Boolean'].include?(t.rooted_name)
-        t.qualify api_map, *gates
+        api_map.unalias(t.name) || t.qualify(api_map, *gates)
       end
       ComplexType.new(types).reduce_object
     end
 
     # @param generics_to_resolve [Enumerable<String>]]
-    # @param context_type [UniqueType, nil]
+    # @param context_type [ComplexType, ComplexType::UniqueType, nil]
     # @param resolved_generic_values [Hash{String => ComplexType}] Added to as types are encountered or resolved
     # @return [self]
     def resolve_generics_from_context generics_to_resolve, context_type, resolved_generic_values: {}
       return self unless generic?
 
-      ComplexType.new(@items.map { |i| i.resolve_generics_from_context(generics_to_resolve, context_type, resolved_generic_values: resolved_generic_values) })
+      ComplexType.new(@items.map do |i|
+        i.resolve_generics_from_context(generics_to_resolve, context_type,
+                                        resolved_generic_values: resolved_generic_values)
+      end)
     end
 
     # @return [UniqueType]
@@ -65,7 +68,7 @@ module Solargraph
        (@items.length > 1 ? ')' : ''))
     end
 
-    # @param dst [ComplexType]
+    # @param dst [ComplexType, ComplexType::UniqueType]
     # @return [ComplexType]
     def self_to_type dst
       object_type_dst = dst.reduce_class_type
@@ -76,15 +79,19 @@ module Solargraph
     end
 
     # @yieldparam [UniqueType]
+    # @yieldreturn [UniqueType]
     # @return [Array<UniqueType>]
+    # @sg-ignore Declared return type
+    #   ::Array<::Solargraph::ComplexType::UniqueType> does not match
+    #   inferred type ::Array<::Proc> for Solargraph::ComplexType#map
     def map &block
-      @items.map &block
+      @items.map(&block)
     end
 
     # @yieldparam [UniqueType]
     # @return [Enumerable<UniqueType>]
     def each &block
-      @items.each &block
+      @items.each(&block)
     end
 
     # @yieldparam [UniqueType]
@@ -95,23 +102,17 @@ module Solargraph
       return enum_for(__method__) unless block_given?
 
       @items.each do |item|
-        item.each_unique_type &block
+        item.each_unique_type(&block)
       end
     end
 
-    # @param atype [ComplexType] type which may be assigned to this type
-    # @param api_map [ApiMap] The ApiMap that performs qualification
-    def can_assign?(api_map, atype)
-      any? { |ut| ut.can_assign?(api_map, atype) }
-    end
-
     # @param new_name [String, nil]
     # @param make_rooted [Boolean, nil]
     # @param new_key_types [Array<ComplexType>, nil]
-    # @param rooted [Boolean, nil]
+    # @param make_rooted [Boolean, nil]
     # @param new_subtypes [Array<ComplexType>, nil]
     # @return [self]
-    def recreate(new_name: nil, make_rooted: nil, new_key_types: nil, new_subtypes: nil)
+    def recreate new_name: nil, make_rooted: nil, new_key_types: nil, new_subtypes: nil
       ComplexType.new(map do |ut|
                         ut.recreate(new_name: new_name,
                                     make_rooted: make_rooted,
@@ -132,13 +133,13 @@ module Solargraph
 
     # @param index [Integer]
     # @return [UniqueType]
-    def [](index)
+    def [] index
       @items[index]
     end
 
     # @return [Array<UniqueType>]
     def select &block
-      @items.select &block
+      @items.select(&block)
     end
 
     # @return [String]
@@ -153,7 +154,9 @@ module Solargraph
     end
 
     # @param name [Symbol]
+    #
     # @return [Object, nil]
+    # @param [Array<Object>] args
     def method_missing name, *args, &block
       return if @items.first.nil?
       return @items.first.send(name, *args, &block) if respond_to_missing?(name)
@@ -162,8 +165,8 @@ module Solargraph
 
     # @param name [Symbol]
     # @param include_private [Boolean]
-    def respond_to_missing?(name, include_private = false)
-      TypeMethods.public_instance_methods.include?(name) || super
+    def respond_to_missing? name, include_private = false
+      TypeMethods.public_method_defined?(name) || super
     end
 
     def to_s
@@ -186,6 +189,7 @@ module Solargraph
 
     # @return [ComplexType]
     def downcast_to_literal_if_possible
+      return self
       ComplexType.new(items.map(&:downcast_to_literal_if_possible))
     end
 
@@ -194,6 +198,78 @@ module Solargraph
       rooted_tags
     end
 
+    # @param api_map [ApiMap]
+    # @param expected [ComplexType, ComplexType::UniqueType]
+    # @param situation [:method_call, :return_type, :assignment]
+    # @param rules [Array<:allow_subtype_skew, :allow_empty_params, :allow_reverse_match, :allow_any_match, :allow_undefined, :allow_unresolved_generic, :allow_unmatched_interface>]
+    #
+    #   allow_subtype_skew: if not provided, check if any subtypes of
+    #     the expected type match the inferred type
+    #
+    #   allow_reverse_match: check if any subtypes
+    #     of the expected type match the inferred type
+    #
+    #   allow_empty_params: allow a general inferred type without
+    #     parameters to conform to a more specific expected type
+    #
+    #   allow_any_match: any unique type matched in the inferred
+    #     qualifies as a match
+    #
+    #   allow_undefined: treat undefined as a wildcard that matches
+    #     anything
+    #
+    # @param variance [:invariant, :covariant, :contravariant]
+    # @return [Boolean]
+    def conforms_to? api_map, expected,
+                     situation,
+                     rules = [],
+                     variance: erased_variance(situation)
+      expected = expected.downcast_to_literal_if_possible
+      inferred = downcast_to_literal_if_possible
+
+      return duck_types_match?(api_map, expected, inferred, rules) if expected.duck_type?
+
+      if rules.include? :allow_any_match
+        inferred.any? do |inf|
+          inf.conforms_to?(api_map, expected, situation, rules,
+                           variance: variance)
+        end
+      else
+        inferred.all? do |inf|
+          inf.conforms_to?(api_map, expected, situation, rules,
+                           variance: variance)
+        end
+      end
+    end
+
+    # @param api_map [ApiMap]
+    # @param expected [ComplexType, UniqueType]
+    # @param inferred [ComplexType, UniqueType]
+    # @param rules [Array<Symbol>]
+    # @return [Boolean]
+    def duck_types_match? api_map, expected, inferred, rules = []
+      raise ArgumentError, 'Expected type must be duck type' unless expected.duck_type?
+      allow_any_match = rules.include?(:allow_any_match)
+      expected.each do |exp|
+        next unless exp.duck_type?
+        quack = exp.to_s[1..] || ''
+        matched = allow_any_match ? inferred.any? { |inf| duck_type_provides?(api_map, inf, quack) } : inferred.all? { |inf| duck_type_provides?(api_map, inf, quack) }
+        return false unless matched
+      end
+      true
+    end
+
+    # @param api_map [ApiMap]
+    # @param inf [UniqueType]
+    # @param quack [String]
+    # @return [Boolean]
+    def duck_type_provides? api_map, inf, quack
+      return true if inf.duck_type? && inf.to_s[1..] == quack
+
+      !api_map.get_method_stack(inf.namespace, quack, scope: inf.scope).empty?
+    end
+    private :duck_type_provides?
+
     # @return [String]
     def rooted_tags
       map(&:rooted_tag).join(', ')
@@ -201,14 +277,14 @@ module Solargraph
 
     # @yieldparam [UniqueType]
     def all? &block
-      @items.all? &block
+      @items.all?(&block)
     end
 
     # @yieldparam [UniqueType]
     # @yieldreturn [Boolean]
     # @return [Boolean]
     def any? &block
-      @items.compact.any? &block
+      @items.compact.any?(&block)
     end
 
     def selfy?
@@ -228,11 +304,17 @@ module Solargraph
     # @yieldparam t [UniqueType]
     # @yieldreturn [UniqueType]
     # @return [ComplexType]
-    def transform(new_name = nil, &transform_type)
-      raise "Please remove leading :: and set rooted with recreate() instead - #{new_name}" if new_name&.start_with?('::')
+    def transform new_name = nil, &transform_type
+      if new_name&.start_with?('::')
+        raise "Please remove leading :: and set rooted with recreate() instead - #{new_name}"
+      end
       ComplexType.new(map { |ut| ut.transform(new_name, &transform_type) })
     end
 
+    def expand named_types
+      ComplexType.new(map { |ut| ut.expand(named_types) })
+    end
+
     # @return [self]
     def force_rooted
       transform do |t|
@@ -252,6 +334,13 @@ module Solargraph
       @items.any?(&:nil_type?)
     end
 
+    # @return [ComplexType]
+    def without_nil
+      new_items = @items.reject(&:nil_type?)
+      return ComplexType::UNDEFINED if new_items.empty?
+      ComplexType.new(new_items)
+    end
+
     # @return [Array<ComplexType>]
     def all_params
       @items.first.all_params || []
@@ -260,7 +349,7 @@ module Solargraph
     # @return [ComplexType]
     def reduce_class_type
       new_items = items.flat_map do |type|
-        next type unless ['Module', 'Class'].include?(type.name)
+        next type unless %w[Module Class].include?(type.name)
         next type if type.all_params.empty?
 
         type.all_params
@@ -274,6 +363,13 @@ module Solargraph
       all?(&:all_rooted?)
     end
 
+    # @param other [ComplexType, UniqueType]
+    def erased_version_of? other
+      return false if items.length != 1 || other.items.length != 1
+
+      @items.first.erased_version_of?(other.items.first)
+    end
+
     # every top-level type has resolved to be fully qualified; see
     # #all_rooted? to check their subtypes as well
     def rooted?
@@ -282,12 +378,46 @@ module Solargraph
 
     attr_reader :items
 
-    def rooted?
-      @items.all?(&:rooted?)
+    # @param exclude_types [ComplexType, nil]
+    # @param api_map [ApiMap]
+    # @return [ComplexType, self]
+    def exclude exclude_types, api_map
+      return self if exclude_types.nil?
+
+      types = items - exclude_types.items
+      types = [ComplexType::UniqueType::UNDEFINED] if types.empty?
+      ComplexType.new(types)
+    end
+
+    # @see https://en.wikipedia.org/wiki/Intersection_type
+    #
+    # @param intersection_type [ComplexType, ComplexType::UniqueType, nil]
+    # @param api_map [ApiMap]
+    # @return [self, ComplexType::UniqueType]
+    def intersect_with intersection_type, api_map
+      return self if intersection_type.nil?
+      return intersection_type if undefined?
+      types = []
+      # try to find common types via conformance
+      items.each do |ut|
+        intersection_type.each do |int_type|
+          if int_type.conforms_to?(api_map, ut, :assignment)
+            types << int_type
+          elsif ut.conforms_to?(api_map, int_type, :assignment)
+            types << ut
+          end
+        end
+      end
+      types = [ComplexType::UniqueType::UNDEFINED] if types.empty?
+      ComplexType.new(types)
     end
 
     protected
 
+    def equality_fields
+      [self.class, items]
+    end
+
     # @return [ComplexType]
     def reduce_object
       new_items = items.flat_map do |ut|
@@ -307,30 +437,29 @@ module Solargraph
       # @example
       #   ComplexType.parse 'String', 'Foo', 'nil' #=> [String, Foo, nil]
       #
-      # @note
-      #   The `partial` parameter is used to indicate that the method is
-      #   receiving a string that will be used inside another ComplexType.
-      #   It returns arrays of ComplexTypes instead of a single cohesive one.
-      #   Consumers should not need to use this parameter; it should only be
-      #   used internally.
-      #
+      # @param partial [Boolean] if true, method is receiving a string
+      #   that will be used inside another ComplexType.  It returns
+      #   arrays of ComplexTypes instead of a single cohesive one.
+      #   Consumers should not need to use this parameter; it should
+      #   only be used internally.
       # @param strings [Array<String>] The type definitions to parse
       # @return [ComplexType]
       # # @overload parse(*strings, partial: false)
       # #  @todo Need ability to use a literal true as a type below
       # #  @param partial [Boolean] True if the string is part of a another type
       # #  @return [Array<UniqueType>]
-      # @todo To be able to select the right signature above,
+      # @sg-ignore To be able to select the right signature above,
       #   Chain::Call needs to know the decl type (:arg, :optarg,
       #   :kwarg, etc) of the arguments given, instead of just having
       #   an array of Chains as the arguments.
       def parse *strings, partial: false
-        # @type [Hash{Array<String> => ComplexType}]
+        # @type [Hash{Array<String> => ComplexType, Array<ComplexType::UniqueType>}]
         @cache ||= {}
         unless partial
           cached = @cache[strings]
           return cached unless cached.nil?
         end
+        # @types [Array<ComplexType::UniqueType>]
         types = []
         key_types = nil
         strings.each do |type_string|
@@ -342,15 +471,16 @@ module Solargraph
           # @param char [String]
           type_string&.each_char do |char|
             if char == '='
-              #raise ComplexTypeError, "Invalid = in type #{type_string}" unless curly_stack > 0
+              # raise ComplexTypeError, "Invalid = in type #{type_string}" unless curly_stack > 0
             elsif char == '<'
               point_stack += 1
             elsif char == '>'
-              if subtype_string.end_with?('=') && curly_stack > 0
+              if subtype_string.end_with?('=') && curly_stack.positive?
                 subtype_string += char
               elsif base.end_with?('=')
-                raise ComplexTypeError, "Invalid hash thing" unless key_types.nil?
+                raise ComplexTypeError, 'Invalid hash thing' unless key_types.nil?
                 # types.push ComplexType.new([UniqueType.new(base[0..-2].strip)])
+                # @sg-ignore Need to add nil check here
                 types.push UniqueType.parse(base[0..-2].strip, subtype_string)
                 # @todo this should either expand key_type's type
                 #   automatically or complain about not being
@@ -361,7 +491,7 @@ module Solargraph
                 subtype_string.clear
                 next
               else
-                raise ComplexTypeError, "Invalid close in type #{type_string}" if point_stack == 0
+                raise ComplexTypeError, "Invalid close in type #{type_string}" if point_stack.zero?
                 point_stack -= 1
                 subtype_string += char
               end
@@ -371,34 +501,37 @@ module Solargraph
             elsif char == '}'
               curly_stack -= 1
               subtype_string += char
-              raise ComplexTypeError, "Invalid close in type #{type_string}" if curly_stack < 0
+              raise ComplexTypeError, "Invalid close in type #{type_string}" if curly_stack.negative?
               next
             elsif char == '('
               paren_stack += 1
             elsif char == ')'
               paren_stack -= 1
               subtype_string += char
-              raise ComplexTypeError, "Invalid close in type #{type_string}" if paren_stack < 0
+              raise ComplexTypeError, "Invalid close in type #{type_string}" if paren_stack.negative?
               next
-            elsif char == ',' && point_stack == 0 && curly_stack == 0 && paren_stack == 0
+            elsif char == ',' && point_stack.zero? && curly_stack.zero? && paren_stack.zero?
               # types.push ComplexType.new([UniqueType.new(base.strip, subtype_string.strip)])
               types.push UniqueType.parse(base.strip, subtype_string.strip)
               base.clear
               subtype_string.clear
               next
             end
-            if point_stack == 0 && curly_stack == 0 && paren_stack == 0
+            if point_stack.zero? && curly_stack.zero? && paren_stack.zero?
               base.concat char
             else
               subtype_string.concat char
             end
           end
-          raise ComplexTypeError, "Unclosed subtype in #{type_string}" if point_stack != 0 || curly_stack != 0 || paren_stack != 0
+          if point_stack != 0 || curly_stack != 0 || paren_stack != 0
+            raise ComplexTypeError,
+                  "Unclosed subtype in #{type_string}"
+          end
           # types.push ComplexType.new([UniqueType.new(base, subtype_string)])
           types.push UniqueType.parse(base.strip, subtype_string.strip)
         end
         unless key_types.nil?
-          raise ComplexTypeError, "Invalid use of key/value parameters" unless partial
+          raise ComplexTypeError, 'Invalid use of key/value parameters' unless partial
           return key_types if types.empty?
           return [key_types, types]
         end
@@ -410,7 +543,7 @@ module Solargraph
       # @param strings [Array<String>]
       # @return [ComplexType]
       def try_parse *strings
-        parse *strings
+        parse(*strings)
       rescue ComplexTypeError => e
         Solargraph.logger.info "Error parsing complex type `#{strings.join(', ')}`: #{e.message}"
         ComplexType::UNDEFINED
@@ -435,9 +568,7 @@ module Solargraph
     # @param dst [String]
     # @return [String]
     def reduce_class dst
-      while dst =~ /^(Class|Module)\<(.*?)\>$/
-        dst = dst.sub(/^(Class|Module)\</, '').sub(/\>$/, '')
-      end
+      dst = dst.sub(/^(Class|Module)</, '').sub(/>$/, '') while dst =~ /^(Class|Module)<(.*?)>$/
       dst
     end
   end