steep 1.5.0.pre.3 → 1.5.0.pre.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fe028736497aa5746e128c32a325b6b98101dc30a97f82b16d572db9a3d39b8
-  data.tar.gz: 1ac7376836e97b860052b75aab42a08ad7a06143d8e0208c9fc764ea54e74cee
+  metadata.gz: ed79428764aa83fbd2e7f3c5a8e52ff863b4e65bef05aae43ba9ca4b7c9d2f4e
+  data.tar.gz: be79772ce19f152e3048ae565802640cae96f1bfca98adf60eab47a28ab3ccad
 SHA512:
-  metadata.gz: 9e1dbff5baebfd9ffd88390dcff4831d7d2bead258bd860fa7a6cf62e4c7880c398788c1d6f3ad163ac4256bcf9f25e59f78350a0422e4afa6ee360d38dbc876
-  data.tar.gz: ba0a4d84cb3a50c764369766fceae755fd6ec5717a488904db5d29f5b2ad48d05dadcec6ce37ef9092616aa540e3c513eaa526983ed15fe3096349d685aa0f24
+  metadata.gz: aa071be8eaf425a2a36ffed4c8d0a97446997f9cbf85c9dc4190b5bf26c9bf5f66c7106ab27b96378d05e246a6327689ef491dedbd16ad7cb9eb8d8079b3818d
+  data.tar.gz: d7f842d51c84a2f48bdfd79a07de3e6265dd746497aa9661871f12b062832c2a24f46b37ce1ddb614ac5ba1c65f4c408e9e1eafec27fd69d7158514fe77e0fec

data/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## master
 
+## 1.5.0.pre.5 (2023-07-07)
+
+### Type checker core
+
+* Unreachability improvements ([#845](https://github.com/soutaro/steep/pull/845))
+* Fix type inference problem ([#843](https://github.com/soutaro/steep/pull/843))
+
+## 1.5.0.pre.4 (2023-07-06)
+
+### Type checker core
+
+* Fix unreachability test ([#842](https://github.com/soutaro/steep/pull/842))
+* Make type of `case` node `untyped` rather than `nil` ([#841](https://github.com/soutaro/steep/pull/841))
+* Fix `#partition_union` ([#840](https://github.com/soutaro/steep/pull/840))
+* Fix type-case ([#839](https://github.com/soutaro/steep/pull/839))
+
 ## 1.5.0.pre.3 (2023-07-05)
 
 ### Type checker core

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    steep (1.5.0.pre.3)
+    steep (1.5.0.pre.5)
       activesupport (>= 5.1)
       concurrent-ruby (>= 1.1.10)
       csv (>= 3.0.9)

data/lib/steep/ast/types/factory.rb

@@ -204,7 +204,7 @@ module Steep
           when Logic::Base
             RBS::Types::Bases::Bool.new(location: type.location)
           else
-            __skip__ = raise "Unexpected type given: #{type} (#{type.class})"
+            raise "Unexpected type given: #{type} (#{type.class})"
           end
         end
 
@@ -358,16 +358,21 @@ module Steep
               partition_union(unfold)
             end
           when AST::Types::Union
-            falsy_types, truthy_types = type.types.partition do |type|
-              (type.is_a?(AST::Types::Literal) && type.value == false) ||
-                type.is_a?(AST::Types::Nil)
+            truthy_types = [] #: Array[AST::Types::t]
+            falsy_types = [] #: Array[AST::Types::t]
+
+            type.types.each do |type|
+              truthy, falsy = partition_union(type)
+
+              truthy_types << truthy if truthy
+              falsy_types << falsy if falsy
             end
 
             [
               truthy_types.empty? ? nil : AST::Types::Union.build(types: truthy_types),
               falsy_types.empty? ? nil : AST::Types::Union.build(types: falsy_types)
             ]
-          when AST::Types::Any, AST::Types::Boolean
+          when AST::Types::Any, AST::Types::Boolean, AST::Types::Top, AST::Types::Logic::Base
             [type, type]
           when AST::Types::Nil
             [nil, type]

data/lib/steep/diagnostic/ruby.rb

@@ -767,6 +767,19 @@ module Steep
         end
       end
 
+      class UnreachableValueBranch < Base
+        attr_reader :type
+
+        def initialize(node:, type:, location: node.location.expression)
+          super(node: node, location: location)
+          @type = type
+        end
+
+        def header_line
+          "The branch may evaluate to a value of `#{type}` but unreachable"
+        end
+      end
+
       class UnexpectedSplat < Base
         attr_reader :type
 
@@ -968,7 +981,8 @@ module Steep
           {
             ImplicitBreakValueMismatch => :warning,
             FallbackAny => :information,
-            UnreachableBranch => :warning,
+            UnreachableValueBranch => :warning,
+            UnreachableBranch => :information,
             UnknownConstant => :warning,
             MethodDefinitionMissing => :information,
             FalseAssertion => :information,
@@ -989,6 +1003,7 @@ module Steep
             NoMethod => nil,
             ImplicitBreakValueMismatch => nil,
             FallbackAny => nil,
+            UnreachableValueBranch => nil,
             UnreachableBranch => nil,
             UnknownConstant => nil,
             MethodDefinitionMissing => nil,
@@ -1006,6 +1021,7 @@ module Steep
             NoMethod => nil,
             ImplicitBreakValueMismatch => nil,
             FallbackAny => nil,
+            UnreachableValueBranch => nil,
             UnreachableBranch => nil,
             UnknownConstant => nil,
             MethodDefinitionMissing => nil,

data/lib/steep/type_construction.rb

@@ -1398,8 +1398,11 @@ module Steep
         when :true, :false
           ty = node.type == :true ? AST::Types::Literal.new(value: true) : AST::Types::Literal.new(value: false)
 
-          if hint && check_relation(sub_type: ty, super_type: hint).success? && !hint.is_a?(AST::Types::Any) && !hint.is_a?(AST::Types::Top)
+          case
+          when hint && check_relation(sub_type: ty, super_type: hint).success? && !hint.is_a?(AST::Types::Any) && !hint.is_a?(AST::Types::Top)
             add_typing(node, type: hint)
+          when condition
+            add_typing(node, type: ty)
           else
             add_typing(node, type: AST::Types::Boolean.new)
           end
@@ -1880,9 +1883,25 @@ module Steep
 
             if truthy.unreachable
               if true_clause
+                _, _, _, loc = deconstruct_if_node!(node)
+
+                if loc.respond_to?(:keyword)
+                  condition_loc = loc #: NodeHelper::condition_loc
+                  case condition_loc.keyword.source
+                  when "if"
+                    location = condition_loc.begin || condition_loc.keyword
+                  when "unless"
+                    # `else` token always exists
+                    location = condition_loc.else || raise
+                  end
+                else
+                  location = true_clause.loc.expression
+                end
+
                 typing.add_error(
                   Diagnostic::Ruby::UnreachableBranch.new(
-                    node: true_clause || node
+                    node: true_clause,
+                    location: location || raise
                   )
                 )
               end
@@ -1890,9 +1909,25 @@ module Steep
 
             if falsy.unreachable
               if false_clause
+                _, _, _, loc = deconstruct_if_node!(node)
+
+                if loc.respond_to?(:keyword)
+                  condition_loc = loc #: NodeHelper::condition_loc
+                  case condition_loc.keyword.source
+                  when "if"
+                    # `else` token always exists
+                    location = condition_loc.else || raise
+                  when "unless"
+                    location = condition_loc.begin || condition_loc.keyword
+                  end
+                else
+                  location = false_clause.loc.expression
+                end
+
                 typing.add_error(
                   Diagnostic::Ruby::UnreachableBranch.new(
-                    node: false_clause || node
+                    node: false_clause,
+                    location: location || raise
                   )
                 )
               end
@@ -1920,18 +1955,9 @@ module Steep
                 cond_vars.delete(name)
               end
 
-              var_name = :"_a#{SecureRandom.alphanumeric(4)}"
-              var_cond, value_node = extract_outermost_call(cond, var_name)
-              if value_node
-                unless constr.context.type_env[value_node]
-                  constr = constr.update_type_env do |env|
-                    env.assign_local_variable(var_name, cond_type, nil)
-                  end
-                  cond = var_cond
-                else
-                  value_node = nil
-                end
-              end
+              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
 
@@ -1949,12 +1975,12 @@ module Steep
                 false_branch_reachable = false
 
                 tests.each do |test|
-                  test_node = test.updated(:send, [test, :===, cond])
+                  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 = truthy.env
-                  falsy_env = falsy.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
 
@@ -1967,19 +1993,25 @@ module Steep
                 next_branch_reachable &&= false_branch_reachable
                 body_constr = when_constr.update_type_env {|env| env.join(*test_envs) }
 
-                if body
-                  branch_results <<
+                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
-                  branch_results << Pair.new(type: AST::Builtin.nil_type, constr: body_constr)
-                end
+                  else
+                    Pair.new(type: AST::Builtin.nil_type, constr: body_constr)
+                  end
 
-                unless branch_reachable
+                branch_results << branch_result
+
+                if !branch_reachable && !branch_result.type.is_a?(AST::Types::Bot)
                   typing.add_error(
-                    Diagnostic::Ruby::UnreachableBranch.new(node: body || clause)
+                    Diagnostic::Ruby::UnreachableValueBranch.new(
+                      node: clause,
+                      type: branch_result.type,
+                      location: clause.location.keyword
+                    )
                   )
                 end
 
@@ -2003,11 +2035,6 @@ module Steep
               types = branch_results.map(&:type)
               constrs = branch_results.map(&:constr)
 
-              cond_type = when_constr.context.type_env[var_name]
-              cond_type ||= when_constr.context.type_env[cond_vars.first || raise] unless cond_vars.empty?
-              cond_type ||= when_constr.context.type_env[value_node] if value_node
-              cond_type ||= typing.type_of(node: node.children[0])
-
               if !next_branch_reachable
                 # Exhaustive
                 _, _, _, loc = deconstruct_case_node!(node)
@@ -2015,9 +2042,14 @@ module Steep
                 # `else` may present even if it's empty
                 if loc.else
                   if els
-                    typing.add_error Diagnostic::Ruby::UnreachableBranch.new(node: els)
-                  else
-                    typing.add_error Diagnostic::Ruby::UnreachableBranch.new(node: node, location: loc.else)
+                    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
@@ -2030,9 +2062,6 @@ module Steep
               branch_results = [] #: Array[Pair]
 
               condition_constr = constr
-              clause_constr = constr
-
-              next_branch_reachable = true
 
               whens.each do |when_clause|
                 when_clause_constr = condition_constr
@@ -2043,7 +2072,6 @@ module Steep
                 *tests, body = when_clause.children
 
                 branch_reachable = false
-                false_branch_reachable = false
 
                 tests.each do |test|
                   test_type, condition_constr = condition_constr.synthesize(test, condition: true)
@@ -2054,27 +2082,32 @@ module Steep
                   condition_constr = condition_constr.update_type_env { falsy_env }
                   body_envs << truthy_env
 
-                  branch_reachable ||= next_branch_reachable && !truthy.unreachable
-                  false_branch_reachable ||= !falsy.unreachable
+                  branch_reachable ||= !truthy.unreachable
                 end
 
-                next_branch_reachable &&= false_branch_reachable
-
-                if body
-                  branch_results <<
+                branch_result =
+                  if body
                     when_clause_constr
                       .for_branch(body)
                       .update_type_env {|env| env.join(*body_envs) }
                       .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
                       .synthesize(body, hint: hint)
-                else
-                  branch_results << Pair.new(type: AST::Builtin.nil_type, constr: when_clause_constr)
-                end
+                  else
+                    Pair.new(type: AST::Builtin.nil_type, constr: when_clause_constr)
+                  end
+
+                branch_results << branch_result
 
                 unless branch_reachable
-                  typing.add_error(
-                    Diagnostic::Ruby::UnreachableBranch.new(node: body || when_clause)
-                  )
+                  unless branch_result.type.is_a?(AST::Types::Bot)
+                    typing.add_error(
+                      Diagnostic::Ruby::UnreachableValueBranch.new(
+                        node: when_clause,
+                        type: branch_result.type,
+                        location: when_clause.location.keyword || raise
+                      )
+                    )
+                  end
                 end
               end
 
@@ -3931,13 +3964,15 @@ module Steep
             end
 
             if hint && !fvs.empty?
-              if check_relation(sub_type: method_type.type.return_type, super_type: hint, constraints: constraints).success?
-                method_type, solved, s = apply_solution(errors, node: node, method_type: method_type) do
-                  constraints.solution(checker, variables: fvs, context: ccontext)
+              if hint.free_variables.subset?(self_type.free_variables)
+                if check_relation(sub_type: method_type.type.return_type, super_type: hint, constraints: constraints).success?
+                  method_type, solved, s = apply_solution(errors, node: node, method_type: method_type) do
+                    constraints.solution(checker, variables: fvs, context: ccontext)
+                  end
                 end
-              end
 
-              method_type.block or raise
+                method_type.block or raise
+              end
             end
 
             # Method accepts block
@@ -4490,16 +4525,27 @@ module Steep
     end
 
     def union_type_unify(*types)
-      types.inject do |type1, type2|
-        unless no_subtyping?(sub_type: type1, super_type: type2)
-          next type2
-        end
+      types = types.reject {|t| t.is_a?(AST::Types::Bot) }
 
-        unless no_subtyping?(sub_type: type2, super_type: type1)
-          next type1
-        end
+      if types.empty?
+        AST::Types::Bot.new
+      else
+        types.inject do |type1, type2|
+          next type2 if type1.is_a?(AST::Types::Any)
+          next type1 if type2.is_a?(AST::Types::Any)
+
+          unless no_subtyping?(sub_type: type1, super_type: type2)
+            # type1 <: type2
+            next type2
+          end
+
+          unless no_subtyping?(sub_type: type2, super_type: type1)
+            # type2 <: type1
+            next type1
+          end
 
-        union_type(type1, type2)
+          union_type(type1, type2)
+        end
       end
     end
 
@@ -5029,33 +5075,19 @@ module Steep
       with_new_typing(typing.parent || raise)
     end
 
-    def extract_outermost_call(node, var_name)
+    def transform_condition_node(node, var_name)
       case node.type
       when :lvasgn
         name, rhs = node.children
-        rhs, value_node = extract_outermost_call(rhs, var_name)
-        if value_node
-          [node.updated(nil, [name, rhs]), value_node]
-        else
-          [node, value_node]
-        end
+        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 = extract_outermost_call(last, var_name)
-        if value_node
-          [node.updated(nil, children.push(last)), value_node]
-        else
-          [node, value_node]
-        end
-      when :lvar
-        [node, nil]
+        last, value_node = transform_condition_node(last, var_name)
+        [node.updated(nil, children.push(last)), value_node]
       else
-        if value_node?(node)
-          [node, nil]
-        else
-          var_node = node.updated(:lvar, [var_name])
-          [var_node, node]
-        end
+        var_node = node.updated(:lvar, [var_name])
+        [var_node, node]
       end
     end
 
@@ -5109,5 +5141,20 @@ 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

data/lib/steep/type_inference/context.rb

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

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -417,6 +417,10 @@ module Steep
           end
 
           [truthy_types, falsy_types]
+        when AST::Types::Boolean
+          [[arg_type], [arg_type]]
+        when AST::Types::Top, AST::Types::Any
+          [[arg_type], [arg_type]]
         else
           types = [arg_type]
 

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.5.0.pre.3"
+  VERSION = "1.5.0.pre.5"
 end

data/sig/shims/parser/nodes.rbs

@@ -62,6 +62,11 @@ module Parser
       %a{pure} def end: () -> Source::Range?
     end
 
+    # ```ruby
+    # foo ? bar : baz
+    # #   ^               question
+    # #         ^         colon
+    # ```
     interface _Ternary
       %a{pure} def question: () -> Source::Range
 

data/sig/steep/diagnostic/ruby.rbs

@@ -479,6 +479,31 @@ module Steep
         def header_line: () -> String
       end
 
+      # The branch is unreachable, but not `bot` type
+      #
+      # We often have `else` branch to make the code more defensive:
+      #
+      # ```ruby
+      # case value
+      # when Integer
+      #   # ...
+      # when String
+      #   # ...
+      # else
+      #   raise "Cannot happen!"
+      # end
+      # ```
+      #
+      # This diagnostic allows writing `raise` or `return`, by checking the type of the branch body is `bot` or not.
+      # 
+      class UnreachableValueBranch < Base
+        attr_reader type: AST::Types::t
+
+        def initialize: (node: Parser::AST::Node, type: AST::Types::t, ?location: location) -> void
+
+        def header_line: () -> String
+      end
+
       class UnexpectedSplat < Base
         attr_reader type: untyped
 

data/sig/steep/type_construction.rbs

@@ -538,18 +538,30 @@ module Steep
     # Returns a pair of transformed node and the outer most call/non-value node if present.
     #
     # ```rb
-    # x = y = foo()   # Call `#transform_value_node` with the node and var_name `:__foo__`
+    # x = y = foo()   # Call `#transform_condition_node` with the node and var_name `:__foo__`
     #                 # => Returns [x = y = __foo__, foo()]
+    #
+    # x               # Call `#transform_condition_node` with the node and var_name `:__foo__`
+    #                 # => Returns [__foo__, x]
     # ```
     #
     # This is typically used for transforming assginment node for case condition.
     #
-    def extract_outermost_call: (Parser::AST::Node node, Symbol) -> [Parser::AST::Node, Parser::AST::Node?]
+    def transform_condition_node: (Parser::AST::Node node, Symbol) -> [Parser::AST::Node, Parser::AST::Node]
 
     def type_name: (AST::Types::t) -> RBS::TypeName?
 
     def singleton_type: (AST::Types::t) -> AST::Types::t?
 
     def instance_type: (AST::Types::t) -> AST::Types::t?
+
+    # Propagate an entry of `source` in TypeEnv to `dest`
+    #
+    # `source` is name of a local variable.
+    #
+    # If `dest` is a `lvar` node, it updates local variable entry of TypeEnv.
+    # Otherwise, it updates *pure* call of `dest` if it already exists.
+    #
+    def propagate_type_env: (Symbol source, Parser::AST::Node dest, TypeInference::TypeEnv) -> TypeInference::TypeEnv
   end
 end

data/smoke/diagnostics/test_expectations.yml

@@ -120,18 +120,6 @@
     message: 'The method parameter has different kind from the declaration `(name:
       ::String, size: ::Integer) -> void`'
     code: Ruby::DifferentMethodParameterKind
-- file: else_on_exhaustive_case.rb
-  diagnostics:
-  - range:
-      start:
-        line: 11
-        character: 2
-      end:
-        line: 11
-        character: 26
-    severity: ERROR
-    message: The branch is unreachable
-    code: Ruby::UnreachableBranch
 - file: incompatible_annotation.rb
   diagnostics:
   - range:

data/smoke/type_case/test_expectations.yml

@@ -13,14 +13,14 @@
     code: Ruby::NoMethod
   - range:
       start:
-        line: 12
-        character: 2
+        line: 11
+        character: 0
       end:
-        line: 12
-        character: 10
+        line: 11
+        character: 4
     severity: ERROR
-    message: The branch is unreachable
-    code: Ruby::UnreachableBranch
+    message: The branch may evaluate to a value of `untyped` but unreachable
+    code: Ruby::UnreachableValueBranch
   - range:
       start:
         line: 12

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 1.5.0.pre.3
+  version: 1.5.0.pre.5
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-05 00:00:00.000000000 Z
+date: 2023-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser