steep 0.35.0 → 0.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ddd53798b724f6fd1a93d869b03a3864db04bed448552a75dadeabe8d1bc51e
-  data.tar.gz: c85f6c58a010ed11dfc1041f8ba98007e0f557d7bda133222b94915dfed0d6ca
+  metadata.gz: 5203340eb3b3534da5f1071cc497bbe7a481553e909088277c83dbfe5e5c0bbc
+  data.tar.gz: 11863c0ea9b692de6fba552ec01645525240c025c598235f9b3bf88e35571ed5
 SHA512:
-  metadata.gz: 79a7742bdef0d368aa2dceaa528cf3e4bc74bccefafc0d6c366aa94994917e7d5560c8d4fd6f03adf0d50c3b8536d80d7e998bba3a9dc5cb872c7047c0079cba
-  data.tar.gz: 512b5bdf6efd6e465d5e3147de2df6cafb549fe68e05890efc13fffcc763b0cec1c48005a1734b6ade2cd120fa48059c435c20bad4b9998b1d15a0b4f557f615
+  metadata.gz: 9897fecb7ca5b60da9eeb236e5f06af1a9b2fa2a2df2bd87d07f7a496f0f05b988b30db2e294797304c6d7f0e8fe478cdc1d41049cbaf2e56c45108444b2c721
+  data.tar.gz: fa2dca2cd37d74e39878ab3da7a5453a714f50e921fcd1c0e75054bf083a11003cb5799f4f92531a10bce6074dce3cce88c90daeb214b9fb45d7f5612e294fb3

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## master
 
+## 0.36.0 (2020-11-16)
+
+* Flow-sensitive typing improvements with `||` and `&&` ([#260](https://github.com/soutaro/steep/pull/260))
+* Type-case improvement ([#259](https://github.com/soutaro/steep/pull/259))
+* Subtyping between `bool` and logic types ([#258](https://github.com/soutaro/steep/pull/258))
+
 ## 0.35.0 (2020-11-14)
 
 * Support third party RBS repository ([#231](https://github.com/soutaro/steep/pull/231), [#254](https://github.com/soutaro/steep/pull/254), [#255](https://github.com/soutaro/steep/pull/255))

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

@@ -18,7 +18,7 @@ module Steep
           end
 
           def ==(other)
-            other.class ==self.class
+            other.class == self.class
           end
 
           alias eql? ==
@@ -57,6 +57,25 @@ module Steep
             @location = location
           end
         end
+
+        class Env < Base
+          attr_reader :truthy, :falsy
+
+          def initialize(truthy:, falsy:, location: nil)
+            @truthy = truthy
+            @falsy = falsy
+          end
+
+          def ==(other)
+            other.is_a?(Env) && other.truthy == truthy && other.falsy == falsy
+          end
+
+          alias eql? ==
+
+          def hash
+            self.class.hash ^ truthy.hash ^ falsy.hash
+          end
+        end
       end
     end
   end

data/lib/steep/subtyping/check.rb

@@ -127,6 +127,24 @@ module Steep
         Result::Failure.new(error: error, trace: trace)
       end
 
+      def true_type?(type)
+        case type
+        when AST::Types::Literal
+          type.value == true
+        else
+          AST::Builtin::TrueClass.instance_type?(type)
+        end
+      end
+
+      def false_type?(type)
+        case type
+        when AST::Types::Literal
+          type.value == false
+        else
+          AST::Builtin::FalseClass.instance_type?(type)
+        end
+      end
+
       def check0(relation, self_type:, assumption:, trace:, constraints:)
         # puts relation
         trace.type(relation.sub_type, relation.super_type) do
@@ -146,6 +164,9 @@ module Steep
           when relation.sub_type.is_a?(AST::Types::Bot)
             success(constraints: constraints)
 
+          when relation.sub_type.is_a?(AST::Types::Logic::Base) && (true_type?(relation.super_type) || false_type?(relation.super_type))
+            success(constraints: constraints)
+
           when relation.super_type.is_a?(AST::Types::Boolean)
             check(
               Relation.new(sub_type: relation.sub_type, super_type: AST::Types::Union.build(types: [AST::Builtin.true_type, AST::Builtin.false_type])),

data/lib/steep/type_construction.rb

@@ -1476,7 +1476,18 @@ module Steep
                                    .for_branch(right)
                                    .synthesize(right)
 
-            type = if left_type.is_a?(AST::Types::Boolean)
+            truthy_env, _ = interpreter.eval(env: truthy_env, type: right_type, node: right)
+
+            env = if right_type.is_a?(AST::Types::Bot)
+                    falsey_env
+                  else
+                    context.lvar_env.join(falsey_env, constr.context.lvar_env)
+                  end
+
+            type = case
+                   when left_type.is_a?(AST::Types::Logic::Base) && right_type.is_a?(AST::Types::Logic::Base)
+                     AST::Types::Logic::Env.new(truthy: truthy_env, falsy: env)
+                   when check_relation(sub_type: left_type, super_type: AST::Types::Boolean.new).success?
                      union_type(left_type, right_type)
                    else
                      union_type(right_type, AST::Builtin.nil_type)
@@ -1484,13 +1495,7 @@ module Steep
 
             add_typing(node,
                        type: type,
-                       constr: constr.update_lvar_env do
-                         if right_type.is_a?(AST::Types::Bot)
-                           falsey_env
-                         else
-                           context.lvar_env.join(falsey_env, constr.context.lvar_env)
-                         end
-                       end)
+                       constr: constr.update_lvar_env { env })
           end
 
         when :or
@@ -1502,24 +1507,31 @@ module Steep
             interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
             truthy_env, falsey_env = interpreter.eval(env: constr.context.lvar_env, type: left_type, node: left)
 
-            left_type_t, _ = checker.factory.unwrap_optional(left_type)
+            left_type, _ = checker.factory.unwrap_optional(left_type)
             right_type, constr = constr
                                    .update_lvar_env { falsey_env }
                                    .tap {|constr| typing.add_context_for_node(right, context: constr.context) }
                                    .for_branch(right)
-                                   .synthesize(right, hint: left_type_t)
+                                   .synthesize(right, hint: left_type)
 
-            type = union_type(left_type_t, right_type)
+            _, falsey_env = interpreter.eval(env: falsey_env, type: right_type, node: right)
+
+            env = if right_type.is_a?(AST::Types::Bot)
+                    truthy_env
+                  else
+                    context.lvar_env.join(truthy_env, constr.context.lvar_env)
+                  end
+
+            type = case
+                   when left_type.is_a?(AST::Types::Logic::Base) && right_type.is_a?(AST::Types::Logic::Base)
+                     AST::Types::Logic::Env.new(truthy: env, falsy: falsey_env)
+                   else
+                     union_type(left_type, right_type)
+                   end
 
             add_typing(node,
                        type: type,
-                       constr: constr.update_lvar_env do
-                         if right_type.is_a?(AST::Types::Bot)
-                           truthy_env
-                         else
-                           context.lvar_env.join(truthy_env, constr.context.lvar_env)
-                         end
-                       end)
+                       constr: constr.update_lvar_env { env })
           end
 
         when :if
@@ -1584,6 +1596,18 @@ module Steep
 
               cond_type, constr = constr.synthesize(cond)
               _, cond_vars = interpreter.decompose_value(cond)
+              unless cond_vars.empty?
+                first_var = cond_vars.to_a[0]
+                var_node = cond.updated(
+                  :lvar,
+                  [
+                    ASTUtils::Labeling::LabeledName.new(name: first_var, label: 0)
+                  ]
+                )
+              else
+                first_var = nil
+                var_node = cond
+              end
 
               when_constr = constr
               whens.each do |clause|
@@ -1593,9 +1617,15 @@ module Steep
                 test_envs = []
 
                 tests.each do |test|
-                  test_node = test.updated(:send, [test, :===, cond.dup])
+                  test_node = test.updated(:send, [test, :===, var_node])
                   test_type, test_constr = test_constr.synthesize(test_node)
                   truthy_env, falsy_env = interpreter.eval(type: test_type, node: test_node, env: test_constr.context.lvar_env)
+                  truthy_env = cond_vars.inject(truthy_env) do |env, var|
+                    env.assign!(var, node: test_node, type: env[first_var])
+                  end
+                  falsy_env = cond_vars.inject(falsy_env) do |env, var|
+                    env.assign!(var, node: test_node, type: env[first_var])
+                  end
                   test_envs << truthy_env
                   test_constr = test_constr.update_lvar_env { falsy_env }
                 end
@@ -1625,10 +1655,6 @@ module Steep
               types = branch_pairs.map(&:type)
               constrs = branch_pairs.map(&:constr)
 
-              unless els
-                constrs << when_constr
-              end
-
               if when_constr.context.lvar_env[cond_vars.first].is_a?(AST::Types::Bot)
                 # Exhaustive
                 if els
@@ -1636,6 +1662,7 @@ module Steep
                 end
               else
                 unless els
+                  constrs << when_constr
                   types << AST::Builtin.nil_type
                 end
               end

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -46,6 +46,9 @@ module Steep
           end
 
           case type
+          when AST::Types::Logic::Env
+            truthy_env = type.truthy
+            falsy_env = type.falsy
           when AST::Types::Logic::ReceiverIsNil
             case value_node.type
             when :send

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.35.0"
+  VERSION = "0.36.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.35.0
+  version: 0.36.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-11-14 00:00:00.000000000 Z
+date: 2020-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser