steep 2.0.0 → 2.1.0

data/lib/steep/subtyping/check.rb

@@ -189,7 +189,7 @@ module Steep
 
         relation.type!
 
-        Steep.logger.tagged "#{relation.sub_type} <: #{relation.super_type}" do
+        Steep.logger.tagged(-> { "#{relation.sub_type} <: #{relation.super_type}" }) do
           bounds = cache_bounds(relation)
           fvs = relation.sub_type.free_variables + relation.super_type.free_variables
           cached = cache[relation, @self_type, @instance_type, @class_type, bounds]
@@ -201,7 +201,7 @@ module Steep
             else
               push_assumption(relation) do
                 check_type0(relation).tap do |result|
-                  Steep.logger.debug "result=#{result.class}"
+                  Steep.logger.debug { "result=#{result.class}" }
                   cache[relation, @self_type, @instance_type, @class_type, bounds] = result
                 end
               end
@@ -644,6 +644,9 @@ module Steep
 
         All(relation) do |result|
           sub_args.zip(sup_args, sup_params.each).each do |sub_arg, sup_arg, sup_param|
+            sup_arg or raise
+            sup_param or raise
+
             case sup_param.variance
             when :covariant
               result.add(Relation.new(sub_type: sub_arg, super_type: sup_arg)) do |rel|
@@ -854,7 +857,7 @@ module Steep
       end
 
       def check_method_type(name, relation)
-        Steep.logger.tagged "#{name} : #{relation.sub_type} <: #{relation.super_type}" do
+        Steep.logger.tagged(-> { "#{name} : #{relation.sub_type} <: #{relation.super_type}" }) do
           relation.method!
 
           sub_type, super_type = relation

data/lib/steep/tagged_logging.rb

@@ -33,7 +33,10 @@ module Steep
     end
 
     def formatted_tags
-      current_tags.map { |tag| "[#{tag}]" }.join(" ")
+      current_tags.map do |tag|
+        tag = tag.call if tag.is_a?(Proc)
+        "[#{tag}]"
+      end.join(" ")
     end
   end
 end

data/lib/steep/type_construction.rb

@@ -653,7 +653,6 @@ module Steep
         instance_definition: instance_definition
       )
 
-      singleton_definition = checker.factory.definition_builder.build_singleton(module_context.class_name)
       type_env =
         TypeInference::TypeEnvBuilder.new(
           TypeInference::TypeEnvBuilder::Command::ImportGlobalDeclarations.new(checker.factory),
@@ -730,7 +729,7 @@ module Steep
     end
 
     def synthesize(node, hint: nil, condition: false)
-      Steep.logger.tagged "synthesize:(#{node.location&.yield_self {|loc| loc.expression.to_s.split(/:/, 2).last } || "-"})" do
+      Steep.logger.tagged(-> { "synthesize:(#{node.location&.yield_self {|loc| loc.expression.to_s.split(/:/, 2).last } || "-"})" }) do
         Steep.logger.debug node.type
         case node.type
         when :begin, :kwbegin
@@ -781,7 +780,7 @@ module Steep
               end
 
               if rhs
-                rhs_type, rhs_constr, rhs_context = synthesize(rhs, hint: hint).to_ary
+                rhs_type, rhs_constr, _ = synthesize(rhs, hint: hint).to_ary
 
                 constr = rhs_constr.update_type_env do |type_env|
                   var_type = rhs_type
@@ -1761,6 +1760,11 @@ module Steep
             else
               if hint
                 tuples = select_flatten_types(hint) {|type| type.is_a?(AST::Types::Tuple) } #: Array[AST::Types::Tuple]
+                if tuples.empty?
+                  if converted = try_convert(hint, :to_ary)
+                    tuples = select_flatten_types(converted) {|type| type.is_a?(AST::Types::Tuple) } #: Array[AST::Types::Tuple]
+                  end
+                end
                 unless tuples.empty?
                   fallback_pair = nil #: Pair?
                   tuples.each do |tuple|
@@ -1913,7 +1917,7 @@ module Steep
           yield_self do
             cond, true_clause, false_clause = node.children
 
-            cond_type, constr = synthesize(cond, condition: true).to_ary
+            _, constr = synthesize(cond, condition: true).to_ary
             interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: constr.typing, config: builder_config)
             truthy, falsy = interpreter.eval(env: constr.context.type_env, node: cond)
 
@@ -2045,7 +2049,7 @@ module Steep
                 branch_reachable = false
 
                 tests.each do |test|
-                  test_type, condition_constr = condition_constr.synthesize(test, condition: true)
+                  _, condition_constr = condition_constr.synthesize(test, condition: true)
                   truthy, falsy = interpreter.eval(env: condition_constr.context.type_env, node: test)
                   truthy_env = truthy.env
                   falsy_env = falsy.env
@@ -2295,7 +2299,7 @@ module Steep
         when :while, :until
           yield_self do
             cond, body = node.children
-            cond_type, constr = synthesize(cond, condition: true).to_ary
+            _, constr = synthesize(cond, condition: true).to_ary
 
             interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing, config: builder_config)
             truthy, falsy = interpreter.eval(env: constr.context.type_env, node: cond)
@@ -2347,7 +2351,7 @@ module Steep
                   .for_branch(body, break_context: TypeInference::Context::BreakContext.new(break_type: hint || AST::Builtin.nil_type, next_type: nil))
 
               typing.cursor_context.set_node_context(body, for_loop.context)
-              _, body_constr, body_context = for_loop.synthesize(body)
+              _, _, body_context = for_loop.synthesize(body)
 
               constr = cond_constr.update_type_env {|env| env.join(env, body_context.type_env) }
 
@@ -2696,7 +2700,7 @@ module Steep
             constr.add_typing(node, type: type)
           end
 
-        when :block, :numblock, :send, :csend
+        when :block, :numblock, :itblock, :send, :csend
           synthesize_sendish(node, hint: hint, tapp: nil)
 
         when :forwarded_args, :forward_arg
@@ -2772,6 +2776,20 @@ module Steep
 
           params = Parser::AST::Node.new(:args, arg_nodes)
 
+          if send_node.type == :lambda
+            # @type var node: Parser::AST::Node & Parser::AST::_BlockNode
+            type_lambda(node, params_node: params, body_node: body, type_hint: hint)
+          else
+            type_send(node, send_node: send_node, block_params: params, block_body: body, unwrap: send_node.type == :csend, tapp: tapp, hint: hint)
+          end
+        end
+      when :itblock
+        yield_self do
+          send_node, _name, body = node.children
+
+          arg_nodes = [Parser::AST::Node.new(:procarg0, [:it])]
+          params = Parser::AST::Node.new(:args, arg_nodes)
+
           if send_node.type == :lambda
             # @type var node: Parser::AST::Node & Parser::AST::_BlockNode
             type_lambda(node, params_node: params, body_node: body, type_hint: hint)
@@ -2872,10 +2890,8 @@ module Steep
           if node.type == :splat
             asgn_node = node.children[0]
             next unless asgn_node
-            var_type = asgn_node.type
           else
             asgn_node = node
-            var_type = type
           end
 
           case asgn_node.type
@@ -3150,11 +3166,14 @@ module Steep
       block =
         if block_param = params.block_param
           if block_param_type = block_param.type
-            case block_param_type
+            # Expanding aliases because the cases below test the structure of the type
+            expanded_type = deep_expand_alias(block_param_type) || block_param_type
+
+            case expanded_type
             when AST::Types::Proc
-              Interface::Block.new(type: block_param_type.type, optional: false, self_type: block_param_type.self_type)
+              Interface::Block.new(type: expanded_type.type, optional: false, self_type: expanded_type.self_type)
             else
-              if proc_type = optional_proc?(block_param_type)
+              if proc_type = optional_proc?(expanded_type)
                 Interface::Block.new(type: proc_type.type, optional: true, self_type: proc_type.self_type)
               else
                 block_constr.typing.add_error(
@@ -3346,7 +3365,7 @@ module Steep
             end
           end
 
-          if node.type == :csend || ((node.type == :block || node.type == :numblock) && node.children[0].type == :csend)
+          if node.type == :csend || ((node.type == :block || node.type == :numblock || node.type == :itblock) && node.children[0].type == :csend)
             optional_type = AST::Types::Union.build(types: [call.return_type, AST::Builtin.nil_type])
             call = call.with_return_type(optional_type)
           end
@@ -3509,7 +3528,7 @@ module Steep
 
         when AST::Types::Any
           case node.type
-          when :block, :numblock
+          when :block, :numblock, :itblock
             # @type var node: Parser::AST::Node & Parser::AST::_BlockNode
             block_annotations = source.annotations(block: node, factory: checker.factory, context: nesting)
             block_params or raise
@@ -4344,7 +4363,9 @@ module Steep
             when arg.compatible?
               if arg.node
                 # Block pass (&block) is given
-                node_type, constr = constr.synthesize(arg.node, hint: arg.node_type)
+                # Passing `proc_type` instead of `node_type` because a block-pass argument is a proc, not `nil`.
+                # `nil` is still allowed by the `node_type` check below.
+                node_type, constr = constr.synthesize(arg.node, hint: arg.proc_type)
 
                 nil_given =
                   constr.check_relation(sub_type: node_type, super_type: AST::Builtin.nil_type).success? &&

data/lib/steep/type_inference/case_when.rb

@@ -20,14 +20,14 @@ module Steep
 
           latest_constr, unreachable_pattern = latest_result
 
-          type, constr = yield(test_node, latest_constr, unreachable_pattern)
+          yield(test_node, latest_constr, unreachable_pattern)
           truthy_result, falsy_result = logic.eval(env: latest_constr.context.type_env, node: test_node)
 
           pattern_results << [pat, truthy_result, falsy_result]
         end
 
         def latest_result
-          if (_, truthy, falsy = pattern_results.last)
+          if (_, _, falsy = pattern_results.last)
             [
               initial_constr.update_type_env { falsy.env },
               falsy.unreachable

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -564,9 +564,12 @@ module Steep
                   false_types << type
                 end
               else
-                # For === (for_receiver: false), non-literal types can match the literal in truthy branch
-                # For == (for_receiver: true), non-literal types only go to falsy branch
-                true_types << AST::Types::Literal.new(value: value_node.children[0]) unless for_receiver
+                # For `==`, narrow only when the literal can be a value of `type`.
+                # e.g. `Symbol == :fatal` can be true, but `SomeClass == :fatal` cannot.
+                literal_type = AST::Types::Literal.new(value: value_node.children[0])
+                if !for_receiver || subtyping?(sub_type: literal_type, super_type: type)
+                  true_types << literal_type
+                end
                 false_types << type
               end
             end

data/lib/steep/type_inference/send_args.rb

@@ -473,16 +473,20 @@ module Steep
           end
         end
 
-        def node_type
+        def proc_type
           raise unless block
 
-          type = AST::Types::Proc.new(type: block.type, block: nil, self_type: block.self_type)
+          AST::Types::Proc.new(type: block.type, block: nil, self_type: block.self_type)
+        end
+
+        def node_type
+          raise unless block
 
           if block.optional?
-            type = AST::Types::Union.build(types: [type, AST::Builtin.nil_type])
+            AST::Types::Union.build(types: [proc_type, AST::Builtin.nil_type])
+          else
+            proc_type
           end
-
-          type
         end
       end
 

data/lib/steep/typing.rb

@@ -106,7 +106,7 @@ module Steep
             set(body_begin_pos..body_end_pos, context)
           end
 
-        when :block, :numblock
+        when :block, :numblock, :itblock
           range = block_range(node)
           set(range, context)
 
@@ -132,7 +132,7 @@ module Steep
                         node.loc.begin.end_pos # steep:ignore NoMethod
                       end
           end_pos = node.loc.end.begin_pos # steep:ignore NoMethod
-        when :numblock
+        when :numblock, :itblock
           send_node, _ = node.children
           begin_pos = node.loc.begin.end_pos # steep:ignore NoMethod
           end_pos = node.loc.end.begin_pos # steep:ignore NoMethod
@@ -245,7 +245,7 @@ module Steep
                       node.loc.begin.end_pos # steep:ignore NoMethod
                     end
         end_pos = node.loc.end.begin_pos # steep:ignore NoMethod
-      when :numblock
+      when :numblock, :itblock
         send_node, _ = node.children
         begin_pos = node.loc.begin.end_pos # steep:ignore NoMethod
         end_pos = node.loc.end.begin_pos # steep:ignore NoMethod

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "2.0.0"
+  VERSION = "2.1.0"
 end

data/lib/steep.rb

@@ -133,6 +133,7 @@ require "steep/server/target_group_files"
 require "steep/server/type_check_controller"
 require "steep/server/inline_source_change_detector"
 require "steep/server/master"
+require "steep/server/command_socket"
 require "steep/daemon"
 
 require "steep/project"

data/steep.gemspec

@@ -29,20 +29,14 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  if false
-    # This is to let dependabot use 3.3, instead of 3.1.x.
-    # They use `required_ruby_version=` method to detect the Ruby version they use.
-    spec.required_ruby_version = ">= 3.3.0"
-  end
-
-  spec.required_ruby_version = '>= 3.2.0'
+  spec.required_ruby_version = '>= 3.3.0'
 
   spec.add_runtime_dependency "parser", ">= 3.2"
   spec.add_runtime_dependency "prism", ">= 0.25.0"
   spec.add_runtime_dependency "rainbow", ">= 2.2.2", "< 4.0"
   spec.add_runtime_dependency "listen", "~> 3.0"
   spec.add_runtime_dependency "language_server-protocol", ">= 3.17.0.4", "< 4.0"
-  spec.add_runtime_dependency "rbs", "~> 4.0"
+  spec.add_runtime_dependency "rbs", "~> 4.2"
   spec.add_runtime_dependency "concurrent-ruby", ">= 1.1.10"
   spec.add_runtime_dependency "terminal-table", ">= 2", "< 5"
   spec.add_runtime_dependency "securerandom", ">= 0.1"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
@@ -97,14 +97,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -267,6 +267,7 @@ files:
 - bin/steep-check.rb
 - bin/steep-prof
 - doc/narrowing.md
+- doc/release.md
 - doc/shape.md
 - exe/steep
 - guides/README.md
@@ -361,6 +362,7 @@ files:
 - lib/steep/range_extension.rb
 - lib/steep/server/base_worker.rb
 - lib/steep/server/change_buffer.rb
+- lib/steep/server/command_socket.rb
 - lib/steep/server/custom_methods.rb
 - lib/steep/server/delay_queue.rb
 - lib/steep/server/inline_source_change_detector.rb
@@ -441,14 +443,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.19
 specification_version: 4
 summary: Gradual Typing for Ruby
 test_files: []