steep 1.1.1 → 1.2.0.pre.1

data/lib/steep/type_inference/block_params.rb

@@ -23,6 +23,59 @@ module Steep
         def hash
           self.class.hash ^ var.hash ^ type.hash ^ value.hash ^ node.hash
         end
+
+        def each_param(&block)
+          if block
+            yield self
+          else
+            enum_for :each_param
+          end
+        end
+      end
+
+      class MultipleParam
+        attr_reader :node
+
+        attr_reader :params
+
+        def initialize(node:, params:)
+          @params = params
+          @node = node
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            other.node == node &&
+            other.params == params
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash ^ node.hash ^ params.hash
+        end
+
+        def variable_types
+          each_param.with_object({}) do |param, hash|
+            # @type var hash: Hash[Symbol, AST::Types::t?]
+            hash[param.var] = param.type
+          end
+        end
+
+        def each_param(&block)
+          if block
+            params.each do |param|
+              case param
+              when Param
+                yield param
+              when MultipleParam
+                param.each_param(&block)
+              end
+            end
+          else
+            enum_for :each_param
+          end
+        end
       end
 
       attr_reader :leading_params
@@ -50,35 +103,42 @@ module Steep
       end
 
       def self.from_node(node, annotations:)
+        # @type var leading_params: Array[Param | MultipleParam]
         leading_params = []
+        # @type var optional_params: Array[Param]
         optional_params = []
+        # @type var rest_param: Param?
         rest_param = nil
+        # @type var trailing_params: Array[Param | MultipleParam]
         trailing_params = []
+        # @type var block_param: Param?
         block_param = nil
 
         default_params = leading_params
 
         node.children.each do |arg|
-          var = arg.children.first
-
-          if var.is_a?(::AST::Node)
-            return
-          end
+          case
+          when arg.type == :mlhs
+            default_params << from_multiple(arg, annotations)
+          when arg.type == :procarg0 && arg.children.size > 1
+            default_params << from_multiple(arg, annotations)
+          else
+            var = arg.children[0]
+            type = annotations.var_type(lvar: var)
 
-          type = annotations.var_type(lvar: var)
-
-          case arg.type
-          when :arg, :procarg0
-            default_params << Param.new(var: var, type: type, value: nil, node: arg)
-          when :optarg
-            default_params = trailing_params
-            optional_params << Param.new(var: var, type: type, value: arg.children.last, node: arg)
-          when :restarg
-            default_params = trailing_params
-            rest_param = Param.new(var: var, type: type, value: nil, node: arg)
-          when :blockarg
-            block_param = Param.new(var: var, type: type, value: nil, node: arg)
-            break
+            case arg.type
+            when :arg, :procarg0
+              default_params << Param.new(var: var, type: type, value: nil, node: arg)
+            when :optarg
+              default_params = trailing_params
+              optional_params << Param.new(var: var, type: type, value: arg.children.last, node: arg)
+            when :restarg
+              default_params = trailing_params
+              rest_param = Param.new(var: var, type: type, value: nil, node: arg)
+            when :blockarg
+              block_param = Param.new(var: var, type: type, value: nil, node: arg)
+              break
+            end
           end
         end
 
@@ -149,99 +209,100 @@ module Steep
         )
       end
 
-      def zip(params_type, block)
+      def zip(params_type, block, factory:)
         if trailing_params.any?
           Steep.logger.error "Block definition with trailing required parameters are not supported yet"
         end
 
-        [].tap do |zip|
-          if expandable_params?(params_type) && expandable?
-            type = params_type.required[0]
-
-            case
-            when AST::Builtin::Array.instance_type?(type)
-              type_arg = type.args[0]
-              params.each do |param|
-                unless param == rest_param
-                  zip << [param, AST::Types::Union.build(types: [type_arg, AST::Builtin.nil_type])]
-                else
-                  zip << [param, AST::Builtin::Array.instance_type(type_arg)]
-                end
-              end
-            when type.is_a?(AST::Types::Tuple)
-              types = type.types.dup
-              (leading_params + optional_params).each do |param|
-                ty = types.shift
-                if ty
-                  zip << [param, ty]
-                else
-                  zip << [param, AST::Types::Nil.new]
-                end
-              end
+        # @type var zip: Array[[Param | MultipleParam, AST::Types::t]]
+        zip = []
 
-              if rest_param
-                if types.any?
-                  union = AST::Types::Union.build(types: types)
-                  zip << [rest_param, AST::Builtin::Array.instance_type(union)]
-                else
-                  zip << [rest_param, AST::Types::Nil.new]
-                end
+        if expandable? && (type = expandable_params?(params_type, factory))
+          case
+          when AST::Builtin::Array.instance_type?(type)
+            type.is_a?(AST::Types::Name::Instance) or raise
+
+            type_arg = type.args[0]
+            params.each do |param|
+              unless param == rest_param
+                zip << [param, AST::Types::Union.build(types: [type_arg, AST::Builtin.nil_type])]
+              else
+                zip << [param, AST::Builtin::Array.instance_type(type_arg)]
               end
             end
-          else
-            types = params_type.flat_unnamed_params
-
+          when type.is_a?(AST::Types::Tuple)
+            types = type.types.dup
             (leading_params + optional_params).each do |param|
-              type = types.shift&.last || params_type.rest
-
-              if type
-                zip << [param, type]
+              ty = types.shift
+              if ty
+                zip << [param, ty]
               else
-                zip << [param, AST::Builtin.nil_type]
+                zip << [param, AST::Types::Nil.new]
               end
             end
 
             if rest_param
-              if types.empty?
-                array = AST::Builtin::Array.instance_type(params_type.rest || AST::Builtin.any_type)
-                zip << [rest_param, array]
+              if types.any?
+                union = AST::Types::Union.build(types: types)
+                zip << [rest_param, AST::Builtin::Array.instance_type(union)]
               else
-                union = AST::Types::Union.build(types: types.map(&:last) + [params_type.rest])
-                array = AST::Builtin::Array.instance_type(union)
-                zip << [rest_param, array]
+                zip << [rest_param, AST::Types::Nil.new]
               end
             end
           end
+        else
+          types = params_type.flat_unnamed_params
 
-          if block_param
-            if block
-              proc_type =
-                if block.optional?
-                  AST::Types::Union.build(
-                    types: [
-                      AST::Types::Proc.new(type: block.type, block: nil),
-                      AST::Builtin.nil_type
-                    ]
-                  )
-                else
-                  AST::Types::Proc.new(type: block.type, block: nil)
-                end
-
-              zip << [block_param, proc_type]
+          (leading_params + optional_params).each do |param|
+            type = types.shift&.last || params_type.rest
+
+            if type
+              zip << [param, type]
+            else
+              zip << [param, AST::Builtin.nil_type]
+            end
+          end
+
+          if rest_param
+            if types.empty?
+              array = AST::Builtin::Array.instance_type(params_type.rest || AST::Builtin.any_type)
+              zip << [rest_param, array]
             else
-              zip << [block_param, AST::Builtin.nil_type]
+              union = AST::Types::Union.build(types: types.map(&:last) + [params_type.rest])
+              array = AST::Builtin::Array.instance_type(union)
+              zip << [rest_param, array]
             end
           end
         end
+
+        if block_param
+          if block
+            proc_type = AST::Types::Proc.new(type: block.type, block: nil, self_type: block.self_type)
+            if block.optional?
+              proc_type = AST::Types::Union.build(types: [proc_type, AST::Builtin.nil_type])
+            end
+
+            zip << [block_param, proc_type]
+          else
+            zip << [block_param, AST::Builtin.nil_type]
+          end
+        end
+
+        zip
       end
 
-      def expandable_params?(params_type)
+      def expandable_params?(params_type, factory)
         if params_type.flat_unnamed_params.size == 1
-          case (type = params_type.required.first)
+          type = params_type.required.first or raise
+          type = factory.deep_expand_alias(type) || type
+
+          case type
           when AST::Types::Tuple
-            true
+            type
           when AST::Types::Name::Base
-            AST::Builtin::Array.instance_type?(type)
+            if AST::Builtin::Array.instance_type?(type)
+              type
+            end
           end
         end
       end
@@ -254,16 +315,38 @@ module Steep
           true
         when params.size == 1 && params[0].node.type == :arg
           true
+        else
+          false
         end
       end
 
       def each(&block)
-        if block_given?
+        if block
           params.each(&block)
         else
           enum_for :each
         end
       end
+
+      def self.from_multiple(node, annotations)
+        # @type var params: Array[Param | MultipleParam]
+        params = []
+
+        node.children.each do |child|
+          if child.type == :mlhs
+            params << from_multiple(child, annotations)
+          else
+            var = child.children.first
+
+            raise unless var.is_a?(Symbol)
+            type = annotations.var_type(lvar: var)
+
+            params << Param.new(var: var, node: child, value: nil, type: type)
+          end
+        end
+
+        MultipleParam.new(node: node, params: params)
+      end
     end
   end
 end

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -3,10 +3,12 @@ module Steep
     class LogicTypeInterpreter
       attr_reader :subtyping
       attr_reader :typing
+      attr_reader :config
 
-      def initialize(subtyping:, typing:)
+      def initialize(subtyping:, typing:, config:)
         @subtyping = subtyping
         @typing = typing
+        @config = config
       end
 
       def factory
@@ -387,22 +389,15 @@ module Steep
       end
 
       def try_convert(type, method)
-        case type
-        when AST::Types::Any, AST::Types::Bot, AST::Types::Top, AST::Types::Var
-          return
-        end
+        if shape = subtyping.builder.shape(type, public_only: true, config: config)
+          if entry = shape.methods[method]
+            method_type = entry.method_types.find do |method_type|
+              method_type.type.params.optional?
+            end
 
-        interface = factory.interface(type, private: false, self_type: type)
-        if entry = interface.methods[method]
-          method_type = entry.method_types.find do |method_type|
-            method_type.type.params.optional?
+            method_type.type.return_type if method_type
           end
-
-          method_type.type.return_type if method_type
         end
-      rescue => exn
-        Steep.log_error(exn, message: "Unexpected error when converting #{type.to_s} with #{method}")
-        nil
       end
     end
   end

data/lib/steep/type_inference/method_params.rb

@@ -95,12 +95,14 @@ module Steep
         attr_reader :name
         attr_reader :type
         attr_reader :node
+        attr_reader :self_type
 
-        def initialize(name:, type:, node:, optional:)
+        def initialize(name:, type:, node:, optional:, self_type:)
           @name = name
           @type = type
           @node = node
           @optional = optional
+          @self_type = self_type
         end
 
         def optional?
@@ -109,7 +111,7 @@ module Steep
 
         def var_type
           if type
-            proc_type = AST::Types::Proc.new(type: type, block: nil)
+            proc_type = AST::Types::Proc.new(type: type, block: nil, self_type: self_type)
 
             if optional?
               AST::Types::Union.build(types: [proc_type, AST::Builtin.nil_type], location: proc_type.location)
@@ -126,13 +128,14 @@ module Steep
             other.name == name &&
             other.type == type &&
             other.node == node &&
-            other.optional? == optional?
+            other.optional? == optional? &&
+            other.self_type == self_type
         end
 
         alias eql? ==
 
         def hash
-          self.class.hash ^ name.hash ^ type.hash ^ node.hash ^ optional?.hash
+          self.class.hash ^ name.hash ^ type.hash ^ node.hash ^ optional?.hash ^ self_type.hash
         end
       end
 
@@ -199,7 +202,7 @@ module Steep
             params.params[name] = KeywordRestParameter.new(name: name, type: nil, node: arg)
           when :blockarg
             name = arg.children[0]
-            params.params[name] = BlockParameter.new(name: name, type: nil, optional: nil, node: arg)
+            params.params[name] = BlockParameter.new(name: name, type: nil, optional: nil, node: arg, self_type: nil)
           end
         end
 
@@ -465,14 +468,16 @@ module Steep
               name: name,
               type: method_type.block.type,
               optional: method_type.block.optional?,
-              node: arg
+              node: arg,
+              self_type: method_type.block.self_type
             )
           else
             instance.params[name] = BlockParameter.new(
               name: name,
               type: nil,
               optional: nil,
-              node: arg
+              node: arg,
+              self_type: nil
             )
           end
         end

data/lib/steep/type_inference/send_args.rb

@@ -88,7 +88,7 @@ module Steep
         end
 
         def following_args
-          args[index..]
+          args[index..] or raise
         end
 
         def param
@@ -115,12 +115,12 @@ module Steep
           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)
+              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)
+              update(index: index+1, positional_params: positional_params&.tail)
             ]
           when node && node.type != :splat && param.is_a?(Interface::Function::Params::PositionalParams::Rest)
             [
@@ -148,6 +148,7 @@ module Steep
         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
@@ -172,7 +173,7 @@ module Steep
               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)
+              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)
@@ -302,6 +303,7 @@ module Steep
         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
 
@@ -395,9 +397,12 @@ module Steep
         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|
@@ -466,7 +471,9 @@ module Steep
         end
 
         def node_type
-          type = AST::Types::Proc.new(type: block.type, block: nil)
+          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])
@@ -478,22 +485,38 @@ module Steep
 
       attr_reader :node
       attr_reader :arguments
-      attr_reader :method_type
-      attr_reader :method_name
+      attr_reader :type
 
-      def initialize(node:, arguments:, method_name:, method_type:)
+      def initialize(node:, arguments:, type:)
         @node = node
         @arguments = arguments
-        @method_type = method_type
-        @method_name = method_name
+        @type = type
+      end
+
+      def params
+        case type
+        when Interface::MethodType
+          type.type.params
+        when AST::Types::Proc
+          type.type.params
+        end
+      end
+
+      def block
+        case type
+        when Interface::MethodType
+          type.block
+        when AST::Types::Proc
+          type.block
+        end
       end
 
       def positional_params
-        method_type.type.params.positional_params
+        params.positional_params
       end
 
       def keyword_params
-        method_type.type.params.keyword_params
+        params.keyword_params
       end
 
       def kwargs_node
@@ -520,7 +543,6 @@ module Steep
 
       def block_pass_arg
         node = arguments.find {|node| node.type == :block_pass }
-        block = method_type.block
 
         BlockPassArg.new(node: node, block: block)
       end
@@ -589,7 +611,8 @@ module Steep
                 when nil
                   raise
                 when AST::Types::Record
-                  keys = type.elements.keys
+                  # @type var keys: Array[Symbol]
+                  keys = _ = type.elements.keys
                   ts, args = args.consume_keys(keys, node: a.node)
 
                   case ts
@@ -625,35 +648,18 @@ module Steep
           errors.each do |error|
             case error
             when KeywordArgs::UnexpectedKeyword
-              diagnostics << Diagnostic::Ruby::UnexpectedKeywordArgument.new(
-                node: error.node,
-                method_type: method_type,
-                method_name: method_name
-              )
+              diagnostics << Diagnostic::Ruby::UnexpectedKeywordArgument.new(node: error.node, params: params)
             when KeywordArgs::MissingKeyword
               missing_keywords.push(*error.keywords)
             when PositionalArgs::UnexpectedArg
-              diagnostics << Diagnostic::Ruby::UnexpectedPositionalArgument.new(
-                node: error.node,
-                method_type: method_type,
-                method_name: method_name
-              )
+              diagnostics << Diagnostic::Ruby::UnexpectedPositionalArgument.new(node: error.node, params: params)
             when PositionalArgs::MissingArg
-              diagnostics << Diagnostic::Ruby::InsufficientPositionalArguments.new(
-                node: node,
-                method_name: method_name,
-                method_type: method_type
-              )
+              diagnostics << Diagnostic::Ruby::InsufficientPositionalArguments.new(node: node, params: params)
             end
           end
 
           unless missing_keywords.empty?
-            diagnostics << Diagnostic::Ruby::InsufficientKeywordArguments.new(
-              node: node,
-              method_name: method_name,
-              method_type: method_type,
-              missing_keywords: missing_keywords
-            )
+            diagnostics << Diagnostic::Ruby::InsufficientKeywordArguments.new(node: node, params: params, missing_keywords: missing_keywords)
           end
 
           diagnostics

data/lib/steep/type_inference/type_env_builder.rb

@@ -125,7 +125,7 @@ module Steep
       attr_reader :commands
 
       def initialize(*commands)
-        @commands = commands
+        @commands = commands.compact
       end
 
       def build(type_env)

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.1.1"
+  VERSION = "1.2.0.pre.1"
 end