solargraph 0.58.1 → 0.59.0.dev.1

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

@@ -1,228 +1,242 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class ComplexType
-    # Methods for accessing type data available from
-    # both ComplexType and UniqueType.
-    #
-    # @abstract This mixin relies on these -
-    #   instance variables:
-    #     @name: String
-    #     @subtypes: Array<ComplexType>
-    #     @rooted: boolish
-    #   methods:
-    #     transform()
-    #     all_params()
-    #     rooted?()
-    #     can_root_name?()
-    module TypeMethods
-      # @!method transform(new_name = nil, &transform_type)
-      #   @param new_name [String, nil]
-      #   @yieldparam t [UniqueType]
-      #   @yieldreturn [UniqueType]
-      #   @return [UniqueType, nil]
-      # @!method all_params
-      #   @return [Array<ComplexType>]
-      # @!method rooted?
-      # @!method can_root_name?(name_to_check = nil)
-      #   @param name_to_check [String, nil]
-
-      # @return [String]
-      attr_reader :name
-
-      # @return [Array<ComplexType>]
-      attr_reader :subtypes
-
-      # @return [String]
-      def tag
-        @tag ||= "#{name}#{substring}"
-      end
-
-      # @return [String]
-      def rooted_tag
-        @rooted_tag ||= rooted_name + rooted_substring
-      end
-
-      def interface?
-        name.start_with?('_')
-      end
-
-      # @return [Boolean]
-      def duck_type?
-        @duck_type ||= name.start_with?('#')
-      end
-
-      # @return [Boolean]
-      def nil_type?
-        @nil_type ||= (name.casecmp('nil') == 0)
-      end
-
-      def tuple?
-        @tuple_type ||= (name == 'Tuple') || (name == 'Array' && subtypes.length >= 1 && fixed_parameters?)
-      end
-
-      def void?
-        name == 'void'
-      end
-
-      def defined?
-        !undefined?
-      end
-
-      def undefined?
-        name == 'undefined'
-      end
-
-      # @param generics_to_erase [Enumerable<String>]
-      # @return [self]
-      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)
-              ComplexType::UNDEFINED
-            else
-              type
-            end
-          else
-            type
-          end
-        end
-      end
-
-      # @return [Symbol, nil]
-      attr_reader :parameters_type
-
-      # @type [Hash{String => Symbol}]
-      PARAMETERS_TYPE_BY_STARTING_TAG = {
-        '{' => :hash,
-        '(' => :fixed,
-        '<' => :list
-      }.freeze
-
-      # @return [Boolean]
-      def list_parameters?
-        parameters_type == :list
-      end
-
-      # @return [Boolean]
-      def fixed_parameters?
-        parameters_type == :fixed
-      end
-
-      # @return [Boolean]
-      def hash_parameters?
-        parameters_type == :hash
-      end
-
-      # @return [Array<ComplexType>]
-      def value_types
-        @subtypes
-      end
-
-      # @return [Array<ComplexType>]
-      def key_types
-        @key_types
-      end
-
-      # @return [String]
-      def namespace
-        # if priority higher than ||=, old implements cause unnecessary check
-        @namespace ||= lambda do
-          return 'Object' if duck_type?
-          return 'NilClass' if nil_type?
-          return (name == 'Class' || name == 'Module') && !subtypes.empty? ? subtypes.first.name : name
-        end.call
-      end
-
-      # @return [self]
-      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?
-        self
-      end
-
-      # @return [String]
-      def rooted_namespace
-        return namespace unless rooted? && can_root_name?(namespace)
-        "::#{namespace}"
-      end
-
-      # @return [String]
-      def rooted_name
-        return name unless @rooted && can_root_name?
-        "::#{name}"
-      end
-
-      # @return [String]
-      def substring
-        @substring ||= generate_substring_from(&:tags)
-      end
-
-      # @return [String]
-      def rooted_substring
-        @rooted_substring = generate_substring_from(&:rooted_tags)
-      end
-
-      # @return [String]
-      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?
-          ''
-        elsif hash_parameters?
-          "{#{key_types_str} => #{subtypes_str}}"
-        elsif fixed_parameters?
-          "(#{subtypes_str})"
-        else
-          if name == 'Hash'
-            "<#{key_types_str}, #{subtypes_str}>"
-          else
-            "<#{key_types_str}#{subtypes_str}>"
-          end
-        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
-      end
-
-      # @param other [Object]
-      def == other
-        return false unless self.class == other.class
-        # @sg-ignore https://github.com/castwide/solargraph/pull/1114
-        tag == other.tag
-      end
-
-      # Generate a ComplexType that fully qualifies this type's namespaces.
-      #
-      # @param api_map [ApiMap] The ApiMap that performs qualification
-      # @param context [String] The namespace from which to resolve names
-      # @return [self, ComplexType, UniqueType] The generated ComplexType
-      def qualify api_map, context = ''
-        transform do |t|
-          next t if t.name == GENERIC_TAG_NAME
-          next t if t.duck_type? || t.void? || t.undefined?
-          recon = (t.rooted? ? '' : context)
-          fqns = api_map.qualify(t.name, recon)
-          if fqns.nil?
-            next UniqueType::BOOLEAN if t.tag == 'Boolean'
-            next UniqueType::UNDEFINED
-          end
-          t.recreate(new_name: fqns, make_rooted: true)
-        end
-      end
-
-      # @yieldparam [UniqueType]
-      # @return [Enumerator<UniqueType>]
-      def each_unique_type &block
-        return enum_for(__method__) unless block_given?
-        yield self
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class ComplexType
+    # Methods for accessing type data available from
+    # both ComplexType and UniqueType.
+    #
+    # @abstract This mixin relies on these -
+    #   instance variables:
+    #     @name: String
+    #     @subtypes: Array<ComplexType>
+    #     @rooted: boolish
+    #   methods:
+    #     transform()
+    #     all_params()
+    #     rooted?()
+    #     can_root_name?()
+    module TypeMethods
+      # @!method transform(new_name = nil, &transform_type)
+      #   @param new_name [String, nil]
+      #   @yieldparam t [UniqueType]
+      #   @yieldreturn [UniqueType]
+      #   @return [UniqueType, nil]
+      # @!method all_params
+      #   @return [Array<ComplexType>]
+      # @!method rooted?
+      # @!method can_root_name?(name_to_check = nil)
+      #   @param name_to_check [String, nil]
+
+      # @return [String]
+      attr_reader :name
+
+      # @return [Array<ComplexType>]
+      attr_reader :subtypes
+
+      # @return [String]
+      def tag
+        @tag ||= "#{name}#{substring}"
+      end
+
+      # @return [String]
+      def rooted_tag
+        @rooted_tag ||= rooted_name + rooted_substring
+      end
+
+      def interface?
+        name.start_with?('_')
+      end
+
+      # @return [Boolean]
+      def duck_type?
+        @duck_type ||= name.start_with?('#')
+      end
+
+      # @return [Boolean]
+      def nil_type?
+        @nil_type ||= (name.casecmp('nil') == 0)
+      end
+
+      def tuple?
+        @tuple_type ||= (name == 'Tuple') || (name == 'Array' && subtypes.length >= 1 && fixed_parameters?)
+      end
+
+      def void?
+        name == 'void'
+      end
+
+      def defined?
+        !undefined?
+      end
+
+      def undefined?
+        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)
+        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)
+              ComplexType::UNDEFINED
+            else
+              type
+            end
+          else
+            type
+          end
+        end
+      end
+
+      # @return [Symbol, nil]
+      attr_reader :parameters_type
+
+      # @type [Hash{String => Symbol}]
+      PARAMETERS_TYPE_BY_STARTING_TAG = {
+        '{' => :hash,
+        '(' => :fixed,
+        '<' => :list
+      }.freeze
+
+      # @return [Boolean]
+      def list_parameters?
+        parameters_type == :list
+      end
+
+      # @return [Boolean]
+      def fixed_parameters?
+        parameters_type == :fixed
+      end
+
+      # @return [Boolean]
+      def hash_parameters?
+        parameters_type == :hash
+      end
+
+      # @return [Array<ComplexType>]
+      def value_types
+        @subtypes
+      end
+
+      # @return [Array<ComplexType>]
+      def key_types
+        @key_types
+      end
+
+      # @return [String]
+      def namespace
+        # if priority higher than ||=, old implements cause unnecessary check
+        @namespace ||= lambda do
+          return 'Object' if duck_type?
+          return 'NilClass' if nil_type?
+          return (name == 'Class' || name == 'Module') && !subtypes.empty? ? subtypes.first.name : name
+        end.call
+      end
+
+      # @return [self]
+      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?
+        self
+      end
+
+      # @return [String]
+      def rooted_namespace
+        return namespace unless rooted? && can_root_name?(namespace)
+        "::#{namespace}"
+      end
+
+      # @return [String]
+      def rooted_name
+        return name unless @rooted && can_root_name?
+        "::#{name}"
+      end
+
+      # @return [String]
+      def substring
+        @substring ||= generate_substring_from(&:tags)
+      end
+
+      # @return [String]
+      def rooted_substring
+        @rooted_substring = generate_substring_from(&:rooted_tags)
+      end
+
+      # @return [String]
+      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?
+          ''
+        elsif hash_parameters?
+          "{#{key_types_str} => #{subtypes_str}}"
+        elsif fixed_parameters?
+          "(#{subtypes_str})"
+        else
+          if name == 'Hash'
+            "<#{key_types_str}, #{subtypes_str}>"
+          else
+            "<#{key_types_str}#{subtypes_str}>"
+          end
+        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
+      end
+
+      # @param other [Object]
+      def == other
+        return false unless self.class == other.class
+        # @sg-ignore flow sensitive typing should support .class == .class
+        tag == other.tag
+      end
+
+      # Generate a ComplexType that fully qualifies this type's namespaces.
+      #
+      # @param api_map [ApiMap] The ApiMap that performs qualification
+      # @param context [String] The namespace from which to resolve names
+      # @return [self, ComplexType, UniqueType] The generated ComplexType
+      def qualify api_map, context = ''
+        transform do |t|
+          next t if t.name == GENERIC_TAG_NAME
+          next t if t.duck_type? || t.void? || t.undefined?
+          recon = (t.rooted? ? '' : context)
+          fqns = api_map.qualify(t.name, recon)
+          if fqns.nil?
+            next UniqueType::BOOLEAN if t.tag == 'Boolean'
+            next UniqueType::UNDEFINED
+          end
+          t.recreate(new_name: fqns, make_rooted: true)
+        end
+      end
+
+      # @yieldparam [UniqueType]
+      # @return [void]
+      # @overload each_unique_type()
+      #   @return [Enumerator<UniqueType>]
+      def each_unique_type &block
+        return enum_for(__method__) unless block_given?
+        yield self
+      end
+    end
+  end
+end