steep 1.0.0 → 1.1.0.pre.1

data/lib/steep/type_inference/constant_env.rb

@@ -5,8 +5,6 @@ module Steep
       attr_reader :factory
       attr_reader :resolver
 
-      # ConstantEnv receives an TypeName as a context, not a Namespace, because this is a simulation of Ruby.
-      # Any namespace is a module or class.
       def initialize(factory:, context:, resolver:)
         @cache = {}
         @factory = factory

data/lib/steep/type_inference/context.rb

@@ -29,6 +29,10 @@ module Steep
         def initialize(body_type:)
           @body_type = body_type
         end
+
+        def subst(s)
+          BlockContext.new(body_type: body_type&.subst(s))
+        end
       end
 
       class BreakContext
@@ -39,6 +43,10 @@ module Steep
           @break_type = break_type
           @next_type = next_type
         end
+
+        def subst(s)
+          BreakContext.new(break_type: break_type.subst(s), next_type: next_type&.subst(s))
+        end
       end
 
       class ModuleContext
@@ -46,28 +54,24 @@ module Steep
         attr_reader :module_type
         attr_reader :defined_instance_methods
         attr_reader :defined_module_methods
-        attr_reader :const_env
+        attr_reader :nesting
         attr_reader :implement_name
         attr_reader :class_name
         attr_reader :instance_definition
         attr_reader :module_definition
 
-        def initialize(instance_type:, module_type:, implement_name:, const_env:, class_name:, instance_definition: nil, module_definition: nil)
+        def initialize(instance_type:, module_type:, implement_name:, class_name:, instance_definition: nil, module_definition: nil, nesting:)
           @instance_type = instance_type
           @module_type = module_type
           @defined_instance_methods = Set.new
           @defined_module_methods = Set.new
           @implement_name = implement_name
-          @const_env = const_env
+          @nesting = nesting
           @class_name = class_name
           @instance_definition = instance_definition
           @module_definition = module_definition
         end
 
-        def nesting
-          const_env.context
-        end
-
         def class_variables
           if module_definition
             @class_variables ||= module_definition.class_variables.transform_values do |var_def|
@@ -80,16 +84,16 @@ module Steep
           instance_type: self.instance_type,
           module_type: self.module_type,
           implement_name: self.implement_name,
-          const_env: self.const_env,
           class_name: self.class_name,
           instance_definition: self.instance_definition,
-          module_definition: self.module_definition
+          module_definition: self.module_definition,
+          nesting: self.nesting
         )
           ModuleContext.new(
             instance_type: instance_type,
             module_type: module_type,
             implement_name: implement_name,
-            const_env: const_env,
+            nesting: nesting,
             class_name: class_name,
             instance_definition: instance_definition,
             module_definition: module_definition
@@ -134,17 +138,15 @@ module Steep
       attr_reader :module_context
       attr_reader :self_type
       attr_reader :type_env
-      attr_reader :lvar_env
       attr_reader :variable_context
 
-      def initialize(method_context:, block_context:, break_context:, module_context:, self_type:, type_env:, lvar_env:, call_context:, variable_context:)
+      def initialize(method_context:, block_context:, break_context:, module_context:, self_type:, type_env:, call_context:, variable_context:)
         @method_context = method_context
         @block_context = block_context
         @break_context = break_context
         @module_context = module_context
         @self_type = self_type
         @type_env = type_env
-        @lvar_env = lvar_env
         @call_context = call_context
         @variable_context = variable_context
       end
@@ -155,7 +157,6 @@ module Steep
                module_context: self.module_context,
                self_type: self.self_type,
                type_env: self.type_env,
-               lvar_env: self.lvar_env,
                call_context: self.call_context,
                variable_context: self.variable_context)
         self.class.new(
@@ -165,18 +166,23 @@ module Steep
           module_context: module_context,
           self_type: self_type,
           type_env: type_env,
-          lvar_env: lvar_env,
           call_context: call_context,
           variable_context: variable_context
         )
       end
 
+      def inspect
+        s = "#<%s:%#018x " % [self.class, object_id]
+        s << instance_variables.map(&:to_s).sort.map {|name| "#{name}=..." }.join(", ")
+        s + ">"
+      end
+
       def factory
-        type_env.subtyping.factory
+        type_env.constant_env.factory
       end
 
       def env
-        type_env.subtyping.factory.env
+        factory.env
       end
     end
   end

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -29,131 +29,202 @@ module Steep
         end
       end
 
-      def eval(env:, type:, node:)
-        value_node, vars = decompose_value(node)
+      def eval(env:, node:)
+        objects = Set[]
+        truthy_type, falsy_type, truthy_env, falsy_env = evaluate_node(env: env, node: node, refined_objects: objects)
 
-        truthy_env = env
-        falsy_env = env
+        [truthy_env, falsy_env, objects, truthy_type, falsy_type]
+      end
+
+      def evaluate_node(env:, node:, refined_objects:)
+        type = typing.type_of(node: node)
+
+        if type.is_a?(AST::Types::Logic::Env)
+          truthy_env = type.truthy
+          falsy_env = type.falsy
 
-        if type.is_a?(AST::Types::Any)
-          type = guess_type_from_method(node) || type
+          return [AST::Types::Boolean.new, AST::Types::Boolean.new, truthy_env, falsy_env]
         end
 
-        if type.is_a?(AST::Types::Logic::Base)
-          vars.each do |var_name|
-            var_type = truthy_env[var_name]
-            truthy_type, falsy_type = factory.unwrap_optional(var_type)
-            falsy_type ||= AST::Builtin.nil_type
-            truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type) {|_, type, _| type }
-            falsy_env = truthy_env.assign!(var_name, node: node, type: falsy_type) {|_, type, _| type }
+        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 })
+          ]
+        when :lvasgn
+          name, rhs = node.children
+          truthy_type, falsy_type, truthy_env, falsy_env = evaluate_node(env: env, node: rhs, refined_objects: refined_objects)
+          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)
+          ]
+        when :masgn
+          lhs, rhs = node.children
+          truthy_type, falsy_type, truthy_env, falsy_env = evaluate_node(env: env, node: rhs, refined_objects: refined_objects)
+          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)
+          ]
+        when :begin
+          last_node = node.children.last or raise
+          return evaluate_node(env: env, node: last_node, refined_objects: refined_objects)
+        when :send
+          if type.is_a?(AST::Types::Any)
+            type = guess_type_from_method(node) || type
           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
-              receiver = value_node.children[0]
-
-              if receiver
-                _, receiver_vars = decompose_value(receiver)
-
-                receiver_vars.each do |receiver_var|
-                  var_type = env[receiver_var]
-                  truthy_type, falsy_type = factory.unwrap_optional(var_type)
-
-                  truthy_env = truthy_env.assign!(receiver_var, node: node, type: falsy_type || AST::Builtin.nil_type)
-                  falsy_env = falsy_env.assign!(receiver_var, node: node, type: truthy_type)
-                end
-              end
-            end
-          when AST::Types::Logic::ReceiverIsArg
-            case value_node.type
-            when :send
-              receiver, _, arg = value_node.children
-
-              if receiver
-                _, receiver_vars = decompose_value(receiver)
-                arg_type = typing.type_of(node: arg)
-
-                if arg_type.is_a?(AST::Types::Name::Singleton)
-                  receiver_vars.each do |var_name|
-                    case var_name
-                    when :_, :__any__, :__skip__
-                      # skip
-                    else
-                      var_type = env[var_name]
-                      truthy_type, falsy_type = type_case_select(var_type, arg_type.name)
-
-                      truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type)
-                      falsy_env = falsy_env.assign!(var_name, node: node, type: falsy_type)
-                    end
-                  end
-                end
-              end
+          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]
             end
-          when AST::Types::Logic::ArgIsReceiver
-            case value_node.type
-            when :send
-              receiver, _, arg = value_node.children
-
-              if receiver
-                _, arg_vars = decompose_value(arg)
-                receiver_type = factory.deep_expand_alias(typing.type_of(node: receiver))
-
-                if receiver_type.is_a?(AST::Types::Name::Singleton)
-                  arg_vars.each do |var_name|
-                    var_type = env[var_name]
-                    truthy_type, falsy_type = type_case_select(var_type, receiver_type.name)
-
-                    truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type)
-                    falsy_env = falsy_env.assign!(var_name, node: node, type: falsy_type)
-                  end
-                end
-              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 })
+              ]
             end
-          when AST::Types::Logic::ArgEqualsReceiver
-            case value_node.type
-            when :send
-              receiver, _, arg = value_node.children
+          end
+        end
 
-              if receiver
-                _, arg_vars = decompose_value(arg)
+        truthy_type, falsy_type = factory.unwrap_optional(type)
+        return [truthy_type, falsy_type, env, env]
+      end
 
-                arg_vars.each do |var_name|
-                  var_type = factory.deep_expand_alias(env[var_name])
-                  truthy_types, falsy_types = literal_var_type_case_select(receiver, var_type)
+      def evaluate_assignment(assignment_node, env, rhs_type, refined_objects:)
+        case assignment_node.type
+        when :lvasgn
+          name, _ = assignment_node.children
+          refined_objects << name
+          env.refine_types(local_variable_types: { name => rhs_type })
+        when :masgn
+          lhs, _ = assignment_node.children
+
+          masgn = MultipleAssignment.new()
+          assignments = masgn.expand(lhs, rhs_type, false)
+          unless assignments
+            rhs_type_converted = try_convert(rhs_type, :to_ary)
+            rhs_type_converted ||= try_convert(rhs_type, :to_a)
+            rhs_type_converted ||= AST::Types::Tuple.new(types: [rhs_type])
+            assignments = masgn.expand(lhs, rhs_type_converted, false)
+          end
 
-                  truthy_env = truthy_env.assign!(var_name, node: node, type: AST::Types::Union.build(types: truthy_types, location: nil))
-                  falsy_env = falsy_env.assign!(var_name, node: node, type: AST::Types::Union.build(types: falsy_types, location: nil))
-                end
-              end
-            end
-          when AST::Types::Logic::Not
-            receiver, * = value_node.children
-            receiver_type = typing.type_of(node: receiver)
-            falsy_env, truthy_env = eval(env: env, type: receiver_type, node: receiver)
+          assignments or raise
+
+          assignments.each do |pair|
+            node, type = pair
+            env = evaluate_assignment(node, env, type, refined_objects: refined_objects)
           end
+
+          env
         else
-          _, vars = decompose_value(node)
+          env
+        end
+      end
 
-          vars.each do |var_name|
-            var_type = env[var_name]
-            truthy_type, falsy_type = factory.unwrap_optional(var_type)
+      def refine_node_type(env:, node:, truthy_type:, falsy_type:, refined_objects:)
+        case node.type
+        when :lvar
+          name = node.children[0]
 
-            if falsy_type
-              truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type)
-              falsy_env = falsy_env.assign!(var_name, node: node, type: falsy_type)
-            else
-              truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type)
-              falsy_env = falsy_env.assign!(var_name, node: node, type: truthy_type)
-            end
+          refined_objects << name
+          [
+            env.refine_types(local_variable_types: { name => truthy_type }),
+            env.refine_types(local_variable_types: { name => falsy_type })
+          ]
+        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 })
+          ]
+        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 })
+            ]
+          else
+            [env, env]
           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)
+        else
+          [env, env]
         end
+      end
+
+      def evaluate_method_call(env:, type:, receiver:, arguments:, refined_objects:)
+        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)
+          end
+        when AST::Types::Logic::ReceiverIsArg
+          if receiver && (arg = arguments[0])
+            receiver_type = typing.type_of(node: receiver)
+            arg_type = factory.deep_expand_alias(typing.type_of(node: arg))
 
-        [truthy_env, falsy_env]
+            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)
+            end
+          end
+        when AST::Types::Logic::ArgIsReceiver
+          if receiver && (arg = arguments[0])
+            receiver_type = factory.deep_expand_alias(typing.type_of(node: receiver))
+            arg_type = typing.type_of(node: arg)
+
+            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)
+            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(
+                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
+              )
+            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]
+          end
+        end
       end
 
       def decompose_value(node)
@@ -161,10 +232,8 @@ module Steep
         when :lvar
           [node, Set[node.children[0]]]
         when :masgn
-          lhs, rhs = node.children
-          lhs_vars = lhs.children.select {|m| m.type == :lvasgn }.map {|m| m.children[0] }
-          val, vars = decompose_value(rhs)
-          [val, vars + lhs_vars]
+          _, rhs = node.children
+          decompose_value(rhs)
         when :lvasgn
           var, rhs = node.children
           val, vars = decompose_value(rhs)
@@ -184,18 +253,22 @@ module Steep
       def literal_var_type_case_select(value_node, arg_type)
         case arg_type
         when AST::Types::Union
+          # @type var truthy_types: Array[AST::Types::t]
           truthy_types = []
+          # @type var falsy_types: Array[AST::Types::t]
           falsy_types = []
 
           arg_type.types.each do |type|
-            ts, fs = literal_var_type_case_select(value_node, type)
-            truthy_types.push(*ts)
-            falsy_types.push(*fs)
+            if (ts, fs = literal_var_type_case_select(value_node, type))
+              truthy_types.push(*ts)
+              falsy_types.push(*fs)
+            else
+              return
+            end
           end
 
           [truthy_types, falsy_types]
         else
-          value_type = typing.type_of(node: value_node)
           types = [arg_type]
 
           case value_node.type
@@ -214,7 +287,10 @@ module Steep
                 (type.is_a?(AST::Types::Literal) && type.value == false)
             end
           when :int, :str, :sym
-            types.each.with_object([[], []]) do |type, pair|
+            # @type var pairs: [Array[AST::Types::t], Array[AST::Types::t]]
+            pairs = [[], []]
+
+            types.each_with_object(pairs) do |type, pair|
               true_types, false_types = pair
 
               case
@@ -229,8 +305,6 @@ module Steep
                 false_types << type
               end
             end
-          else
-            [[arg_type], [arg_type]]
           end
         end
       end
@@ -296,6 +370,25 @@ module Steep
           end
         end
       end
+
+      def try_convert(type, method)
+        case type
+        when AST::Types::Any, AST::Types::Bot, AST::Types::Top, AST::Types::Var
+          return
+        end
+
+        interface = factory.interface(type, private: false, self_type: type)
+        if entry = interface.methods[method]
+          method_type = entry.method_types.find do |method_type|
+            method_type.type.params.optional?
+          end
+
+          method_type.type.return_type if method_type
+        end
+      rescue => exn
+        Steep.log_error(exn, message: "Unexpected error when converting #{type.to_s} with #{method}")
+        nil
+      end
     end
   end
 end

data/lib/steep/type_inference/method_call.rb

@@ -12,7 +12,6 @@ module Steep
 
         def hash
           method_name.hash
-          # RBS::MethodType doesn't have #hash
         end
 
         def ==(other)
@@ -26,30 +25,53 @@ module Steep
         end
       end
 
-      MethodContext = Struct.new(:method_name, keyword_init: true) do
+      MethodContext = _ = Struct.new(:method_name, keyword_init: true) do
+        # @implements MethodContext
+
         def to_s
           "@#{method_name}"
         end
       end
 
-      ModuleContext = Struct.new(:type_name, keyword_init: true) do
+      ModuleContext = _ = Struct.new(:type_name, keyword_init: true) do
+        # @implements ModuleContext
+
         def to_s
           "@#{type_name}@"
         end
       end
 
-      TopLevelContext = Class.new() do
+      TopLevelContext = _ = Class.new() do
         def to_s
           "@<main>"
         end
+
+        def ==(other)
+          other.is_a?(TopLevelContext)
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash
+        end
       end
 
-      UnknownContext = Class.new() do
+      UnknownContext = _ = Class.new() do
         def to_s
           "@<unknown>"
         end
-      end
 
+        def ==(other)
+          other.is_a?(UnknownContext)
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash
+        end
+      end
 
       class Base
         attr_reader :node
@@ -73,6 +95,21 @@ module Steep
             end
           end
         end
+
+        def ==(other)
+          other.is_a?(Base) &&
+            other.node == node &&
+            other.context == context &&
+            other.method_name == method_name &&
+            other.return_type == return_type &&
+            other.receiver_type == receiver_type
+        end
+
+        alias eql? ==
+
+        def hash
+          node.hash ^ context.hash ^ method_name.hash ^ return_type.hash ^ receiver_type.hash
+        end
       end
 
       class Typed < Base
@@ -84,6 +121,43 @@ module Steep
           @actual_method_type = actual_method_type
           @method_decls = method_decls
         end
+
+        def pure?
+          method_decls.all? do |method_decl|
+            case member = method_decl.method_def.member
+            when RBS::AST::Members::MethodDefinition
+              member.annotations.any? {|annotation| annotation.string == "pure" }
+            when RBS::AST::Members::Attribute
+              # The attribute writer is not pure
+              !method_decl.method_name.method_name.end_with?("=")
+            end
+          end
+        end
+
+        def update(node: self.node, return_type: self.return_type)
+          _ = self.class.new(
+            node: node,
+            return_type: return_type,
+            context: context,
+            method_name: method_name,
+            receiver_type: receiver_type,
+            actual_method_type: actual_method_type,
+            method_decls: method_decls
+          )
+        end
+
+        def ==(other)
+          super &&
+          other.is_a?(Typed) &&
+            other.actual_method_type == actual_method_type &&
+            other.method_decls == method_decls
+        end
+
+        alias eql? ==
+
+        def hash
+          super ^ actual_method_type.hash ^ method_decls.hash
+        end
       end
 
       class Special < Typed