solargraph 0.58.2 → 0.59.0.dev.2

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,25 +19,24 @@ 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
       end
@@ -44,13 +44,16 @@ module Solargraph
     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,7 +165,7 @@ module Solargraph
 
     # @param name [Symbol]
     # @param include_private [Boolean]
-    def respond_to_missing?(name, include_private = false)
+    def respond_to_missing? name, include_private = false
       TypeMethods.public_instance_methods.include?(name) || super
     end
 
@@ -194,6 +197,65 @@ 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) 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]
+    # @return [Boolean]
+    def duck_types_match? api_map, expected, inferred
+      raise ArgumentError, 'Expected type must be duck type' unless expected.duck_type?
+      expected.each do |exp|
+        next unless exp.duck_type?
+        quack = exp.to_s[1..]
+        # @sg-ignore Need to add nil check here
+        return false if api_map.get_method_stack(inferred.namespace, quack, scope: inferred.scope).empty?
+      end
+      true
+    end
+
     # @return [String]
     def rooted_tags
       map(&:rooted_tag).join(', ')
@@ -201,14 +263,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,8 +290,10 @@ 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
 
@@ -252,6 +316,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 +331,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 +345,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 +360,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 +419,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 +453,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 +473,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 +483,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 +525,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 +550,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

data/lib/solargraph/convention/data_definition/data_assignment_node.rb

@@ -1,61 +1,61 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Convention
-    module DataDefinition
-      # A node wrapper for a Data definition via const assignment.
-      # @example
-      #   MyData = Data.new(:bar, :baz) do
-      #     def foo
-      #     end
-      #   end
-      class DataAssignmentNode < DataDefintionNode
-        class << self
-          # @example
-          # s(:casgn, nil, :Foo,
-          #   s(:block,
-          #     s(:send,
-          #       s(:const, nil, :Data), :define,
-          #       s(:sym, :bar),
-          #       s(:sym, :baz)),
-          #     s(:args),
-          #     s(:def, :foo,
-          #       s(:args),
-          #       s(:send, nil, :bar))))
-          # @param node [::Parser::AST::Node]
-          def match?(node)
-            return false unless node&.type == :casgn
-            return false if node.children[2].nil?
-
-            data_node = if node.children[2].type == :block
-                          node.children[2].children[0]
-                        else
-                          node.children[2]
-                        end
-
-            data_definition_node?(data_node)
-          end
-        end
-
-        def class_name
-          if node.children[0]
-            Parser::NodeMethods.unpack_name(node.children[0]) + "::#{node.children[1]}"
-          else
-            node.children[1].to_s
-          end
-        end
-
-        private
-
-        # @return [Parser::AST::Node]
-        def data_node
-          if node.children[2].type == :block
-            node.children[2].children[0]
-          else
-            node.children[2]
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    module DataDefinition
+      # A node wrapper for a Data definition via const assignment.
+      # @example
+      #   MyData = Data.new(:bar, :baz) do
+      #     def foo
+      #     end
+      #   end
+      class DataAssignmentNode < DataDefintionNode
+        class << self
+          # @example
+          # s(:casgn, nil, :Foo,
+          #   s(:block,
+          #     s(:send,
+          #       s(:const, nil, :Data), :define,
+          #       s(:sym, :bar),
+          #       s(:sym, :baz)),
+          #     s(:args),
+          #     s(:def, :foo,
+          #       s(:args),
+          #       s(:send, nil, :bar))))
+          # @param node [::Parser::AST::Node]
+          def match? node
+            return false unless node&.type == :casgn
+            return false if node.children[2].nil?
+
+            data_node = if node.children[2].type == :block
+                          node.children[2].children[0]
+                        else
+                          node.children[2]
+                        end
+
+            data_definition_node?(data_node)
+          end
+        end
+
+        def class_name
+          if node.children[0]
+            Parser::NodeMethods.unpack_name(node.children[0]) + "::#{node.children[1]}"
+          else
+            node.children[1].to_s
+          end
+        end
+
+        private
+
+        # @return [Parser::AST::Node]
+        def data_node
+          if node.children[2].type == :block
+            node.children[2].children[0]
+          else
+            node.children[2]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/convention/data_definition/data_definition_node.rb

@@ -27,7 +27,7 @@ module Solargraph
           #       s(:send, nil, :bar)))
           #
           # @param node [Parser::AST::Node]
-          def match?(node)
+          def match? node
             return false unless node&.type == :class
 
             data_definition_node?(node.children[1])
@@ -37,7 +37,7 @@ module Solargraph
 
           # @param data_node [Parser::AST::Node]
           # @return [Boolean]
-          def data_definition_node?(data_node)
+          def data_definition_node? data_node
             return false unless data_node.is_a?(::Parser::AST::Node)
             return false unless data_node&.type == :send
             return false unless data_node.children[0]&.type == :const
@@ -49,7 +49,7 @@ module Solargraph
         end
 
         # @param node [Parser::AST::Node]
-        def initialize(node)
+        def initialize node
           @node = node
         end
 
@@ -66,7 +66,7 @@ module Solargraph
           end.compact
         end
 
-        # @return [Parser::AST::Node]
+        # @return [Parser::AST::Node, nil]
         def body_node
           node.children[2]
         end
@@ -81,9 +81,11 @@ module Solargraph
           node.children[1]
         end
 
+        # @sg-ignore Need to add nil check here
         # @return [Array<Parser::AST::Node>]
         def data_attribute_nodes
-          data_node.children[2..-1]
+          # @sg-ignore Need to add nil check here
+          data_node.children[2..]
         end
       end
     end

data/lib/solargraph/convention/data_definition.rb

@@ -17,6 +17,7 @@ module Solargraph
               type: :class,
               location: loc,
               closure: region.closure,
+              # @sg-ignore flow sensitive typing needs to handle attrs
               name: data_definition_node.class_name,
               comments: comments_for(node),
               visibility: :public,
@@ -39,6 +40,7 @@ module Solargraph
             # Solargraph::SourceMap::Clip#complete_keyword_parameters does not seem to currently take into account [Pin::Method#signatures] hence we only one for :kwarg
             pins.push initialize_method_pin
 
+            # @sg-ignore flow sensitive typing needs to handle attrs
             data_definition_node.attributes.map do |attribute_node, attribute_name|
               initialize_method_pin.parameters.push(
                 Pin::Parameter.new(
@@ -51,6 +53,7 @@ module Solargraph
             end
 
             # define attribute readers and instance variables
+            # @sg-ignore flow sensitive typing needs to handle attrs
             data_definition_node.attributes.each do |attribute_node, attribute_name|
               name = attribute_name.to_s
               method_pin = Pin::Method.new(
@@ -78,7 +81,7 @@ module Solargraph
 
           private
 
-          # @return [DataDefintionNode, nil]
+          # @return [DataDefinition::DataDefintionNode, DataDefinition::DataAssignmentNode, nil]
           def data_definition_node
             @data_definition_node ||= if DataDefintionNode.match?(node)
                                         DataDefintionNode.new(node)
@@ -90,7 +93,7 @@ module Solargraph
           # @param attribute_node [Parser::AST::Node]
           # @param attribute_name [String]
           # @return [String, nil]
-          def attribute_comments(attribute_node, attribute_name)
+          def attribute_comments attribute_node, attribute_name
             data_comments = comments_for(attribute_node)
             return if data_comments.nil? || data_comments.empty?