steep-relaxed 1.9.3.3

data/lib/steep/type_inference/send_args.rb

@@ -0,0 +1,712 @@
+module Steep
+  module TypeInference
+    class SendArgs
+      class PositionalArgs
+        class NodeParamPair
+          attr_reader :node
+          attr_reader :param
+
+          def initialize(node:, param:)
+            @node = node
+            @param = param
+          end
+
+          include Equatable
+
+          def to_ary
+            [node, param]
+          end
+        end
+
+        class NodeTypePair
+          attr_reader :node
+          attr_reader :type
+
+          def initialize(node:, type:)
+            @node = node
+            @type = type
+          end
+
+          include Equatable
+
+          def node_type
+            case node.type
+            when :splat
+              AST::Builtin::Array.instance_type(type)
+            else
+              type
+            end
+          end
+        end
+
+        class SplatArg
+          attr_reader :node
+          attr_accessor :type
+
+          def initialize(node:)
+            @node = node
+            @type = nil
+          end
+
+          include Equatable
+        end
+
+        class UnexpectedArg
+          attr_reader :node
+
+          def initialize(node:)
+            @node = node
+          end
+
+          include Equatable
+        end
+
+        class MissingArg
+          attr_reader :params
+
+          def initialize(params:)
+            @params = params
+          end
+
+          include Equatable
+        end
+
+        attr_reader :args
+        attr_reader :index
+        attr_reader :positional_params
+        attr_reader :uniform
+
+        def initialize(args:, index:, positional_params:, uniform: false)
+          @args = args
+          @index = index
+          @positional_params = positional_params
+          @uniform = uniform
+        end
+
+        def node
+          args[index]
+        end
+
+        def following_args
+          args[index..] or raise
+        end
+
+        def param
+          positional_params&.head
+        end
+
+        def update(index: self.index, positional_params: self.positional_params, uniform: self.uniform)
+          PositionalArgs.new(args: args, index: index, positional_params: positional_params, uniform: uniform)
+        end
+
+        def next()
+          case
+          when node && node.type == :forwarded_args
+            # If the node is a `:forwarded_args`, abort
+            nil
+          when !node && param.is_a?(Interface::Function::Params::PositionalParams::Required)
+            [
+              MissingArg.new(params: positional_params),
+              update(index: index, positional_params: nil)
+            ]
+          when !node && param.is_a?(Interface::Function::Params::PositionalParams::Optional)
+            nil
+          when !node && param.is_a?(Interface::Function::Params::PositionalParams::Rest)
+            nil
+          when !node && !param
+            nil
+          when node && node.type != :splat && param.is_a?(Interface::Function::Params::PositionalParams::Required)
+            [
+              NodeParamPair.new(node: node, param: param),
+              update(index: index+1, positional_params: positional_params&.tail)
+            ]
+          when node && node.type != :splat && param.is_a?(Interface::Function::Params::PositionalParams::Optional)
+            [
+              NodeParamPair.new(node: node, param: param),
+              update(index: index+1, positional_params: positional_params&.tail)
+            ]
+          when node && node.type != :splat && param.is_a?(Interface::Function::Params::PositionalParams::Rest)
+            [
+              NodeParamPair.new(node: node, param: param),
+              update(index: index+1)
+            ]
+          when node && node.type != :splat && !param
+            [
+              UnexpectedArg.new(node: node),
+              update(index: index + 1)
+            ]
+          when node && node.type == :splat
+            [
+              SplatArg.new(node: node),
+              self
+            ]
+          end
+        end
+
+        def uniform_type
+          return nil unless positional_params
+          if positional_params.each.any? {|param| param.is_a?(Interface::Function::Params::PositionalParams::Rest) }
+            AST::Types::Intersection.build(types: positional_params.each.map(&:type))
+          end
+        end
+
+        def consume(n, node:)
+          # @type var ps: Array[Interface::Function::Params::PositionalParams::param]
+          ps = []
+          params = consume0(n, node: node, params: positional_params, ps: ps)
+          case params
+          when UnexpectedArg
+            [
+              params,
+              update(index: index+1, positional_params: nil)
+            ]
+          else
+            [ps, update(index: index+1, positional_params: params)]
+          end
+        end
+
+        def consume0(n, node:, params:, ps:)
+          case n
+          when 0
+            params
+          else
+            head = params&.head
+            case head
+            when nil
+              UnexpectedArg.new(node: node)
+            when Interface::Function::Params::PositionalParams::Required, Interface::Function::Params::PositionalParams::Optional
+              ps << head
+              consume0(n-1, node: node, params: params&.tail, ps: ps)
+            when Interface::Function::Params::PositionalParams::Rest
+              ps << head
+              consume0(n-1, node: node, params: params, ps: ps)
+            end
+          end
+        end
+      end
+
+      class KeywordArgs
+        class ArgTypePairs
+          attr_reader :pairs
+
+          def initialize(pairs:)
+            @pairs = pairs
+          end
+
+          include Equatable
+
+          def [](index)
+            pairs[index]
+          end
+
+          def size
+            pairs.size
+          end
+        end
+
+        class SplatArg
+          attr_reader :node
+          attr_accessor :type
+
+          def initialize(node:)
+            @node = node
+            @type = nil
+          end
+
+          include Equatable
+        end
+
+        class UnexpectedKeyword
+          attr_reader :keyword
+          attr_reader :node
+
+          include Equatable
+
+          def initialize(keyword:, node:)
+            @keyword = keyword
+            @node = node
+          end
+
+          def key_node
+            if node.type == :pair
+              node.children[0]
+            end
+          end
+
+          def value_node
+            if node.type == :pair
+              node.children[1]
+            end
+          end
+        end
+
+        class MissingKeyword
+          attr_reader :keywords
+
+          include Equatable
+
+          def initialize(keywords:)
+            @keywords = keywords
+          end
+        end
+
+        attr_reader :kwarg_nodes
+        attr_reader :keyword_params
+        attr_reader :index
+        attr_reader :consumed_keywords
+
+        def initialize(kwarg_nodes:, keyword_params:, index: 0, consumed_keywords: Set[])
+          @kwarg_nodes = kwarg_nodes
+          @keyword_params = keyword_params
+          @index = index
+          @consumed_keywords = consumed_keywords
+        end
+
+        def update(index: self.index, consumed_keywords: self.consumed_keywords)
+          KeywordArgs.new(
+            kwarg_nodes: kwarg_nodes,
+            keyword_params: keyword_params,
+            index: index,
+            consumed_keywords: consumed_keywords
+          )
+        end
+
+        def keyword_pair
+          kwarg_nodes[index]
+        end
+
+        def required_keywords
+          keyword_params.requireds
+        end
+
+        def optional_keywords
+          keyword_params.optionals
+        end
+
+        def rest_type
+          keyword_params.rest
+        end
+
+        def keyword_type(key)
+          required_keywords[key] || optional_keywords[key]
+        end
+
+        def all_keys
+          keys = Set.new
+          keys.merge(required_keywords.each_key)
+          keys.merge(optional_keywords.each_key)
+          keys.sort_by(&:to_s).to_a
+        end
+
+        def all_values
+          keys = Set.new
+          keys.merge(required_keywords.each_value)
+          keys.merge(optional_keywords.each_value)
+          keys.sort_by(&:to_s).to_a
+        end
+
+        def possible_key_type
+          # @type var key_types: Array[AST::Types::t]
+          key_types = all_keys.map {|key| AST::Types::Literal.new(value: key) }
+          key_types << AST::Builtin::Symbol.instance_type if rest_type
+
+          AST::Types::Union.build(types: key_types)
+        end
+
+        def possible_value_type
+          value_types = all_values
+          value_types << rest_type if rest_type
+
+          AST::Types::Intersection.build(types: value_types)
+        end
+
+        def next()
+          node = keyword_pair
+
+          if node
+            case node.type
+            when :pair
+              key_node, value_node = node.children
+
+              if key_node.type == :sym
+                key = key_node.children[0]
+
+                case
+                when value_type = keyword_type(key)
+                  [
+                    ArgTypePairs.new(
+                      pairs: [
+                        [key_node, AST::Types::Literal.new(value: key)],
+                        [value_node, value_type]
+                      ]
+                    ),
+                    update(
+                      index: index+1,
+                      consumed_keywords: consumed_keywords + [key]
+                    )
+                  ]
+                when value_type = rest_type
+                  [
+                    ArgTypePairs.new(
+                      pairs: [
+                        [key_node, AST::Builtin::Symbol.instance_type],
+                        [value_node, value_type]
+                      ]
+                    ),
+                    update(
+                      index: index+1,
+                      consumed_keywords: consumed_keywords + [key]
+                    )
+                  ]
+                else
+                  [
+                    UnexpectedKeyword.new(keyword: key, node: node),
+                    update(index: index+1)
+                  ]
+                end
+              else
+                if !all_keys.empty? || rest_type
+                  [
+                    ArgTypePairs.new(
+                      pairs: [
+                        [key_node, possible_key_type],
+                        [value_node, possible_value_type]
+                      ]
+                    ),
+                    update(index: index+1)
+                  ]
+                else
+                  [
+                    UnexpectedKeyword.new(keyword: nil, node: node),
+                    update(index: index+1)
+                  ]
+                end
+              end
+            when :kwsplat
+              [
+                SplatArg.new(node: node),
+                self
+              ]
+            end
+          else
+            left = Set.new(required_keywords.keys) - consumed_keywords
+            unless left.empty?
+              [
+                MissingKeyword.new(keywords: left),
+                update(consumed_keywords: consumed_keywords + left)
+              ]
+            end
+          end
+        end
+
+        def consume_keys(keys, node:)
+          # @type var consumed_keys: Array[Symbol]
+          consumed_keys = []
+          # @type var types: Array[AST::Types::t]
+          types = []
+
+          # @type var unexpected_keyword: Symbol?
+          unexpected_keyword = nil
+
+          keys.each do |key|
+            case
+            when type = keyword_type(key)
+              consumed_keys << key
+              types << type
+            when type = rest_type()
+              types << type
+            else
+              unexpected_keyword = key
+            end
+          end
+
+          [
+            if unexpected_keyword
+              UnexpectedKeyword.new(keyword: unexpected_keyword, node: node)
+            else
+              types
+            end,
+            update(index: index + 1, consumed_keywords: consumed_keywords + consumed_keys)
+          ]
+        end
+      end
+
+      class BlockPassArg
+        attr_reader :node
+        attr_reader :block
+
+        def initialize(node:, block:)
+          @node = node
+          @block = block
+        end
+
+        include Equatable
+
+        def no_block?
+          !node && !block
+        end
+
+        def compatible?
+          if node
+            block ? true : false
+          else
+            !block || block.optional?
+          end
+        end
+
+        def block_missing?
+          !node && block&.required?
+        end
+
+        def unexpected_block?
+          node && !block
+        end
+
+        def pair
+          raise unless compatible?
+
+          if node && block
+            [
+              node,
+              block.type
+            ]
+          end
+        end
+
+        def node_type
+          raise unless block
+
+          type = AST::Types::Proc.new(type: block.type, block: nil, self_type: block.self_type)
+
+          if block.optional?
+            type = AST::Types::Union.build(types: [type, AST::Builtin.nil_type])
+          end
+
+          type
+        end
+      end
+
+      class ForwardedArgs
+        attr_reader :node, :params
+
+        def initialize(node:, params:)
+          @node = node
+          @params = params
+        end
+      end
+
+      attr_reader :node
+      attr_reader :arguments
+      attr_reader :type
+
+      def initialize(node:, arguments:, type:)
+        raise "Untyped function is not supported" unless type.type.params
+        @node = node
+        @arguments = arguments
+        @type = type
+      end
+
+      def params
+        case type
+        when Interface::MethodType
+          type.type.params or raise
+        when AST::Types::Proc
+          type.type.params or raise
+        else
+          raise
+        end
+      end
+
+      def block
+        case type
+        when Interface::MethodType
+          type.block
+        when AST::Types::Proc
+          type.block
+        end
+      end
+
+      def positional_params
+        params or raise
+        params.positional_params
+      end
+
+      def keyword_params
+        params or raise
+        params.keyword_params
+      end
+
+      def kwargs_node
+        unless keyword_params.empty?
+          arguments.find {|node| node.type == :kwargs }
+        end
+      end
+
+      def positional_arg
+        args =
+          if keyword_params.empty?
+            arguments.take_while {|node| node.type != :block_pass }
+          else
+            arguments.take_while {|node| node.type != :kwargs && node.type != :block_pass }
+          end
+
+        PositionalArgs.new(args: args, index: 0, positional_params: positional_params)
+      end
+
+      def forwarded_args_node
+        arguments.find {|node| node.type == :forwarded_args }
+      end
+
+      def keyword_args
+        KeywordArgs.new(
+          kwarg_nodes: kwargs_node&.children || [],
+          keyword_params: keyword_params
+        )
+      end
+
+      def block_pass_arg
+        node = arguments.find {|node| node.type == :block_pass }
+
+        BlockPassArg.new(node: node, block: block)
+      end
+
+      def each
+        if block_given?
+          errors = [] #: Array[PositionalArgs::error_arg | KeywordArgs::error_arg]
+
+          last_positional_args = positional_arg
+
+          positional_arg.tap do |args|
+            while (value, args = args.next())
+              yield value
+
+              case value
+              when PositionalArgs::SplatArg
+                type = value.type
+
+                case type
+                when nil
+                  raise
+                when AST::Types::Tuple
+                  ts, args = args.consume(type.types.size, node: value.node)
+
+                  case ts
+                  when Array
+                    ty = AST::Types::Tuple.new(types: ts.map(&:type))
+                    yield PositionalArgs::NodeTypePair.new(node: value.node, type: ty)
+                  when PositionalArgs::UnexpectedArg
+                    errors << ts
+                    yield ts
+                  end
+                else
+                  if t = args.uniform_type
+                    args.following_args.each do |node|
+                      yield PositionalArgs::NodeTypePair.new(node: node, type: t)
+                    end
+                  else
+                    args.following_args.each do |node|
+                      arg = PositionalArgs::UnexpectedArg.new(node: node)
+                      yield arg
+                      errors << arg
+                    end
+                  end
+
+                  break
+                end
+              when PositionalArgs::UnexpectedArg, PositionalArgs::MissingArg
+                errors << value
+              end
+
+              last_positional_args = args
+            end
+          end
+
+          if fag = forwarded_args_node
+            forward_params = Interface::Function::Params.new(
+              positional_params: last_positional_args.positional_params,
+              keyword_params: keyword_params
+            )
+
+            forwarded_args = ForwardedArgs.new(node: fag, params: forward_params)
+          else
+            keyword_args.tap do |args|
+              while (a, args = args.next)
+                case a
+                when KeywordArgs::MissingKeyword
+                  errors << a
+                when KeywordArgs::UnexpectedKeyword
+                  errors << a
+                end
+
+                yield a
+
+                case a
+                when KeywordArgs::SplatArg
+                  case type = a.type
+                  when nil
+                    raise
+                  when AST::Types::Record
+                    # @type var keys: Array[Symbol]
+                    keys = _ = type.elements.keys
+                    ts, args = args.consume_keys(keys, node: a.node)
+
+                    case ts
+                    when KeywordArgs::UnexpectedKeyword
+                      yield ts
+                      errors << ts
+                    when Array
+                      pairs = keys.zip(ts) #: Array[[Symbol, AST::Types::t]]
+                      record = AST::Types::Record.new(elements: Hash[pairs], required_keys: Set.new(keys))
+                      yield KeywordArgs::ArgTypePairs.new(pairs: [[a.node, record]])
+                    end
+                  else
+                    args = args.update(index: args.index + 1)
+
+                    if args.rest_type
+                      type = AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type, args.possible_value_type)
+                      yield KeywordArgs::ArgTypePairs.new(pairs: [[a.node, type]])
+                    else
+                      yield KeywordArgs::UnexpectedKeyword.new(keyword: nil, node: a.node)
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          diagnostics = [] #: Array[Diagnostic::Ruby::Base]
+
+          missing_keywords = [] #: Array[Symbol]
+          errors.each do |error|
+            case error
+            when KeywordArgs::UnexpectedKeyword
+              diagnostics << Diagnostic::Ruby::UnexpectedKeywordArgument.new(node: error.node, params: params)
+            when KeywordArgs::MissingKeyword
+              missing_keywords.push(*error.keywords.to_a)
+            when PositionalArgs::UnexpectedArg
+              if error.node.type == :kwargs
+                error.node.children.each do |kwarg|
+                  if kwarg.type == :pair
+                    diagnostics << Diagnostic::Ruby::UnexpectedKeywordArgument.new(node: kwarg, params: params)
+                  end
+                end
+              else
+                diagnostics << Diagnostic::Ruby::UnexpectedPositionalArgument.new(node: error.node, params: params)
+              end
+            when PositionalArgs::MissingArg
+              diagnostics << Diagnostic::Ruby::InsufficientPositionalArguments.new(node: node, params: params)
+            end
+          end
+
+          unless missing_keywords.empty?
+            diagnostics << Diagnostic::Ruby::InsufficientKeywordArguments.new(node: node, params: params, missing_keywords: missing_keywords)
+          end
+
+          [forwarded_args, diagnostics]
+        else
+          enum_for :each
+        end
+      end
+    end
+  end
+end