steep 1.5.0.pre.3 → 1.5.0.pre.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fe028736497aa5746e128c32a325b6b98101dc30a97f82b16d572db9a3d39b8
-  data.tar.gz: 1ac7376836e97b860052b75aab42a08ad7a06143d8e0208c9fc764ea54e74cee
+  metadata.gz: cfb1de89ec50042cf06306ab17717671e8b6a8451ea2885b4af8085226f7994e
+  data.tar.gz: 1b67eb25821061afe42c8c4dd644b30370e866ac9ef8066cb77031799c981145
 SHA512:
-  metadata.gz: 9e1dbff5baebfd9ffd88390dcff4831d7d2bead258bd860fa7a6cf62e4c7880c398788c1d6f3ad163ac4256bcf9f25e59f78350a0422e4afa6ee360d38dbc876
-  data.tar.gz: ba0a4d84cb3a50c764369766fceae755fd6ec5717a488904db5d29f5b2ad48d05dadcec6ce37ef9092616aa540e3c513eaa526983ed15fe3096349d685aa0f24
+  metadata.gz: 1f0b3400822be747c45ed1d5c2cdfbddf8c0fdf70963061b66308464a18a95e493cc94ad406bbc444f618f562e0f95f276600c27e3ec2269f01504727b0528c7
+  data.tar.gz: 45b2a32802ea5ab504a8c3ee04f714a87b27227ffa66282d64243e3161aa0628001f1925e3ad7aaf09fcd0fbddc4def36e9b9940c76a87b195c2f51b19006bf9

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## master
 
+## 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.4)
       activesupport (>= 5.1)
       concurrent-ruby (>= 1.1.10)
       csv (>= 3.0.9)

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

@@ -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/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
@@ -1920,18 +1923,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 +1943,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
 
@@ -2003,11 +1997,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)
@@ -2030,9 +2019,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 +2029,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,12 +2039,9 @@ 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 <<
                     when_clause_constr
@@ -4490,16 +4472,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)
 
-        union_type(type1, type2)
+          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)
+        end
       end
     end
 
@@ -5029,33 +5022,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 +5088,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/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.4"
 end

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

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.4
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-05 00:00:00.000000000 Z
+date: 2023-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser