steep 1.6.0 → 1.7.1

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
@@ -1966,113 +1971,7 @@ module Steep
             interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing, config: builder_config)
 
             if cond
-              branch_results = [] #: Array[Pair]
-
-              cond_type, constr = constr.synthesize(cond)
-
-              var_name = :"_a[#{SecureRandom.alphanumeric(4)}]"
-              var_cond, value_node = transform_condition_node(cond, var_name)
-              constr = constr.update_type_env {|env| env.assign_local_variable(var_name, cond_type, nil) }
-
-              next_branch_reachable = true
-
-              when_constr = constr
-              whens.each do |clause|
-                # @type var tests: Array[Parser::AST::Node]
-                # @type var body: Parser::AST::Node?
-                *tests, body = clause.children
-
-                test_constr = when_constr
-                # @type var test_envs: Array[TypeInference::TypeEnv]
-                test_envs = []
-
-                branch_reachable = false
-                false_branch_reachable = false
-
-                tests.each do |test|
-                  test_node = test.updated(:send, [test, :===, var_cond])
-                  test_type, test_constr = test_constr.synthesize(test_node, condition: true).to_ary
-                  truthy, falsy = interpreter.eval(node: test_node, env: test_constr.context.type_env)
-
-                  truthy_env = propagate_type_env(var_name, value_node, truthy.env)
-                  falsy_env = propagate_type_env(var_name, value_node, falsy.env)
-
-                  test_envs << truthy_env
-
-                  test_constr = test_constr.update_type_env { falsy_env }
-
-                  branch_reachable ||= next_branch_reachable && !truthy.unreachable
-                  false_branch_reachable = !falsy.unreachable
-                end
-
-                next_branch_reachable &&= false_branch_reachable
-                body_constr = when_constr.update_type_env {|env| env.join(*test_envs) }
-
-                branch_result =
-                  if body
-                    body_constr
-                      .for_branch(body)
-                      .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
-                      .synthesize(body, hint: hint)
-                  else
-                    Pair.new(type: AST::Builtin.nil_type, constr: body_constr)
-                  end
-
-                branch_results << branch_result
-
-                if !branch_reachable && !branch_result.type.is_a?(AST::Types::Bot)
-                  typing.add_error(
-                    Diagnostic::Ruby::UnreachableValueBranch.new(
-                      node: clause,
-                      type: branch_result.type,
-                      location: clause.location.keyword
-                    )
-                  )
-                end
-
-                when_constr = test_constr
-              end
-
-              if els
-                node.loc.else or raise
-
-                begin_pos = node.loc.else.end_pos
-                end_pos = node.loc.end.begin_pos
-                typing.add_context(begin_pos..end_pos, context: when_constr.context)
-
-                else_result = when_constr.synthesize(els, hint: hint)
-
-                if next_branch_reachable
-                  branch_results << else_result
-                end
-              end
-
-              types = branch_results.map(&:type)
-              constrs = branch_results.map(&:constr)
-
-              if !next_branch_reachable
-                # Exhaustive
-                _, _, _, loc = deconstruct_case_node!(node)
-
-                # `else` may present even if it's empty
-                if loc.else
-                  if els
-                    else_result or raise
-                    unless else_result.type.is_a?(AST::Types::Bot)
-                      typing.add_error Diagnostic::Ruby::UnreachableValueBranch.new(
-                        node: els,
-                        type: else_result.type,
-                        location: node.loc.else || raise
-                      )
-                    end
-                  end
-                end
-              else
-                unless els
-                  constrs << when_constr
-                  types << AST::Builtin.nil_type
-                end
-              end
+              types, envs = TypeInference::CaseWhen.type_check(constr, node, interpreter, hint: hint, condition: condition)
             else
               branch_results = [] #: Array[Pair]
 
@@ -2131,7 +2030,7 @@ module Steep
               end
 
               types = branch_results.map(&:type)
-              constrs = branch_results.map(&:constr)
+              envs = branch_results.map {|result| result.constr.context.type_env }
 
               unless els
                 types << AST::Builtin.nil_type
@@ -2139,7 +2038,6 @@ module Steep
             end
 
             constr = constr.update_type_env do |env|
-              envs = constrs.map {|c| c.context.type_env }
               env.join(*envs)
             end
 
@@ -2208,6 +2106,7 @@ module Steep
               end
 
               if body
+                resbody_construction.typing.add_context_for_node(body, context: resbody_construction.context)
                 resbody_construction.synthesize(body, hint: hint)
               else
                 Pair.new(constr: body_constr, type: AST::Builtin.nil_type)
@@ -2278,10 +2177,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
@@ -2455,11 +2365,8 @@ module Steep
           end
 
         when :defined?
-          each_child_node(node) do |child|
-            synthesize(child)
-          end
-
-          add_typing(node, type: AST::Builtin.any_type)
+          type_any_rec(node, only_children: true)
+          add_typing(node, type: AST::Builtin.optional(AST::Builtin::String.instance_type))
 
         when :gvasgn
           yield_self do
@@ -2495,31 +2402,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
@@ -2721,6 +2630,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))
@@ -3294,7 +3204,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(
@@ -3541,16 +3451,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
@@ -3732,10 +3642,6 @@ module Steep
       end
     end
 
-    def inspect
-      "#<#{self.class}>"
-    end
-
     def with_child_typing(range:)
       constr = with_new_typing(typing.new_child(range))
 
@@ -4027,13 +3933,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
@@ -4122,11 +4032,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
@@ -4214,129 +4125,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
@@ -4463,7 +4388,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|
@@ -4498,10 +4423,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
 
@@ -4774,8 +4701,8 @@ module Steep
       !nodes.empty? && nodes.all? {|child| child.type == :class || child.type == :module}
     end
 
-    def type_any_rec(node)
-      add_typing node, type: AST::Builtin.any_type
+    def type_any_rec(node, only_children: false)
+      add_typing node, type: AST::Builtin.any_type unless only_children
 
       each_child_node(node) do |child|
         type_any_rec(child)
@@ -4906,7 +4833,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
@@ -5162,22 +5089,6 @@ module Steep
       with_new_typing(typing.parent || raise)
     end
 
-    def transform_condition_node(node, var_name)
-      case node.type
-      when :lvasgn
-        name, rhs = node.children
-        rhs, value_node = transform_condition_node(rhs, var_name)
-        [node.updated(nil, [name, rhs]), value_node]
-      when :begin
-        *children, last = node.children
-        last, value_node = transform_condition_node(last, var_name)
-        [node.updated(nil, children.push(last)), value_node]
-      else
-        var_node = node.updated(:lvar, [var_name])
-        [var_node, node]
-      end
-    end
-
     def type_name(type)
       case type
       when AST::Types::Name::Instance, AST::Types::Name::Singleton
@@ -5228,20 +5139,5 @@ module Steep
         end
       end
     end
-
-    def propagate_type_env(source, dest, env)
-      source_type = env[source] or raise
-
-      if dest.type == :lvar
-        var_name = dest.children[0] #: Symbol
-        env.assign_local_variable(var_name, source_type, nil)
-      else
-        if env[dest]
-          env.replace_pure_call_type(dest, source_type)
-        else
-          env
-        end
-      end
-    end
   end
 end