steep 1.4.0 → 1.5.0.pre.1

data/lib/steep/type_inference/block_params.rb

@@ -76,6 +76,14 @@ module Steep
             enum_for :each_param
           end
         end
+
+        def type
+          types = params.map do |param|
+            param.type or return
+          end
+
+          AST::Types::Tuple.new(types: types)
+        end
       end
 
       attr_reader :leading_params
@@ -191,15 +199,30 @@ module Steep
             return nil
           end
 
-          if rest_param && hint.rest
-            rest = rest_param.type&.yield_self {|ty| ty.args&.first } || hint.rest
-          else
-            rest = hint.rest
+          if rest_param
+            if hint.rest
+              if rest_type = rest_param.type
+                if AST::Builtin::Array.instance_type?(rest_type)
+                  rest_type.is_a?(AST::Types::Name::Instance) or raise
+                  rest = rest_type.args.first or raise
+                end
+              end
+
+              rest ||= hint.rest
+            end
           end
         else
           leadings = leading_params.map {|param| param.type || AST::Types::Any.new }
           optionals = optional_params.map {|param| param.type || AST::Types::Any.new }
-          rest = rest_param&.yield_self {|param| param.type&.args&.[](0) || AST::Types::Any.new }
+
+          if rest_param
+            if rest_type = rest_param.type
+              if array = AST::Builtin::Array.instance_type?(rest_type)
+                rest = array.args.first or raise
+              end
+            end
+            rest ||= AST::Types::Any.new
+          end
         end
 
         Interface::Function::Params.build(
@@ -217,6 +240,17 @@ module Steep
         # @type var zip: Array[[Param | MultipleParam, AST::Types::t]]
         zip = []
 
+        if untyped_args?(params_type)
+          params.each do |param|
+            if param == rest_param
+              zip << [param, AST::Builtin::Array.instance_type(fill_untyped: true)]
+            else
+              zip << [param, AST::Builtin.any_type]
+            end
+          end
+          return zip
+        end
+
         if expandable? && (type = expandable_params?(params_type, factory))
           case
           when AST::Builtin::Array.instance_type?(type)
@@ -254,10 +288,10 @@ module Steep
           types = params_type.flat_unnamed_params
 
           (leading_params + optional_params).each do |param|
-            type = types.shift&.last || params_type.rest
+            typ = types.shift&.last || params_type.rest
 
-            if type
-              zip << [param, type]
+            if typ
+              zip << [param, typ]
             else
               zip << [param, AST::Builtin.nil_type]
             end
@@ -268,7 +302,9 @@ module Steep
               array = AST::Builtin::Array.instance_type(params_type.rest || AST::Builtin.any_type)
               zip << [rest_param, array]
             else
-              union = AST::Types::Union.build(types: types.map(&:last) + [params_type.rest])
+              union_members = types.map(&:last)
+              union_members << params_type.rest if params_type.rest
+              union = AST::Types::Union.build(types: union_members)
               array = AST::Builtin::Array.instance_type(union)
               zip << [rest_param, array]
             end
@@ -360,6 +396,11 @@ module Steep
 
         MultipleParam.new(node: node, params: params)
       end
+
+      def untyped_args?(params)
+        flat = params.flat_unnamed_params
+        flat.size == 1 && flat[0][1].is_a?(AST::Types::Any)
+      end
     end
   end
 end

data/lib/steep/type_inference/context.rb

@@ -21,6 +21,10 @@ module Steep
         def block_type
           method_type&.block
         end
+
+        def attribute_setter?
+          name.to_s.end_with?('=')
+        end
       end
 
       class BlockContext

data/lib/steep/type_inference/context_array.rb

@@ -23,14 +23,15 @@ module Steep
         root.range
       end
 
-      def self.from_source(source:, range: nil, context: nil)
+      def self.from_source(source:, range: nil, context:)
         content = if source.node
                     source.node.location.expression.source_buffer.source
                   else
                     ""
                   end
         buffer = RBS::Buffer.new(name: source.path, content: content)
-        new(buffer: buffer, context: context, range: range || 0..buffer.content.size)
+        range ||= 0..buffer.content.size
+        new(buffer: buffer, context: context, range: range)
       end
 
       def insert_context(range, context:, entry: self.root)
@@ -62,12 +63,11 @@ module Steep
         end
       end
 
-      def each_entry
-        if block_given?
+      def each_entry(&block)
+        if block
           es = [root]
 
-          until es.empty?
-            e = es.pop
+          while e = es.pop
             es.push(*e.sub_entries.to_a)
 
             yield e

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -1,6 +1,22 @@
 module Steep
   module TypeInference
     class LogicTypeInterpreter
+      class Result < Struct.new(:env, :type, :unreachable, keyword_init: true)
+        def update_env
+          env = yield()
+          Result.new(type: type, env: env, unreachable: unreachable)
+        end
+
+        def update_type
+          Result.new(type: yield, env: env, unreachable: unreachable)
+        end
+
+        def unreachable!
+          self.unreachable = true
+          self
+        end
+      end
+
       attr_reader :subtyping
       attr_reader :typing
       attr_reader :config
@@ -31,55 +47,112 @@ module Steep
         end
       end
 
-      def eval(env:, node:)
-        objects = Set[]
-        truthy_type, falsy_type, truthy_env, falsy_env = evaluate_node(env: env, node: node, refined_objects: objects)
+      TRUE = AST::Types::Literal.new(value: true)
+      FALSE = AST::Types::Literal.new(value: false)
+      BOOL = AST::Types::Boolean.new
+      BOT = AST::Types::Bot.new
+      UNTYPED = AST::Types::Any.new
 
-        [truthy_env, falsy_env, objects, truthy_type, falsy_type]
+      def eval(env:, node:)
+        evaluate_node(env: env, node: node)
       end
 
-      def evaluate_node(env:, node:, refined_objects:)
-        type = typing.type_of(node: node)
-
+      def evaluate_node(env:, node:, type: typing.type_of(node: node))
         if type.is_a?(AST::Types::Logic::Env)
           truthy_env = type.truthy
           falsy_env = type.falsy
 
-          return [AST::Types::Boolean.new, AST::Types::Boolean.new, truthy_env, falsy_env]
+          truthy_type, falsy_type = factory.partition_union(type.type)
+
+          return [
+            Result.new(env: truthy_env, type: truthy_type || TRUE, unreachable: !truthy_type),
+            Result.new(env: falsy_env, type: falsy_type || FALSE, unreachable: !falsy_type)
+          ]
+        end
+
+        if type.is_a?(AST::Types::Bot)
+          return [
+            Result.new(env: env, type: type, unreachable: true),
+            Result.new(env: env, type: type, unreachable: true),
+          ]
         end
 
         case node.type
         when :lvar
           name = node.children[0]
-          refined_objects << name
-          truthy_type, falsy_type = factory.unwrap_optional(type)
-          return [
-            truthy_type,
-            falsy_type,
-            env.refine_types(local_variable_types: { name => truthy_type }),
-            env.refine_types(local_variable_types: { name => falsy_type })
-          ]
+          truthy_type, falsy_type = factory.partition_union(type)
+
+          truthy_result =
+            if truthy_type
+              Result.new(type: truthy_type, env: env.refine_types(local_variable_types: { name => truthy_type }), unreachable: false)
+            else
+              Result.new(type: type, env: env, unreachable: true)
+            end
+
+          falsy_result =
+            if falsy_type
+              Result.new(type: falsy_type, env: env.refine_types(local_variable_types: { name => falsy_type }), unreachable: false)
+            else
+              Result.new(type: type, env: env, unreachable: true)
+            end
+
+          return [truthy_result, falsy_result]
+
         when :lvasgn
           name, rhs = node.children
-          truthy_type, falsy_type, truthy_env, falsy_env = evaluate_node(env: env, node: rhs, refined_objects: refined_objects)
+          if TypeConstruction::SPECIAL_LVAR_NAMES.include?(name)
+            return [
+              Result.new(type: type, env: env, unreachable: false),
+              Result.new(type: type, env: env, unreachable: false)
+            ]
+          end
+
+          truthy_result, falsy_result = evaluate_node(env: env, node: rhs)
+
           return [
-            truthy_type,
-            falsy_type,
-            evaluate_assignment(node, truthy_env, truthy_type, refined_objects: refined_objects),
-            evaluate_assignment(node, falsy_env, falsy_type, refined_objects: refined_objects)
+            truthy_result.update_env { evaluate_assignment(node, truthy_result.env, truthy_result.type) },
+            falsy_result.update_env { evaluate_assignment(node, falsy_result.env, falsy_result.type) }
           ]
+
         when :masgn
-          lhs, rhs = node.children
-          truthy_type, falsy_type, truthy_env, falsy_env = evaluate_node(env: env, node: rhs, refined_objects: refined_objects)
+          _, rhs = node.children
+          truthy_result, falsy_result = evaluate_node(env: env, node: rhs)
+
           return [
-            truthy_type,
-            falsy_type,
-            evaluate_assignment(node, truthy_env, truthy_type, refined_objects: refined_objects),
-            evaluate_assignment(node, falsy_env, falsy_type, refined_objects: refined_objects)
+            truthy_result.update_env { evaluate_assignment(node, truthy_result.env, truthy_result.type) },
+            falsy_result.update_env { evaluate_assignment(node, falsy_result.env, falsy_result.type) }
           ]
+
         when :begin
           last_node = node.children.last or raise
-          return evaluate_node(env: env, node: last_node, refined_objects: refined_objects)
+          return evaluate_node(env: env, node: last_node)
+
+        when :csend
+          if type.is_a?(AST::Types::Any)
+            type = guess_type_from_method(node) || type
+          end
+
+          receiver, _, *arguments = node.children
+          receiver_type = typing.type_of(node: receiver)
+
+          truthy_receiver, falsy_receiver = evaluate_node(env: env, node: receiver)
+          truthy_type, _ = factory.partition_union(type)
+
+          truthy_result, falsy_result = evaluate_node(
+            env: truthy_receiver.env,
+            node: node.updated(:send),
+            type: truthy_type || type
+          )
+          truthy_result.unreachable! if truthy_receiver.unreachable
+
+          falsy_result = Result.new(
+            env: env.join(falsy_receiver.env, falsy_result.env),
+            unreachable: falsy_result.unreachable && falsy_receiver.unreachable,
+            type: falsy_result.type
+          )
+
+          return [truthy_result, falsy_result]
+
         when :send
           if type.is_a?(AST::Types::Any)
             type = guess_type_from_method(node) || type
@@ -88,38 +161,46 @@ module Steep
           case type
           when AST::Types::Logic::Base
             receiver, _, *arguments = node.children
-            truthy_env, falsy_env = evaluate_method_call(env: env, type: type, receiver: receiver, arguments: arguments, refined_objects: refined_objects)
-
-            if truthy_env && falsy_env
-              return [AST::Builtin.true_type, AST::Builtin.false_type, truthy_env, falsy_env]
+            if (truthy_result, falsy_result = evaluate_method_call(env: env, type: type, receiver: receiver, arguments: arguments))
+              return [truthy_result, falsy_result]
             end
           else
             if env[node]
-              truthy_type, falsy_type = factory.unwrap_optional(type)
-
-              refined_objects << node
-              return [
-                truthy_type,
-                falsy_type,
-                env.refine_types(pure_call_types: { node => truthy_type }),
-                env.refine_types(pure_call_types: { node => falsy_type })
-              ]
+              truthy_type, falsy_type = factory.partition_union(type)
+
+              truthy_result =
+                if truthy_type
+                  Result.new(type: truthy_type, env: env.refine_types(pure_call_types: { node => truthy_type }), unreachable: false)
+                else
+                  Result.new(type: type, env: env, unreachable: true)
+                end
+
+              falsy_result =
+                if falsy_type
+                  Result.new(type: falsy_type, env: env.refine_types(pure_call_types: { node => falsy_type }), unreachable: false)
+                else
+                  Result.new(type: type, env: env, unreachable: true)
+                end
+
+              return [truthy_result, falsy_result]
             end
           end
         end
 
-        truthy_type, falsy_type = factory.unwrap_optional(type)
-        return [truthy_type, falsy_type, env, env]
+        truthy_type, falsy_type = factory.partition_union(type)
+        return [
+          Result.new(type: truthy_type || BOT, env: env, unreachable: truthy_type.nil?),
+          Result.new(type: falsy_type || BOT, env: env, unreachable: falsy_type.nil?)
+        ]
       end
 
-      def evaluate_assignment(assignment_node, env, rhs_type, refined_objects:)
+      def evaluate_assignment(assignment_node, env, rhs_type)
         case assignment_node.type
         when :lvasgn
           name, _ = assignment_node.children
           if TypeConstruction::SPECIAL_LVAR_NAMES.include?(name)
             env
           else
-            refined_objects << name
             env.refine_types(local_variable_types: { name => rhs_type })
           end
         when :masgn
@@ -140,7 +221,7 @@ module Steep
 
           assignments.each do |pair|
             node, type = pair
-            env = evaluate_assignment(node, env, type, refined_objects: refined_objects)
+            env = evaluate_assignment(node, env, type)
           end
 
           env
@@ -149,7 +230,7 @@ module Steep
         end
       end
 
-      def refine_node_type(env:, node:, truthy_type:, falsy_type:, refined_objects:)
+      def refine_node_type(env:, node:, truthy_type:, falsy_type:)
         case node.type
         when :lvar
           name = node.children[0]
@@ -157,7 +238,6 @@ module Steep
           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 })
@@ -167,12 +247,11 @@ module Steep
         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)
+          truthy_env, falsy_env = refine_node_type(env: env, node: rhs, truthy_type: truthy_type, falsy_type: 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 })
@@ -181,7 +260,6 @@ module Steep
 
         when :send
           if env[node]
-            refined_objects << node
             [
               env.refine_types(pure_call_types: { node => truthy_type }),
               env.refine_types(pure_call_types: { node => falsy_type })
@@ -191,20 +269,35 @@ module Steep
           end
         when :begin
           last_node = node.children.last or raise
-          refine_node_type(env: env, node: last_node, truthy_type: truthy_type, falsy_type: falsy_type, refined_objects: refined_objects)
+          refine_node_type(env: env, node: last_node, truthy_type: truthy_type, falsy_type: falsy_type)
         else
           [env, env]
         end
       end
 
-      def evaluate_method_call(env:, type:, receiver:, arguments:, refined_objects:)
+      def evaluate_method_call(env:, type:, receiver:, arguments:)
         case type
         when AST::Types::Logic::ReceiverIsNil
           if receiver && arguments.size.zero?
             receiver_type = typing.type_of(node: receiver)
-            truthy_receiver, falsy_receiver = factory.unwrap_optional(receiver_type)
-            refine_node_type(env: env, node: receiver, truthy_type: falsy_receiver, falsy_type: truthy_receiver, refined_objects: refined_objects)
+            truthy_receiver, falsy_receiver = factory.partition_union(receiver_type)
+
+            truthy_env, falsy_env = refine_node_type(
+              env: env,
+              node: receiver,
+              truthy_type: falsy_receiver || BOT,
+              falsy_type: truthy_receiver || BOT
+            )
+
+            truthy_result = Result.new(type: TRUE, env: truthy_env, unreachable: false)
+            truthy_result.unreachable! unless truthy_receiver
+
+            falsy_result = Result.new(type: FALSE, env: falsy_env, unreachable: false)
+            falsy_result.unreachable! unless falsy_receiver
+
+            [truthy_result, falsy_result]
           end
+
         when AST::Types::Logic::ReceiverIsArg
           if receiver && (arg = arguments[0])
             receiver_type = typing.type_of(node: receiver)
@@ -212,9 +305,23 @@ module Steep
 
             if arg_type.is_a?(AST::Types::Name::Singleton)
               truthy_type, falsy_type = type_case_select(receiver_type, arg_type.name)
-              refine_node_type(env: env, node: receiver, truthy_type: truthy_type, falsy_type: falsy_type, refined_objects: refined_objects)
+              truthy_env, falsy_env = refine_node_type(
+                env: env,
+                node: receiver,
+                truthy_type: truthy_type || factory.instance_type(arg_type.name),
+                falsy_type: falsy_type || UNTYPED
+              )
+
+              truthy_result = Result.new(type: TRUE, env: truthy_env, unreachable: false)
+              truthy_result.unreachable! unless truthy_type
+
+              falsy_result = Result.new(type: FALSE, env: falsy_env, unreachable: false)
+              falsy_result.unreachable! unless falsy_type
+
+              [truthy_result, falsy_result]
             end
           end
+
         when AST::Types::Logic::ArgIsReceiver
           if receiver && (arg = arguments[0])
             receiver_type = factory.deep_expand_alias(typing.type_of(node: receiver))
@@ -222,26 +329,49 @@ module Steep
 
             if receiver_type.is_a?(AST::Types::Name::Singleton)
               truthy_type, falsy_type = type_case_select(arg_type, receiver_type.name)
-              refine_node_type(env: env, node: arg, truthy_type: truthy_type, falsy_type: falsy_type, refined_objects: refined_objects)
+              truthy_env, falsy_env = refine_node_type(
+                env: env,
+                node: arg,
+                truthy_type: truthy_type || factory.instance_type(receiver_type.name),
+                falsy_type: falsy_type || UNTYPED
+              )
+
+              truthy_result = Result.new(type: TRUE, env: truthy_env, unreachable: false)
+              truthy_result.unreachable! unless truthy_type
+
+              falsy_result = Result.new(type: FALSE, env: falsy_env, unreachable: false)
+              falsy_result.unreachable! unless falsy_type
+
+              [truthy_result, falsy_result]
             end
           end
         when AST::Types::Logic::ArgEqualsReceiver
           if receiver && (arg = arguments[0])
             arg_type = factory.expand_alias(typing.type_of(node: arg))
             if (truthy_types, falsy_types = literal_var_type_case_select(receiver, arg_type))
-              refine_node_type(
+              truthy_env, falsy_env = refine_node_type(
                 env: env,
                 node: arg,
-                truthy_type: AST::Types::Union.build(types: truthy_types),
-                falsy_type: AST::Types::Union.build(types: falsy_types),
-                refined_objects: refined_objects
+                truthy_type: truthy_types.empty? ? BOT : AST::Types::Union.build(types: truthy_types),
+                falsy_type: falsy_types.empty? ? BOT : AST::Types::Union.build(types: falsy_types)
               )
+
+              truthy_result = Result.new(type: TRUE, env: truthy_env, unreachable: false)
+              truthy_result.unreachable! if truthy_types.empty?
+
+              falsy_result = Result.new(type: FALSE, env: falsy_env, unreachable: false)
+              falsy_result.unreachable! if falsy_types.empty?
+
+              [truthy_result, falsy_result]
             end
           end
         when AST::Types::Logic::Not
           if receiver
-            truthy_type, falsy_type, truthy_env, falsy_env = evaluate_node(env: env, node: receiver, refined_objects: refined_objects)
-            [falsy_env, truthy_env]
+            truthy_result, falsy_result = evaluate_node(env: env, node: receiver)
+            [
+              falsy_result.update_type { TRUE },
+              truthy_result.update_type { FALSE }
+            ]
           end
         end
       end
@@ -332,8 +462,8 @@ module Steep
         truth_types, false_types = type_case_select0(type, klass)
 
         [
-          AST::Types::Union.build(types: truth_types),
-          AST::Types::Union.build(types: false_types)
+          truth_types.empty? ? nil : AST::Types::Union.build(types: truth_types),
+          false_types.empty? ? nil : AST::Types::Union.build(types: false_types)
         ]
       end
 
@@ -342,8 +472,8 @@ module Steep
 
         case type
         when AST::Types::Union
-          truthy_types = []
-          falsy_types = []
+          truthy_types = [] # :Array[AST::Types::t]
+          falsy_types = [] #: Array[AST::Types::t]
 
           type.types.each do |ty|
             truths, falses = type_case_select0(ty, klass)
@@ -360,7 +490,11 @@ module Steep
 
         when AST::Types::Name::Alias
           ty = factory.expand_alias(type)
-          type_case_select0(ty, klass)
+          if ty == type
+            [[type], [type]]
+          else
+            type_case_select0(ty, klass)
+          end
 
         when AST::Types::Any, AST::Types::Top
           [

data/lib/steep/typing.rb

@@ -32,10 +32,10 @@ module Steep
       @should_update = false
 
       @errors = []
-      @typing = {}.compare_by_identity
+      (@typing = {}).compare_by_identity
       @root_context = root_context
-      @contexts = contexts || TypeInference::ContextArray.from_source(source: source)
-      @method_calls = {}.compare_by_identity
+      @contexts = contexts || TypeInference::ContextArray.from_source(source: source, context: root_context)
+      (@method_calls = {}).compare_by_identity
 
       @source_index = source_index || Index::SourceIndex.new(source: source)
     end
@@ -222,10 +222,11 @@ module Steep
     end
 
     def new_child(range)
+      context = contexts[range.begin] || contexts.root.context
       child = self.class.new(source: source,
                              parent: self,
                              root_context: root_context,
-                             contexts: TypeInference::ContextArray.new(buffer: contexts.buffer, range: range, context: nil),
+                             contexts: TypeInference::ContextArray.new(buffer: contexts.buffer, range: range, context: context),
                              source_index: source_index.new_child)
       @should_update = true
 

data/lib/steep/version.rb

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