steep 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c8da530ec2506030583be78aaaecc04f977ce86bef6c69a5025806c29f32a73
-  data.tar.gz: 507b2fc612005b9893ae02ec840114b428654d039dd6e0c3cf3c719fc03916ab
+  metadata.gz: a82e5deea68aec9ddc24d1ff5c4872ea0c2fd1d00a6098056e144bc932fba5bf
+  data.tar.gz: 2e55a0e505ab5ff267c911b53828f7de2159ae1ac443401a962c1d77c8cda294
 SHA512:
-  metadata.gz: 03444250fd89df0edcb58884081dee7c21f5a2b26d1c2b012371ee5b7046355b426dec781b7a9551d336190f306850721ac66d525128518a7c2324fb8b63f4f1
-  data.tar.gz: c4f35528752c20c8d2b494e8bb60546ca65cf0317134343202679b865e7afd92d58bcfe49dc315f58ea2f29c93906ba65ebacb1a53741f94f2f47870961e23ff
+  metadata.gz: 3d572d7d6f4908286a5714cfe029930a749a0437d5f88663b3c85f86bf14a60f2de0f53320177b6749d235ed384576cfbfc21f6954873fa4fcc29d4132a24880
+  data.tar.gz: 7319b4110d5f5ad465f0a84a4052c7c542ed5c0f2da5bd8e378247a75883ecc62fecfb16d3da215f9e017ade5045cffa56cff3d5eaaaeeb59c602035113af370

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## master
 
+## 1.1.1 (2022-07-31)
+
+### Type checker core
+
+* Ignore special local variables -- `_`, `__any__` and `__skip__` ([#617](https://github.com/soutaro/steep/pull/617), [#627](https://github.com/soutaro/steep/pull/627))
+* Fix type narrowing on assignments ([#622](https://github.com/soutaro/steep/pull/622))
+
 ## 1.1.0 (2022-07-27)
 
 ### Type checker core

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    steep (1.1.0)
+    steep (1.1.1)
       activesupport (>= 5.1)
       language_server-protocol (>= 3.15, < 4.0)
       listen (~> 3.0)

data/Gemfile.steep

@@ -1,4 +1,4 @@
 source "https://rubygems.org"
 
-gem 'steep', '~> 1.1.pre'
+gem 'steep', '~> 1.1.0'
 gem "rbs", "~> 2.5.0"

data/Gemfile.steep.lock

@@ -24,7 +24,7 @@ GEM
     rb-inotify (0.10.1)
       ffi (~> 1.0)
     rbs (2.5.1)
-    steep (1.1.0.pre.1)
+    steep (1.1.0)
       activesupport (>= 5.1)
       language_server-protocol (>= 3.15, < 4.0)
       listen (~> 3.0)
@@ -44,7 +44,7 @@ PLATFORMS
 
 DEPENDENCIES
   rbs (~> 2.5.0)
-  steep (~> 1.1.pre)
+  steep (~> 1.1.0)
 
 BUNDLED WITH
    2.3.15

data/lib/steep/type_construction.rb

@@ -37,6 +37,8 @@ module Steep
       s + ">"
     end
 
+    SPECIAL_LVAR_NAMES = Set[:_, :__any__, :__skip__]
+
     include ModuleHelper
 
     attr_reader :checker
@@ -202,7 +204,9 @@ module Steep
 
       local_variable_types = method_params.each_param.with_object({}) do |param, hash|
         if param.name
-          hash[param.name] = param.var_type
+          unless SPECIAL_LVAR_NAMES.include?(param.name)
+            hash[param.name] = param.var_type
+          end
         end
       end
       type_env = context.type_env.assign_local_variables(local_variable_types)
@@ -752,10 +756,15 @@ module Steep
         when :lvar
           yield_self do
             var = node.children[0]
-            if (type = context.type_env[var])
-              add_typing node, type: type
+
+            if SPECIAL_LVAR_NAMES.include?(var)
+              add_typing node, type: AST::Builtin.any_type
             else
-              fallback_to_any(node)
+              if (type = context.type_env[var])
+                add_typing node, type: type
+              else
+                fallback_to_any(node)
+              end
             end
           end
 
@@ -1240,13 +1249,17 @@ module Steep
 
             node.children.each do |arg|
               if arg.is_a?(Symbol)
-                type = context.type_env[arg]
-
-                if type
-                  _, constr = add_typing(node, type: type)
+                if SPECIAL_LVAR_NAMES === arg
+                  _, constr = add_typing(node, type: AST::Builtin.any_type)
                 else
-                  type = AST::Builtin.any_type
-                  _, constr = lvasgn(node, type)
+                  type = context.type_env[arg]
+
+                  if type
+                    _, constr = add_typing(node, type: type)
+                  else
+                    type = AST::Builtin.any_type
+                    _, constr = lvasgn(node, type)
+                  end
                 end
               else
                 _, constr = constr.synthesize(arg)
@@ -1270,13 +1283,18 @@ module Steep
         when :arg, :kwarg
           yield_self do
             var = node.children[0]
-            type = context.type_env[var]
 
-            if type
-              add_typing(node, type: type)
+            if SPECIAL_LVAR_NAMES.include?(var)
+              add_typing(node, type: AST::Builtin.any_type)
             else
-              type = AST::Builtin.any_type
-              lvasgn(node, type)
+              type = context.type_env[var]
+
+              if type
+                add_typing(node, type: type)
+              else
+                type = AST::Builtin.any_type
+                lvasgn(node, type)
+              end
             end
           end
 
@@ -1826,8 +1844,21 @@ module Steep
             if cond
               branch_results = []
 
-              cond_type, constr = constr.synthesize(cond).to_ary
-              cond_value_node, cond_vars = interpreter.decompose_value(cond)
+              cond_type, constr = constr.synthesize(cond)
+              _, cond_vars = interpreter.decompose_value(cond)
+
+              var_name = :"_a#{SecureRandom.base64(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
 
               when_constr = constr
               whens.each do |clause|
@@ -1875,7 +1906,11 @@ module Steep
               types = branch_results.map(&:type)
               constrs = branch_results.map(&:constr)
 
-              cond_type = when_constr.context.type_env[cond_value_node]
+              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 cond_type.is_a?(AST::Types::Bot)
                 # Exhaustive
                 if els
@@ -2440,23 +2475,27 @@ module Steep
     def lvasgn(node, type)
       name = node.children[0]
 
-      if enforced_type = context.type_env.enforced_type(name)
-        if result = no_subtyping?(sub_type: type, super_type: enforced_type)
-          typing.add_error(
-            Diagnostic::Ruby::IncompatibleAssignment.new(
-              node: node,
-              lhs_type: enforced_type,
-              rhs_type: type,
-              result: result
+      if SPECIAL_LVAR_NAMES.include?(name)
+        add_typing(node, type: AST::Builtin.any_type)
+      else
+        if enforced_type = context.type_env.enforced_type(name)
+          if result = no_subtyping?(sub_type: type, super_type: enforced_type)
+            typing.add_error(
+              Diagnostic::Ruby::IncompatibleAssignment.new(
+                node: node,
+                lhs_type: enforced_type,
+                rhs_type: type,
+                result: result
+              )
             )
-          )
 
-          type = enforced_type
+            type = enforced_type
+          end
         end
-      end
 
-      update_type_env {|env| env.assign_local_variable(name, type, enforced_type) }
-        .add_typing(node, type: type)
+        update_type_env {|env| env.assign_local_variable(name, type, enforced_type) }
+          .add_typing(node, type: type)
+      end
     end
 
     def ivasgn(node, rhs_type)
@@ -3689,6 +3728,8 @@ module Steep
         end
       end
 
+      param_types_hash.delete_if {|name, _| SPECIAL_LVAR_NAMES.include?(name) }
+
       param_types = param_types_hash.each.with_object({}) do |pair, hash|
         # @type var hash: Hash[Symbol, [AST::Types::t, AST::Types::t?]]
         name, type = pair
@@ -4213,5 +4254,35 @@ module Steep
       typing.save!
       with_new_typing(typing.parent)
     end
+
+    def extract_outermost_call(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
+      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]
+      else
+        if value_node?(node)
+          [node, nil]
+        else
+          var_node = node.updated(:lvar, [var_name])
+          [var_node, node]
+        end
+      end
+    end
   end
 end

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -114,8 +114,12 @@ module Steep
         case assignment_node.type
         when :lvasgn
           name, _ = assignment_node.children
-          refined_objects << name
-          env.refine_types(local_variable_types: { name => rhs_type })
+          if TypeConstruction::SPECIAL_LVAR_NAMES.include?(name)
+            env
+          else
+            refined_objects << name
+            env.refine_types(local_variable_types: { name => rhs_type })
+          end
         when :masgn
           lhs, _ = assignment_node.children
 
@@ -146,20 +150,31 @@ module Steep
         when :lvar
           name = node.children[0]
 
-          refined_objects << name
-          [
-            env.refine_types(local_variable_types: { name => truthy_type }),
-            env.refine_types(local_variable_types: { name => falsy_type })
-          ]
+          if TypeConstruction::SPECIAL_LVAR_NAMES.include?(name)
+            [env, env]
+          else
+            refined_objects << name
+            [
+              env.refine_types(local_variable_types: { name => truthy_type }),
+              env.refine_types(local_variable_types: { name => falsy_type })
+            ]
+          end
+
         when :lvasgn
           name, rhs = node.children
 
           truthy_env, falsy_env = refine_node_type(env: env, node: rhs, truthy_type: truthy_type, falsy_type: falsy_type, refined_objects: refined_objects)
-          refined_objects << name
-          [
-            truthy_env.refine_types(local_variable_types: { name => truthy_type }),
-            falsy_env.refine_types(local_variable_types: { name => falsy_type })
-          ]
+
+          if TypeConstruction::SPECIAL_LVAR_NAMES.include?(name)
+            [truthy_env, falsy_env]
+          else
+            refined_objects << name
+            [
+              truthy_env.refine_types(local_variable_types: { name => truthy_type }),
+              falsy_env.refine_types(local_variable_types: { name => falsy_type })
+            ]
+          end
+
         when :send
           if env[node]
             refined_objects << node

data/lib/steep/type_inference/multiple_assignment.rb

@@ -177,7 +177,12 @@ module Steep
           AST::Types::Tuple.new(types: types)
         when :lvasgn, :ivasgn, :gvasgn
           name = mlhs.children[0]
-          env[name] || AST::Builtin.any_type
+          
+          unless TypeConstruction::SPECIAL_LVAR_NAMES.include?(name)
+            env[name] || AST::Builtin.any_type
+          else
+            AST::Builtin.any_type
+          end
         when :splat
           return
         else

data/lib/steep/type_inference/type_env.rb

@@ -112,6 +112,8 @@ module Steep
         invalidated_nodes = Set[]
 
         assignments.each do |name, new_type|
+          local_variable_name!(name)
+
           local_variable_types[name] = [new_type, enforced_type(name)]
           invalidated_nodes.merge(invalidated_pure_nodes(::Parser::AST::Node.new(:lvar, [name])))
         end
@@ -125,6 +127,7 @@ module Steep
       end
 
       def assign_local_variable(name, var_type, enforced_type)
+        local_variable_name!(name)
         merge(
           local_variable_types: { name => [enforced_type || var_type, enforced_type] },
           pure_method_calls: pure_node_invalidation(invalidated_pure_nodes(::Parser::AST::Node.new(:lvar, [name])))
@@ -135,6 +138,7 @@ module Steep
         local_variable_updates = {}
 
         local_variable_types.each do |name, type|
+          local_variable_name!(name)
           local_variable_updates[name] = [type, enforced_type(name)]
         end
 
@@ -175,6 +179,8 @@ module Steep
         local_variable_types.each.with_object({}) do |pair, hash|
           name, entry = pair
 
+          local_variable_name!(name)
+
           if names.nil? || names.include?(name)
             type, enforced_type = entry
             unless enforced_type
@@ -190,6 +196,8 @@ module Steep
         local_var_types = local_variable_types.each.with_object({}) do |pair, hash|
           name, entry = pair
 
+          local_variable_name!(name)
+
           if names.nil? || names.include?(name)
             type, _ = entry
             hash[name] = [type, nil]
@@ -300,7 +308,11 @@ module Steep
       end
 
       def local_variable_name?(name)
-        name.start_with?(/[a-z_]/)
+        name.start_with?(/[a-z_]/) && name != :_ && name != :__skip__ && name != :__any__
+      end
+
+      def local_variable_name!(name)
+        local_variable_name?(name) || raise("#{name} is not a local variable")
       end
 
       def instance_variable_name?(name)

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.1.0"
+  VERSION = "1.1.1"
 end

data/sig/steep/node_helper.rbs

@@ -6,6 +6,8 @@ module Steep
     def each_descendant_node: (Parser::AST::Node) -> Enumerator[Parser::AST::Node, void]
                             | (Parser::AST::Node) { (Parser::AST::Node) -> void } -> void
 
+    # Returns true if given node is a syntactic-value node
+    #
     def value_node?: (Parser::AST::Node) -> bool
   end
 end

data/sig/steep/type_construction.rbs

@@ -16,6 +16,8 @@ module Steep
       def to_ary: () -> [AST::Types::t, TypeConstruction, TypeInference::Context]
     end
 
+    SPECIAL_LVAR_NAMES: Set[Symbol]
+
     include NodeHelper
 
     attr_reader checker: Subtyping::Check
@@ -281,5 +283,18 @@ module Steep
     # * All of the arguments are _pure_
     #
     def pure_send?: (TypeInference::MethodCall::Typed call, Parser::AST::Node receiver, Array[Parser::AST::Node] arguments) -> bool
+
+    # Transform given `node` to a node that has a local variable instead of the outer most call/non-value node
+    #
+    # 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__`
+    #                 # => Returns [x = y = __foo__, foo()]
+    # ```
+    #
+    # 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?]
   end
 end

data/sig/steep/type_inference/type_env.rbs

@@ -150,6 +150,8 @@ module Steep
 
       def local_variable_name?: (Symbol) -> bool
 
+      def local_variable_name!: (Symbol) -> void
+
       def instance_variable_name?: (Symbol) -> bool
 
       def global_name?: (Symbol) -> bool

data/sig/version.rbs

@@ -0,0 +1,3 @@
+module Steep
+  VERSION: String
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-27 00:00:00.000000000 Z
+date: 2022-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -363,6 +363,7 @@ files:
 - sig/steep/type_inference/type_env.rbs
 - sig/steep/type_inference/type_env_builder.rbs
 - sig/steep/typing.rbs
+- sig/version.rbs
 - smoke/alias/Steepfile
 - smoke/alias/a.rb
 - smoke/alias/a.rbs
@@ -633,7 +634,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Gradual Typing for Ruby