solargraph 0.58.3 → 0.59.2

data/lib/solargraph/complex_type/conformance.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class ComplexType
+    # Checks whether a type can be used in a given situation
+    class Conformance
+      # @param api_map [ApiMap]
+      # @param inferred [ComplexType::UniqueType]
+      # @param expected [ComplexType::UniqueType]
+      # @param situation [:method_call, :return_type]
+      # @param rules [Array<:allow_subtype_skew, :allow_empty_params, :allow_reverse_match,
+      #   :allow_any_match, :allow_undefined, :allow_unresolved_generic,
+      #   :allow_unmatched_interface>]
+      # @param variance [:invariant, :covariant, :contravariant]
+      def initialize api_map, inferred, expected,
+                     situation = :method_call, rules = [],
+                     variance: inferred.erased_variance(situation)
+        @api_map = api_map
+        @inferred = inferred
+        @expected = expected
+        @situation = situation
+        @rules = rules
+        @variance = variance
+        # :nocov:
+        unless expected.is_a?(UniqueType)
+          # @sg-ignore This should never happen and the typechecker is angry about it
+          raise "Expected type must be a UniqueType, got #{expected.class} in #{expected.inspect}"
+        end
+        # :nocov:
+        return if inferred.is_a?(UniqueType)
+        # :nocov:
+        # @sg-ignore This should never happen and the typechecker is angry about it
+        raise "Inferred type must be a UniqueType, got #{inferred.class} in #{inferred.inspect}"
+        # :nocov:
+      end
+
+      def conforms_to_unique_type?
+        unless expected.is_a?(UniqueType)
+          # :nocov:
+          raise "Expected type must be a UniqueType, got #{expected.class} in #{expected.inspect}"
+          # :nocov:
+        end
+
+        return true if ignore_interface?
+        return true if conforms_via_reverse_match?
+
+        downcast_inferred = inferred.downcast_to_literal_if_possible
+        downcast_expected = expected.downcast_to_literal_if_possible
+        if (downcast_inferred.name != inferred.name) || (downcast_expected.name != expected.name)
+          return with_new_types(downcast_inferred, downcast_expected).conforms_to_unique_type?
+        end
+
+        if rules.include?(:allow_subtype_skew) && !expected.all_params.empty?
+          # parameters are not considered in this case
+          return with_new_types(inferred, expected.erase_parameters).conforms_to_unique_type?
+        end
+
+        return with_new_types(inferred.erase_parameters, expected).conforms_to_unique_type? if only_inferred_parameters?
+
+        return conforms_via_stripped_expected_parameters? if can_strip_expected_parameters?
+
+        return true if inferred == expected
+
+        return false unless erased_type_conforms?
+
+        return true if inferred.all_params.empty? && rules.include?(:allow_empty_params)
+
+        # at this point we know the erased type is fine - time to look at parameters
+
+        # there's an implicit 'any' on the expectation parameters
+        # if there are none specified
+        return true if expected.all_params.empty?
+
+        return false unless key_types_conform?
+
+        subtypes_conform?
+      end
+
+      private
+
+      def only_inferred_parameters?
+        !expected.parameters? && inferred.parameters?
+      end
+
+      def conforms_via_stripped_expected_parameters?
+        with_new_types(inferred, expected.erase_parameters).conforms_to_unique_type?
+      end
+
+      def ignore_interface?
+        (expected.any?(&:interface?) && rules.include?(:allow_unmatched_interface)) ||
+          (inferred.interface? && rules.include?(:allow_unmatched_interface))
+      end
+
+      def can_strip_expected_parameters?
+        expected.parameters? && !inferred.parameters? && rules.include?(:allow_empty_params)
+      end
+
+      def conforms_via_reverse_match?
+        return false unless rules.include? :allow_reverse_match
+
+        expected.conforms_to?(api_map, inferred, situation,
+                              rules - [:allow_reverse_match],
+                              variance: variance)
+      end
+
+      def erased_type_conforms?
+        case variance
+        when :invariant
+          return false unless inferred.name == expected.name
+        when :covariant
+          # covariant: we can pass in a more specific type
+          # we contain the expected mix-in, or we have a more specific type
+          return false unless api_map.type_include?(inferred.name, expected.name) ||
+                              api_map.super_and_sub?(expected.name, inferred.name) ||
+                              inferred.name == expected.name
+        when :contravariant
+          # contravariant: we can pass in a more general type
+          # we contain the expected mix-in, or we have a more general type
+          return false unless api_map.type_include?(inferred.name, expected.name) ||
+                              api_map.super_and_sub?(inferred.name, expected.name) ||
+                              inferred.name == expected.name
+        else
+          # :nocov:
+          raise "Unknown variance: #{variance.inspect}"
+          # :nocov:
+        end
+        true
+      end
+
+      def key_types_conform?
+        return true if expected.key_types.empty?
+
+        return false if inferred.key_types.empty?
+
+        unless ComplexType.new(inferred.key_types).conforms_to?(api_map,
+                                                                ComplexType.new(expected.key_types),
+                                                                situation,
+                                                                rules,
+                                                                variance: inferred.parameter_variance(situation))
+          return false
+        end
+
+        true
+      end
+
+      def subtypes_conform?
+        return true if expected.subtypes.empty?
+
+        return true if expected.subtypes.any?(&:undefined?) && rules.include?(:allow_undefined)
+
+        return true if inferred.subtypes.any?(&:undefined?) && rules.include?(:allow_undefined)
+
+        return true if inferred.subtypes.all?(&:generic?) && rules.include?(:allow_unresolved_generic)
+
+        return true if expected.subtypes.all?(&:generic?) && rules.include?(:allow_unresolved_generic)
+
+        return false if inferred.subtypes.empty?
+
+        ComplexType.new(inferred.subtypes).conforms_to?(api_map,
+                                                        ComplexType.new(expected.subtypes),
+                                                        situation,
+                                                        rules,
+                                                        variance: inferred.parameter_variance(situation))
+      end
+
+      # @return [self]
+      # @param inferred [ComplexType::UniqueType]
+      # @param expected [ComplexType::UniqueType]
+      def with_new_types inferred, expected
+        self.class.new(api_map, inferred, expected, situation, rules, variance: variance)
+      end
+
+      attr_reader :api_map, :inferred, :expected, :situation, :rules, :variance
+    end
+  end
+end

data/lib/solargraph/complex_type/type_methods.rb

@@ -43,8 +43,9 @@ module Solargraph
         @rooted_tag ||= rooted_name + rooted_substring
       end
 
+      # Whether this is an RBS interface like _ToAry or Hash::_Key.
       def interface?
-        name.start_with?('_')
+        name.start_with?('_') || name.include?('::_')
       end
 
       # @return [Boolean]
@@ -54,11 +55,12 @@ module Solargraph
 
       # @return [Boolean]
       def nil_type?
-        @nil_type ||= (name.casecmp('nil') == 0)
+        @nil_type ||= name.casecmp('nil').zero?
       end
 
       def tuple?
-        @tuple_type ||= (name == 'Tuple') || (name == 'Array' && subtypes.length >= 1 && fixed_parameters?)
+        return false
+        @tuple ||= (name == 'Tuple') || (name == 'Array' && subtypes.length >= 1 && fixed_parameters?)
       end
 
       def void?
@@ -73,9 +75,21 @@ module Solargraph
         name == 'undefined'
       end
 
+      # Variance of the type ignoring any type parameters
+      # @return [Symbol]
+      # @param situation [Symbol] The situation in which the variance is being considered.
+      def erased_variance situation = :method_call
+        # :nocov:
+        unless %i[method_call return_type assignment].include?(situation)
+          raise "Unknown situation: #{situation.inspect}"
+        end
+        # :nocov:
+        :covariant
+      end
+
       # @param generics_to_erase [Enumerable<String>]
       # @return [self]
-      def erase_generics(generics_to_erase)
+      def erase_generics generics_to_erase
         transform do |type|
           if type.name == ComplexType::GENERIC_TAG_NAME
             if type.all_params.length == 1 && generics_to_erase.include?(type.all_params.first.to_s)
@@ -130,7 +144,7 @@ module Solargraph
         @namespace ||= lambda do
           return 'Object' if duck_type?
           return 'NilClass' if nil_type?
-          return (name == 'Class' || name == 'Module') && !subtypes.empty? ? subtypes.first.name : name
+          %w[Class Module].include?(name) && !subtypes.empty? ? subtypes.first.name : name
         end.call
       end
 
@@ -138,7 +152,7 @@ module Solargraph
       def namespace_type
         return ComplexType.parse('::Object') if duck_type?
         return ComplexType.parse('::NilClass') if nil_type?
-        return subtypes.first if (name == 'Class' || name == 'Module') && !subtypes.empty?
+        return subtypes.first if %w[Class Module].include?(name) && !subtypes.empty?
         self
       end
 
@@ -165,36 +179,33 @@ module Solargraph
       end
 
       # @return [String]
-      def generate_substring_from(&to_str)
+      def generate_substring_from &to_str
         key_types_str = key_types.map(&to_str).join(', ')
         subtypes_str = subtypes.map(&to_str).join(', ')
-        if key_types.none?(&:defined?) && subtypes.none?(&:defined?)
-          ''
-        elsif key_types.empty? && subtypes.empty?
+        if (key_types.none?(&:defined?) && subtypes.none?(&:defined?)) ||
+           (key_types.empty? && subtypes.empty?)
           ''
         elsif hash_parameters?
           "{#{key_types_str} => #{subtypes_str}}"
         elsif fixed_parameters?
           "(#{subtypes_str})"
+        elsif name == 'Hash'
+          "<#{key_types_str}, #{subtypes_str}>"
         else
-          if name == 'Hash'
-            "<#{key_types_str}, #{subtypes_str}>"
-          else
-            "<#{key_types_str}#{subtypes_str}>"
-          end
+          "<#{key_types_str}#{subtypes_str}>"
         end
       end
 
       # @return [::Symbol] :class or :instance
       def scope
         @scope ||= :instance if duck_type? || nil_type?
-        @scope ||= (name == 'Class' || name == 'Module') && !subtypes.empty? ? :class : :instance
+        @scope ||= %w[Class Module].include?(name) && !subtypes.empty? ? :class : :instance
       end
 
       # @param other [Object]
       def == other
         return false unless self.class == other.class
-        # @sg-ignore https://github.com/castwide/solargraph/pull/1114
+        # @sg-ignore flow sensitive typing should support .class == .class
         tag == other.tag
       end
 
@@ -218,7 +229,9 @@ module Solargraph
       end
 
       # @yieldparam [UniqueType]
-      # @return [Enumerator<UniqueType>]
+      # @return [void]
+      # @overload each_unique_type()
+      #   @return [Enumerator<UniqueType>]
       def each_unique_type &block
         return enum_for(__method__) unless block_given?
         yield self