steep 1.7.0.dev.2 → 1.7.0.dev.4

data/lib/steep/type_construction.rb

@@ -878,6 +878,7 @@ module Steep
             if self_type && method_context!.method
               if super_def = method_context!.super_method
                 super_method = Interface::Shape::Entry.new(
+                  private_method: true,
                   method_types: super_def.defs.map {|type_def|
                     decl = TypeInference::MethodCall::MethodDecl.new(
                       method_name: InstanceMethodName.new(
@@ -1634,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)
@@ -1812,7 +1817,7 @@ module Steep
                 .for_branch(right_node)
                 .synthesize(right_node, hint: left_truthy.type, condition: true).to_ary
 
-            right_truthy, right_falsy = interpreter.eval(env: left_falsy.env, node: right_node)
+            right_truthy, right_falsy = interpreter.eval(env: right_context.type_env, node: right_node)
 
             case
             when left_falsy.unreachable
@@ -2171,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
@@ -2385,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
@@ -2611,6 +2629,7 @@ module Steep
           end
         end
       rescue RBS::BaseError => exn
+        Steep.logger.warn("hello")
         Steep.logger.warn { "Unexpected RBS error: #{exn.message}" }
         exn.backtrace&.each {|loc| Steep.logger.warn "  #{loc}" }
         typing.add_error(Diagnostic::Ruby::UnexpectedError.new(node: node, error: exn))
@@ -3184,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(
@@ -3431,16 +3450,16 @@ module Steep
         self_type: self_type,
         class_type: module_context.module_type,
         instance_type: module_context.instance_type,
-        variable_bounds: variable_context.upper_bounds
+        variable_bounds: context.variable_context.upper_bounds
       )
     end
 
     def calculate_interface(type, method_name = nil, private:)
-      shape = checker.builder.shape(
-        type,
-        public_only: !private,
-        config: builder_config
-      )
+      shape = checker.builder.shape(type, builder_config)
+
+      unless private
+        shape = shape&.public_shape
+      end
 
       if method_name
         if shape
@@ -3913,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
@@ -4008,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
@@ -4100,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
@@ -4349,7 +4387,7 @@ module Steep
     def for_block(body_node, block_params:, block_param_hint:, block_type_hint:, block_block_hint:, block_annotations:, node_type_hint:, block_self_hint:)
       block_param_pairs = block_param_hint && block_params.zip(block_param_hint, block_block_hint, factory: checker.factory)
 
-      # @type var param_types_hash: Hash[Symbol, AST::Types::t]
+      # @type var param_types_hash: Hash[Symbol?, AST::Types::t]
       param_types_hash = {}
       if block_param_pairs
         block_param_pairs.each do |param, type|
@@ -4384,10 +4422,12 @@ module Steep
         end
       end
 
-      param_types_hash.delete_if {|name, _| SPECIAL_LVAR_NAMES.include?(name) }
+      param_types_hash.delete_if {|name, _| name && SPECIAL_LVAR_NAMES.include?(name) }
 
       param_types = param_types_hash.each.with_object({}) do |pair, hash| #$ Hash[Symbol, [AST::Types::t, AST::Types::t?]]
         name, type = pair
+        # skip unamed arguments `*`, `**` and `&`
+        next if name.nil?
         hash[name] = [type, nil]
       end
 
@@ -4792,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

@@ -57,8 +57,9 @@ module Steep
 
         def variable_types
           each_param.with_object({}) do |param, hash|
+            var_name = param.var || next
             # @type var hash: Hash[Symbol, AST::Types::t?]
-            hash[param.var] = param.type
+            hash[var_name] = param.type
           end
         end
 
@@ -133,10 +134,17 @@ module Steep
           else
             var = arg.children[0]
             type = annotations.var_type(lvar: var)
-
             case arg.type
-            when :arg, :procarg0
+            when :arg
               default_params << Param.new(var: var, type: type, value: nil, node: arg)
+            when :procarg0
+              var = arg.children[0]
+              if var.is_a?(Symbol)
+                default_params << Param.new(var: var, type: type, value: nil, node: arg)
+              else
+                var = var.children[0]
+                default_params << Param.new(var: var, type: type, value: nil, node: arg)
+              end
             when :optarg
               default_params = trailing_params
               optional_params << Param.new(var: var, type: type, value: arg.children.last, node: arg)
@@ -240,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/context.rb

@@ -125,7 +125,7 @@ module Steep
         end
 
         def upper_bounds
-          table.each_value.with_object({}) do |type_param, bounds|
+          @upper_bounds ||= table.each_value.with_object({}) do |type_param, bounds|
             if type_param.upper_bound
               bounds[type_param.name] = type_param.upper_bound
             end

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -593,10 +593,11 @@ module Steep
       end
 
       def try_convert(type, method)
-        if shape = subtyping.builder.shape(type, public_only: true, config: config)
+        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.2"
+  VERSION = "1.7.0.dev.4"
 end

data/lib/steep.rb

@@ -186,15 +186,19 @@ module Steep
   @ui_logger = nil
   self.log_output = STDERR
 
-  def self.measure(message, level: :warn)
+  def self.measure(message, level: :warn, threshold: 0.0)
     start = Time.now
-    yield
-  ensure
-    time = Time.now - start
-    if level.is_a?(Symbol)
-      level = Logger.const_get(level.to_s.upcase)
+    begin
+      yield
+    ensure
+      time = Time.now - start
+      if level.is_a?(Symbol)
+        level = Logger.const_get(level.to_s.upcase)
+      end
+      if time > threshold
+        self.logger.log(level) { "#{message} took #{time} seconds" }
+      end
     end
-    self.logger.log(level) { "#{message} took #{time} seconds" }
   end
 
   def self.log_error(exn, message: "Unexpected error: #{exn.inspect}")

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