steep 1.7.0.dev.3 → 1.7.0.dev.4

data/lib/steep/subtyping/check.rb

@@ -850,8 +850,10 @@ module Steep
         relation.function!
 
         All(relation) do |result|
-          result.add(relation.map {|fun| fun.params }) do |rel|
-            check_method_params(name, rel)
+          if relation.sub_type.params && relation.super_type.params
+            result.add(relation.map {|fun| _ = fun.params }) do |rel|
+              check_method_params(name, rel)
+            end
           end
 
           result.add(relation.map {|fun| fun.return_type }) do |rel|
@@ -906,16 +908,23 @@ module Steep
       end
 
       def match_method_type_fails?(name, type1, type2)
-        match_params(name, Relation(type1.type.params, type2.type.params)).tap do |param_pairs|
-          return param_pairs unless param_pairs.is_a?(Array)
+        if type1.type.params && type2.type.params
+          match_params(name, Relation(type1.type.params, type2.type.params)).tap do |param_pairs|
+            return param_pairs unless param_pairs.is_a?(Array)
+          end
         end
 
         case result = expand_block_given(name, Relation(type1.block, type2.block))
         when Result::Base
           return result
         when Relation
-          match_params(name, result.map {|m| m.type.params }).tap do |param_pairs|
-            return param_pairs unless param_pairs.is_a?(Array)
+          type1.block or raise
+          type2.block or raise
+
+          if type1.block.type.params && type2.block.type.params
+            match_params(name, result.map {|m| _ = m.type.params }).tap do |param_pairs|
+              return param_pairs unless param_pairs.is_a?(Array)
+            end
           end
         end
 

data/lib/steep/subtyping/variable_variance.rb

@@ -46,7 +46,7 @@ module Steep
       end
 
       def self.add_params(params, block:, covariants:, contravariants:)
-        params.each_type do |type|
+        params&.each_type do |type|
           add_type(type, variance: block ? :contravariant : :covariant, covariants: covariants, contravariants: contravariants)
         end
       end
@@ -64,12 +64,12 @@ module Steep
             contravariants << type.name
           end
         when AST::Types::Proc
-          type.type.params.each_type do |type|
+          type.type.params&.each_type do |type|
             add_type(type, variance: variance, covariants: contravariants, contravariants: covariants)
           end
           add_type(type.type.return_type, variance: variance, covariants: covariants, contravariants: contravariants)
           if type.block
-            type.block.type.params.each_type do |type|
+            type.block.type.params&.each_type do |type|
               add_type(type, variance: variance, covariants: covariants, contravariants: contravariants)
             end
             add_type(type.type.return_type, variance: variance, covariants: contravariants, contravariants: covariants)

data/lib/steep/type_construction.rb

@@ -1635,28 +1635,32 @@ module Steep
         when :yield
           if method_context && method_context.method_type
             if block_type = method_context.block_type
-              type = AST::Types::Proc.new(
-                type: block_type.type,
-                block: nil,
-                self_type: block_type.self_type
-              )
-              args = TypeInference::SendArgs.new(
-                node: node,
-                arguments: node.children,
-                type: type
-              )
+              if block_type.type.params
+                type = AST::Types::Proc.new(
+                  type: block_type.type,
+                  block: nil,
+                  self_type: block_type.self_type
+                )
+                args = TypeInference::SendArgs.new(
+                  node: node,
+                  arguments: node.children,
+                  type: type
+                )
 
-              # @type var errors: Array[Diagnostic::Ruby::Base]
-              errors = []
-              constr = type_check_args(
-                nil,
-                args,
-                Subtyping::Constraints.new(unknowns: []),
-                errors
-              )
+                # @type var errors: Array[Diagnostic::Ruby::Base]
+                errors = []
+                constr = type_check_args(
+                  nil,
+                  args,
+                  Subtyping::Constraints.new(unknowns: []),
+                  errors
+                )
 
-              errors.each do |error|
-                typing.add_error(error)
+                errors.each do |error|
+                  typing.add_error(error)
+                end
+              else
+                constr = type_check_untyped_args(node.children)
               end
 
               add_typing(node, type: block_type.type.return_type)
@@ -2172,10 +2176,21 @@ module Steep
               var_type = AST::Builtin.any_type
             else
               if each = calculate_interface(collection_type, :each, private: true)
-                if method_type = (each.method_types || []).find {|type| type.block && type.block.type.params.first_param }
+                method_type = (each.method_types || []).find do |type|
+                  if type.block
+                    if type.block.type.params
+                      type.block.type.params.first_param
+                    else
+                      true
+                    end
+                  end
+                end
+                if method_type
                   if block = method_type.block
-                    if first_param = block.type.params.first_param
+                    if first_param = block.type&.params&.first_param
                       var_type = first_param.type #: AST::Types::t
+                    else
+                      var_type - AST::Builtin.any_type
                     end
                   end
                 end
@@ -2386,31 +2401,33 @@ module Steep
 
               if hint.is_a?(AST::Types::Proc) && value_node.type == :sym
                 if hint.one_arg?
-                  # Assumes Symbol#to_proc implementation
-                  param_type = hint.type.params.required[0]
-                  case param_type
-                  when AST::Types::Any
-                    type = AST::Types::Any.new
-                  else
-                    if method = calculate_interface(param_type, private: true)&.methods&.[](value_node.children[0])
-                      return_types = method.method_types.filter_map do |method_type|
-                        if method_type.type.params.optional?
-                          method_type.type.return_type
+                  if hint.type.params
+                    # Assumes Symbol#to_proc implementation
+                    param_type = hint.type.params.required[0]
+                    case param_type
+                    when AST::Types::Any
+                      type = AST::Types::Any.new
+                    else
+                      if method = calculate_interface(param_type, private: true)&.methods&.[](value_node.children[0])
+                        return_types = method.method_types.filter_map do |method_type|
+                          if method_type.type.params.nil? || method_type.type.params.optional?
+                            method_type.type.return_type
+                          end
                         end
-                      end
 
-                      unless return_types.empty?
-                        type = AST::Types::Proc.new(
-                          type: Interface::Function.new(
-                            params: Interface::Function::Params.empty.with_first_param(
-                              Interface::Function::Params::PositionalParams::Required.new(param_type)
+                        unless return_types.empty?
+                          type = AST::Types::Proc.new(
+                            type: Interface::Function.new(
+                              params: Interface::Function::Params.empty.with_first_param(
+                                Interface::Function::Params::PositionalParams::Required.new(param_type)
+                              ),
+                              return_type: return_types[0],
+                              location: nil
                             ),
-                            return_type: return_types[0],
-                            location: nil
-                          ),
-                          block: nil,
-                          self_type: nil
-                        )
+                            block: nil,
+                            self_type: nil
+                          )
+                        end
                       end
                     end
                   end
@@ -3186,7 +3203,7 @@ module Steep
     end
 
     def type_send_interface(node, interface:, receiver:, receiver_type:, method_name:, arguments:, block_params:, block_body:, tapp:, hint:)
-      method = interface&.methods&.[](method_name)
+      method = interface.methods[method_name]
 
       if method
         call, constr = type_method_call(
@@ -3915,13 +3932,17 @@ module Steep
         # @type var errors: Array[Diagnostic::Ruby::Base]
         errors = []
 
-        args = TypeInference::SendArgs.new(node: node, arguments: arguments, type: method_type)
-        constr = constr.type_check_args(
-          method_name,
-          args,
-          constraints,
-          errors
-        )
+        if method_type.type.params
+          args = TypeInference::SendArgs.new(node: node, arguments: arguments, type: method_type)
+          constr = constr.type_check_args(
+            method_name,
+            args,
+            constraints,
+            errors
+          )
+        else
+          constr = constr.type_check_untyped_args(arguments)
+        end
 
         if block_params
           # block is given
@@ -4010,11 +4031,12 @@ module Steep
               end
 
               method_type, solved, s = apply_solution(errors, node: node, method_type: method_type) {
-                constraints.solution(
-                  checker,
-                  variables: method_type.type.params.free_variables + method_type.block.type.params.free_variables,
-                  context: ccontext
-                )
+                fvs_ = Set[] #: Set[AST::Types::variable]
+
+                fvs_.merge(method_type.type.params.free_variables) if method_type.type.params
+                fvs_.merge(method_type.block.type.params.free_variables) if method_type.block.type.params
+
+                constraints.solution(checker, variables: fvs_, context: ccontext)
               }
 
               method_type.block or raise
@@ -4102,129 +4124,143 @@ module Steep
               return_type = method_type.type.return_type
             end
           else
-            # Block is given but method doesn't accept
-            #
-            constr.type_block_without_hint(node: node, block_annotations: block_annotations, block_params: block_params_, block_body: block_body) do |error|
-              errors << error
-            end
+            if args
+              # Block is given but method doesn't accept
+              #
+              constr.type_block_without_hint(node: node, block_annotations: block_annotations, block_params: block_params_, block_body: block_body) do |error|
+                errors << error
+              end
 
-            case node.children[0].type
-            when :super, :zsuper
-              unless method_context!.super_method
-                errors << Diagnostic::Ruby::UnexpectedSuper.new(
-                  node: node.children[0],
-                  method: method_name
+              case node.children[0].type
+              when :super, :zsuper
+                unless method_context!.super_method
+                  errors << Diagnostic::Ruby::UnexpectedSuper.new(
+                    node: node.children[0],
+                    method: method_name
+                  )
+                end
+              else
+                errors << Diagnostic::Ruby::UnexpectedBlockGiven.new(
+                  node: node,
+                  method_type: method_type
                 )
               end
+
+              method_type = eliminate_vars(method_type, type_param_names)
+              return_type = method_type.type.return_type
             else
-              errors << Diagnostic::Ruby::UnexpectedBlockGiven.new(
-                node: node,
-                method_type: method_type
-              )
+              if block_body
+                block_annotations = source.annotations(block: node, factory: checker.factory, context: nesting)
+                type_block_without_hint(
+                  node: node,
+                  block_annotations: block_annotations,
+                  block_params: TypeInference::BlockParams.from_node(block_params, annotations: block_annotations),
+                  block_body: block_body
+                )
+              end
             end
-
-            method_type = eliminate_vars(method_type, type_param_names)
-            return_type = method_type.type.return_type
           end
         else
           # Block syntax is not given
-          arg = args.block_pass_arg
+          if args
+            arg = args.block_pass_arg
 
-          case
-          when forwarded_args_node = args.forwarded_args_node
-            (_, block = method_context!.forward_arg_type) or raise
+            case
+            when forwarded_args_node = args.forwarded_args_node
+              (_, block = method_context!.forward_arg_type) or raise
 
-            method_block_type = method_type.block&.to_proc_type || AST::Builtin.nil_type
-            forwarded_block_type = block&.to_proc_type || AST::Builtin.nil_type
+              method_block_type = method_type.block&.to_proc_type || AST::Builtin.nil_type
+              forwarded_block_type = block&.to_proc_type || AST::Builtin.nil_type
 
-            if result = constr.no_subtyping?(sub_type: forwarded_block_type, super_type: method_block_type)
-              errors << Diagnostic::Ruby::IncompatibleArgumentForwarding.new(
-                method_name: method_name,
-                node: forwarded_args_node,
-                block_pair: [block, method_type.block],
-                result: result
-              )
-            end
+              if result = constr.no_subtyping?(sub_type: forwarded_block_type, super_type: method_block_type)
+                errors << Diagnostic::Ruby::IncompatibleArgumentForwarding.new(
+                  method_name: method_name,
+                  node: forwarded_args_node,
+                  block_pair: [block, method_type.block],
+                  result: result
+                )
+              end
 
-          when arg.compatible?
-            if arg.node
-              # Block pass (&block) is given
-              node_type, constr = constr.synthesize(arg.node, hint: arg.node_type)
+            when arg.compatible?
+              if arg.node
+                # Block pass (&block) is given
+                node_type, constr = constr.synthesize(arg.node, hint: arg.node_type)
 
-              nil_given =
-                constr.check_relation(sub_type: node_type, super_type: AST::Builtin.nil_type).success? &&
-                  !node_type.is_a?(AST::Types::Any)
+                nil_given =
+                  constr.check_relation(sub_type: node_type, super_type: AST::Builtin.nil_type).success? &&
+                    !node_type.is_a?(AST::Types::Any)
 
-              if nil_given
-                # nil is given ==> no block arg node is given
-                method_type, solved, _ = apply_solution(errors, node: node, method_type: method_type) {
-                  constraints.solution(checker, variables: method_type.free_variables, context: ccontext)
-                }
-                method_type = eliminate_vars(method_type, type_param_names) unless solved
+                if nil_given
+                  # nil is given ==> no block arg node is given
+                  method_type, solved, _ = apply_solution(errors, node: node, method_type: method_type) {
+                    constraints.solution(checker, variables: method_type.free_variables, context: ccontext)
+                  }
+                  method_type = eliminate_vars(method_type, type_param_names) unless solved
 
-                # Passing no block
-                errors << Diagnostic::Ruby::RequiredBlockMissing.new(
-                  node: node,
-                  method_type: method_type
-                )
-              else
-                # non-nil value is given
-                constr.check_relation(sub_type: node_type, super_type: arg.node_type, constraints: constraints).else do |result|
-                  errors << Diagnostic::Ruby::BlockTypeMismatch.new(
-                    node: arg.node,
-                    expected: arg.node_type,
-                    actual: node_type,
-                    result: result
+                  # Passing no block
+                  errors << Diagnostic::Ruby::RequiredBlockMissing.new(
+                    node: node,
+                    method_type: method_type
                   )
-                end
+                else
+                  # non-nil value is given
+                  constr.check_relation(sub_type: node_type, super_type: arg.node_type, constraints: constraints).else do |result|
+                    errors << Diagnostic::Ruby::BlockTypeMismatch.new(
+                      node: arg.node,
+                      expected: arg.node_type,
+                      actual: node_type,
+                      result: result
+                    )
+                  end
 
+                  method_type, solved, _ = apply_solution(errors, node: node, method_type: method_type) {
+                    constraints.solution(checker, variables: method_type.free_variables, context: ccontext)
+                  }
+                  method_type = eliminate_vars(method_type, type_param_names) unless solved
+                end
+              else
+                # Block is not given
                 method_type, solved, _ = apply_solution(errors, node: node, method_type: method_type) {
                   constraints.solution(checker, variables: method_type.free_variables, context: ccontext)
                 }
                 method_type = eliminate_vars(method_type, type_param_names) unless solved
               end
-            else
-              # Block is not given
+
+              return_type = method_type.type.return_type
+
+            when arg.block_missing?
+              # Block is required but not given
               method_type, solved, _ = apply_solution(errors, node: node, method_type: method_type) {
                 constraints.solution(checker, variables: method_type.free_variables, context: ccontext)
               }
-              method_type = eliminate_vars(method_type, type_param_names) unless solved
-            end
-
-            return_type = method_type.type.return_type
 
-          when arg.block_missing?
-            # Block is required but not given
-            method_type, solved, _ = apply_solution(errors, node: node, method_type: method_type) {
-              constraints.solution(checker, variables: method_type.free_variables, context: ccontext)
-            }
-
-            method_type = eliminate_vars(method_type, type_param_names) unless solved
-            return_type = method_type.type.return_type
+              method_type = eliminate_vars(method_type, type_param_names) unless solved
+              return_type = method_type.type.return_type
 
-            errors << Diagnostic::Ruby::RequiredBlockMissing.new(
-              node: node,
-              method_type: method_type
-            )
+              errors << Diagnostic::Ruby::RequiredBlockMissing.new(
+                node: node,
+                method_type: method_type
+              )
 
-          when arg.unexpected_block?
-            # Unexpected block pass node is given
+            when arg.unexpected_block?
+              # Unexpected block pass node is given
 
-            arg.node or raise
+              arg.node or raise
 
-            method_type, solved, _ = apply_solution(errors, node: node, method_type: method_type) {
-              constraints.solution(checker, variables: method_type.free_variables, context: ccontext)
-            }
-            method_type = eliminate_vars(method_type, type_param_names) unless solved
-            return_type = method_type.type.return_type
+              method_type, solved, _ = apply_solution(errors, node: node, method_type: method_type) {
+                constraints.solution(checker, variables: method_type.free_variables, context: ccontext)
+              }
+              method_type = eliminate_vars(method_type, type_param_names) unless solved
+              return_type = method_type.type.return_type
 
-            node_type, constr = constr.synthesize(arg.node)
+              node_type, constr = constr.synthesize(arg.node)
 
-            unless constr.check_relation(sub_type: node_type, super_type: AST::Builtin.nil_type).success?
-              errors << Diagnostic::Ruby::UnexpectedBlockGiven.new(
-                node: node,
-                method_type: method_type
-              )
+              unless constr.check_relation(sub_type: node_type, super_type: AST::Builtin.nil_type).success?
+                errors << Diagnostic::Ruby::UnexpectedBlockGiven.new(
+                  node: node,
+                  method_type: method_type
+                )
+              end
             end
           end
         end
@@ -4796,7 +4832,7 @@ module Steep
       if shape = calculate_interface(type, private: false)
         if entry = shape.methods[method]
           method_type = entry.method_types.find do |method_type|
-            method_type.type.params.optional?
+            method_type.type.params.nil? || method_type.type.params.optional?
           end
 
           method_type.type.return_type if method_type

data/lib/steep/type_inference/block_params.rb

@@ -248,7 +248,7 @@ module Steep
         # @type var zip: Array[[Param | MultipleParam, AST::Types::t]]
         zip = []
 
-        if untyped_args?(params_type)
+        if params_type.nil? || untyped_args?(params_type)
           params.each do |param|
             if param == rest_param
               zip << [param, AST::Builtin::Array.instance_type(fill_untyped: true)]

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -596,7 +596,8 @@ module Steep
         if shape = subtyping.builder.shape(type, config)
           if entry = shape.methods[method]
             method_type = entry.method_types.find do |method_type|
-              method_type.type.params.optional?
+              method_type.type.params.nil? ||
+                method_type.type.params.optional?
             end
 
             method_type.type.return_type if method_type

data/lib/steep/type_inference/method_params.rb

@@ -241,6 +241,22 @@ module Steep
 
         instance = new(args: original, method_type: method_type, forward_arg_type: nil)
 
+        unless method_type.type.params
+          args.each do |arg|
+            case arg.type
+            when :arg
+              name = arg.children[0]
+              instance.params[name] = PositionalParameter.new(name: name, type: AST::Builtin.any_type, node: arg)
+            when :optarg
+              name = arg.children[0]
+              instance.params[name] = PositionalParameter.new(name: name, type: AST::Builtin.any_type, node: arg)
+            when :forward_arg
+              return instance.update(forward_arg_type: true)
+            end
+          end
+          return instance
+        end
+
         positional_params = method_type.type.params.positional_params
 
         loop do

data/lib/steep/type_inference/send_args.rb

@@ -500,6 +500,7 @@ module Steep
       attr_reader :type
 
       def initialize(node:, arguments:, type:)
+        raise "Untyped function is not supported" unless type.type.params
         @node = node
         @arguments = arguments
         @type = type
@@ -508,9 +509,9 @@ module Steep
       def params
         case type
         when Interface::MethodType
-          type.type.params
+          type.type.params or raise
         when AST::Types::Proc
-          type.type.params
+          type.type.params or raise
         else
           raise
         end
@@ -526,10 +527,12 @@ module Steep
       end
 
       def positional_params
+        params or raise
         params.positional_params
       end
 
       def keyword_params
+        params or raise
         params.keyword_params
       end
 

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.7.0.dev.3"
+  VERSION = "1.7.0.dev.4"
 end

data/sig/steep/ast/types/factory.rbs

@@ -28,9 +28,9 @@ module Steep
 
         def type_1_opt: (t?) -> RBS::Types::t?
 
-        def function_1: (Interface::Function func) -> RBS::Types::Function
+        def function_1: (Interface::Function func) -> RBS::Types::function
 
-        def params: (RBS::Types::Function `type`) -> Interface::Function::Params
+        def params: (RBS::Types::function `type`) -> Interface::Function::Params?
 
         def type_param: (RBS::AST::TypeParam type_param) -> Interface::TypeParam