steep 1.6.0 → 1.7.1

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/case_when.rb

@@ -0,0 +1,301 @@
+module Steep
+  module TypeInference
+    class CaseWhen
+      class WhenPatterns
+        include NodeHelper
+
+        attr_reader :logic, :initial_constr, :unreachable_clause, :pattern_results
+
+        def initialize(logic, initial_constr, unreachable_clause, assignment_node)
+          @logic = logic
+          @initial_constr = initial_constr
+          @unreachable_clause = unreachable_clause
+          @assignment_node = assignment_node
+
+          @pattern_results = []
+        end
+
+        def add_pattern(pat)
+          test_node = pat.updated(:send, [pat, :===, assignment_node])
+
+          latest_constr, unreachable_pattern = latest_result
+
+          type, constr = 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)
+            [
+              initial_constr.update_type_env { falsy.env },
+              falsy.unreachable
+            ]
+          else
+            [initial_constr, unreachable_clause]
+          end
+        end
+
+        def body_result
+          raise if pattern_results.empty?
+
+          type_envs = pattern_results.map {|_, truthy, _| truthy.env }
+          env = initial_constr.context.type_env.join(*type_envs)
+
+          env = yield(env) || env
+
+          [
+            initial_constr.update_type_env { env },
+            unreachable_clause || pattern_results.all? {|_, truthy, _| truthy.unreachable }
+          ]
+        end
+
+        def falsy_result
+          (_, _, falsy = pattern_results.last) or raise
+
+          [
+            initial_constr.update_type_env { falsy.env },
+            unreachable_clause || falsy.unreachable
+          ]
+        end
+
+        def assignment_node()
+          clone_node(@assignment_node)
+        end
+      end
+
+      include NodeHelper
+      extend NodeHelper
+
+      def self.type_check(constr, node, logic, hint:, condition:)
+        case_when = new(node, logic) do |condition_node|
+          constr.synthesize(condition_node)
+        end
+
+        case_when.when_clauses() do |when_pats, patterns, body_node, loc|
+          patterns.each do |pat|
+            when_pats.add_pattern(pat) {|test, constr| constr.synthesize(test) }
+          end
+
+          body_constr, body_unreachable = when_pats.body_result() do |env|
+            case_when.propagate_value_node_type(env)
+          end
+
+          if body_node
+            body_constr = body_constr.for_branch(body_node)
+            type, body_constr = body_constr.synthesize(body_node, hint: hint, condition: condition)
+          else
+            type = AST::Builtin.nil_type
+          end
+
+          body_result = LogicTypeInterpreter::Result.new(
+            type: type,
+            env: body_constr.context.type_env,
+            unreachable: body_unreachable
+          )
+
+          falsy_constr, falsy_unreachable = when_pats.falsy_result
+          next_result = LogicTypeInterpreter::Result.new(
+            type: AST::Builtin.any_type,    # Unused for falsy pattern
+            env: falsy_constr.context.type_env,
+            unreachable: falsy_unreachable
+          )
+
+          [body_result, next_result]
+        end
+
+        case_when.else_clause do |else_node, constr|
+          constr.synthesize(else_node, hint: hint, condition: condition)
+        end
+
+        case_when.result()
+      end
+
+      attr_reader :location, :node, :condition_node, :when_nodes, :else_node
+      attr_reader :initial_constr, :logic, :clause_results, :else_result
+      attr_reader :assignment_node, :value_node, :var_name
+
+      def initialize(node, logic)
+        @node = node
+
+        condition_node, when_nodes, else_node, location = deconstruct_case_node!(node)
+        condition_node or raise "CaseWhen works for case-when syntax with condition node"
+
+        @condition_node = condition_node
+        @when_nodes = when_nodes
+        @else_node = else_node
+        @location = location
+        @logic = logic
+        @clause_results = []
+
+        type, constr = yield(condition_node)
+
+        @var_name = "__case_when:#{SecureRandom.alphanumeric(5)}__".to_sym
+        @value_node, @assignment_node = rewrite_condition_node(var_name, condition_node)
+
+        @initial_constr = constr.update_type_env do |env|
+          env.merge(local_variable_types: { var_name => [type, nil] })
+        end
+      end
+
+      def when_clauses()
+        when_nodes.each do |when_node|
+          clause_constr, unreachable = latest_result
+
+          patterns, body, loc = deconstruct_when_node!(when_node)
+
+          when_pats = WhenPatterns.new(
+            logic,
+            clause_constr,
+            unreachable,
+            assignment_node
+          )
+
+          body_result, next_result = yield(
+            when_pats,
+            patterns,
+            body,
+            loc
+          )
+
+          if body_result.unreachable
+            if body_result.type.is_a?(AST::Types::Any) || initial_constr.no_subtyping?(sub_type: body_result.type, super_type: AST::Builtin.bottom_type)
+              typing.add_error(
+                Diagnostic::Ruby::UnreachableValueBranch.new(
+                  node: when_node,
+                  type: body_result.type,
+                  location: loc.keyword
+                )
+              )
+            end
+          end
+
+          clause_results << [body_result, next_result]
+        end
+      end
+
+      def else_clause()
+        unless else_loc = has_else_clause?
+          return
+        end
+
+        constr, unreachable = latest_result
+
+        constr = constr.update_type_env do |env|
+          propagate_value_node_type(env) || env
+        end
+
+        @else_result =
+          if else_node
+            yield(else_node, constr)
+          else
+            TypeConstruction::Pair.new(type: AST::Builtin.nil_type, constr: constr)
+          end
+
+        else_result or raise
+
+        if unreachable
+          if else_result.type.is_a?(AST::Types::Any) || initial_constr.no_subtyping?(sub_type: else_result.type, super_type: AST::Builtin.bottom_type)
+            typing.add_error(
+              Diagnostic::Ruby::UnreachableValueBranch.new(
+                node: else_node || node,
+                type: else_result.type,
+                location: else_loc
+              )
+            )
+          end
+        end
+      end
+
+      def latest_result
+        if (_, falsy_result = clause_results.last)
+          [
+            initial_constr.update_type_env { falsy_result.env },
+            falsy_result.unreachable
+          ]
+        else
+          [initial_constr, false]
+        end
+      end
+
+      def result
+        results = clause_results.filter_map do |body, _|
+          unless body.unreachable
+            body
+          end
+        end
+        next_constr, next_clause_unreachable = latest_result
+
+        unless next_clause_unreachable
+          if else_result
+            results << LogicTypeInterpreter::Result.new(
+              type: else_result.type,
+              env: else_result.context.type_env,
+              unreachable: false    # Unused
+            )
+          else
+            results << LogicTypeInterpreter::Result.new(
+              type: AST::Builtin.nil_type,
+              env: next_constr.context.type_env,
+              unreachable: false
+            )
+          end
+        end
+
+        types = results.map {|result| result.type }
+        envs = results.map {|result| result.env }
+
+        [
+          types,
+          envs
+        ]
+      end
+
+      def has_else_clause?
+        location.else
+      end
+
+      def typing
+        logic.typing
+      end
+
+      def rewrite_condition_node(var_name, node)
+        case node.type
+        when :lvasgn
+          name, rhs = node.children
+          value, rhs = rewrite_condition_node(var_name, rhs)
+          [value, node.updated(nil, [name, rhs])]
+        when :lvar
+          name, = node.children
+          [
+            nil,
+            node.updated(:lvasgn, [name, node.updated(:lvar, [var_name])])
+          ]
+        when :begin
+          *children, last = node.children
+          value_node, last = rewrite_condition_node(var_name, last)
+          [
+            value_node,
+            node.updated(nil, children.push(last))
+          ]
+        else
+          [
+            node,
+            node.updated(:lvar, [var_name])
+          ]
+        end
+      end
+
+      def propagate_value_node_type(env)
+        if value_node
+          if (call = initial_constr.typing.method_calls[value_node]).is_a?(MethodCall::Typed)
+            if env[value_node]
+              env.merge(pure_method_calls: { value_node => [call, env[var_name]] })
+            end
+          end
+        end
+      end
+    end
+  end
+end

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.6.0"
+  VERSION = "1.7.1"
 end

data/lib/steep.rb

@@ -1,7 +1,7 @@
 require "steep/version"
 
 require "pathname"
-require "parser/ruby32"
+require "parser/ruby33"
 require "active_support"
 require "active_support/core_ext/object/try"
 require "active_support/core_ext/string/inflections"
@@ -52,6 +52,7 @@ require "steep/ast/node/type_assertion"
 require "steep/ast/node/type_application"
 require "steep/ast/builtin"
 require "steep/ast/types/factory"
+require "steep/ast/ignore"
 
 require "steep/range_extension"
 
@@ -76,6 +77,7 @@ require "steep/diagnostic/signature"
 require "steep/diagnostic/lsp_formatter"
 require "steep/signature/validator"
 require "steep/source"
+require "steep/source/ignore_ranges"
 require "steep/annotation_parser"
 require "steep/typing"
 require "steep/module_helper"
@@ -91,6 +93,7 @@ require "steep/type_inference/type_env_builder"
 require "steep/type_inference/logic_type_interpreter"
 require "steep/type_inference/multiple_assignment"
 require "steep/type_inference/method_call"
+require "steep/type_inference/case_when"
 
 require "steep/index/rbs_index"
 require "steep/index/signature_symbol_provider"
@@ -152,6 +155,10 @@ module Steep
     @logger || raise
   end
 
+  def self.ui_logger
+    @ui_logger || raise
+  end
+
   def self.new_logger(output, prev_level)
     ActiveSupport::TaggedLogging.new(Logger.new(output)).tap do |logger|
       logger.push_tags "Steep #{VERSION}"
@@ -165,23 +172,33 @@ module Steep
 
   def self.log_output=(output)
     @log_output = output
+
     prev_level = @logger&.level
     @logger = new_logger(output, prev_level)
+
+    prev_level = @ui_logger&.level
+    @ui_logger = new_logger(output, prev_level)
+
     output
   end
 
   @logger = nil
+  @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/steep.gemspec

@@ -18,8 +18,11 @@ Gem::Specification.new do |spec|
   spec.metadata["source_code_uri"] = "https://github.com/soutaro/steep"
   spec.metadata["changelog_uri"] = "https://github.com/soutaro/steep/blob/master/CHANGELOG.md"
 
+  skip_dirs = %w(test spec features smoke sig gemfile_steep .github .vscode)
+  skip_files = %w(Gemfile Gemfile.lock rbs_collection.steep.yaml rbs_collection.steep.lock.yaml)
+
   spec.files         = `git ls-files -z`.split("\x0").reject {|f|
-    f.match(%r{^(test|spec|features)/})
+    skip_dirs.any? {|dir| f.start_with?(dir + File::SEPARATOR) } || skip_files.include?(f)
   }
 
   spec.bindir        = "exe"
@@ -33,7 +36,7 @@ Gem::Specification.new do |spec|
   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.15", "< 4.0"
-  spec.add_runtime_dependency "rbs", ">= 3.1.0"
+  spec.add_runtime_dependency "rbs", ">= 3.5.0.pre"
   spec.add_runtime_dependency "concurrent-ruby", ">= 1.1.10"
   spec.add_runtime_dependency "terminal-table", ">= 2", "< 4"
   spec.add_runtime_dependency "securerandom", ">= 0.1"