steep 0.28.0 → 0.29.0

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

@@ -0,0 +1,63 @@
+module Steep
+  module AST
+    module Types
+      module Logic
+        class Base
+          attr_reader :location
+
+          def subst(s)
+            self
+          end
+
+          def free_variables
+            @fvs ||= Set[]
+          end
+
+          def hash
+            self.class.hash
+          end
+
+          def ==(other)
+            other.class ==self.class
+          end
+
+          alias eql? ==
+
+          def to_s
+            "<% #{self.class} %>"
+          end
+        end
+
+        class Not < Base
+          def initialize(location: nil)
+            @location = location
+          end
+        end
+
+        class ReceiverIsNil < Base
+          def initialize(location: nil)
+            @location = location
+          end
+        end
+
+        class ReceiverIsNotNil < Base
+          def initialize(location: nil)
+            @location = location
+          end
+        end
+
+        class ReceiverIsArg < Base
+          def initialize(location: nil)
+            @location = location
+          end
+        end
+
+        class ArgIsReceiver < Base
+          def initialize(location: nil)
+            @location = location
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/interface/method_type.rb

@@ -775,13 +775,15 @@ module Steep
       attr_reader :block
       attr_reader :return_type
       attr_reader :location
+      attr_reader :method_def
 
-      def initialize(type_params:, params:, block:, return_type:, location:)
+      def initialize(type_params:, params:, block:, return_type:, location:, method_def:)
         @type_params = type_params
         @params = params
         @block = block
         @return_type = return_type
         @location = location
+        @method_def = method_def
       end
 
       def ==(other)
@@ -790,6 +792,7 @@ module Steep
           other.params == params &&
           other.block == block &&
           other.return_type == return_type &&
+          (!other.method_def || !method_def || other.method_def == method_def) &&
           (!other.location || !location || other.location == location)
       end
 
@@ -821,6 +824,7 @@ module Steep
           params: params.subst(s_),
           block: block&.subst(s_),
           return_type: return_type.subst(s_),
+          method_def: method_def,
           location: location
         )
       end
@@ -843,14 +847,16 @@ module Steep
                        params: params.subst(s),
                        block: block&.subst(s),
                        return_type: return_type.subst(s),
-                       location: location)
+                       location: location,
+                       method_def: method_def)
       end
 
-      def with(type_params: self.type_params, params: self.params, block: self.block, return_type: self.return_type, location: self.location)
+      def with(type_params: self.type_params, params: self.params, block: self.block, return_type: self.return_type, location: self.location,  method_def: self.method_def)
         self.class.new(type_params: type_params,
                        params: params,
                        block: block,
                        return_type: return_type,
+                       method_def: method_def,
                        location: location)
       end
 
@@ -867,7 +873,8 @@ module Steep
                        params: params.map_type(&block),
                        block: self.block&.yield_self {|blk| blk.map_type(&block) },
                        return_type: yield(return_type),
-                       location: location)
+                       location: location,
+                       method_def: method_def)
       end
 
       # Returns a new method type which can be used for the method implementation type of both `self` and `other`.
@@ -895,6 +902,7 @@ module Steep
           return_type: AST::Types::Union.build(
             types: [return_type.subst(s1),other.return_type.subst(s2)]
           ),
+          method_def: method_def,
           location: nil
         )
       end
@@ -950,6 +958,7 @@ module Steep
           block: block,
           return_type: return_type,
           type_params: type_params,
+          method_def: nil,
           location: nil
         )
       end
@@ -997,6 +1006,7 @@ module Steep
           block: block,
           return_type: return_type,
           type_params: type_params,
+          method_def: nil,
           location: nil
         )
       end

data/lib/steep/module_helper.rb

@@ -0,0 +1,25 @@
+module Steep
+  module ModuleHelper
+    def module_name_from_node(node)
+      case node.type
+      when :const, :casgn
+        namespace = namespace_from_node(node.children[0]) or return
+        name = node.children[1]
+        RBS::TypeName.new(name: name, namespace: namespace)
+      end
+    end
+
+    def namespace_from_node(node)
+      case node&.type
+      when nil
+        RBS::Namespace.empty
+      when :cbase
+        RBS::Namespace.root
+      when :const
+        namespace_from_node(node.children[0])&.yield_self do |parent|
+          parent.append(node.children[1])
+        end
+      end
+    end
+  end
+end

data/lib/steep/project/completion_provider.rb

@@ -10,13 +10,9 @@ module Steep
 
       InstanceVariableItem = Struct.new(:identifier, :range, :type, keyword_init: true)
       LocalVariableItem = Struct.new(:identifier, :range, :type, keyword_init: true)
-      MethodNameItem = Struct.new(:identifier, :range, :definition, :def_type, :inherited_method, keyword_init: true) do
-        def method_type
-          def_type.type
-        end
-
+      MethodNameItem = Struct.new(:identifier, :range, :method_def, :method_type, :inherited_method, keyword_init: true) do
         def comment
-          def_type.comment
+          method_def&.comment
         end
       end
 
@@ -90,7 +86,9 @@ module Steep
       end
 
       def at_end?(pos, of:)
-        of.last_line == pos.line && of.last_column == pos.column
+        if of
+          of.last_line == pos.line && of.last_column == pos.column
+        end
       end
 
       def range_for(position, prefix: "")
@@ -194,21 +192,25 @@ module Steep
         return [] unless node
 
         if at_end?(shift_pos, of: node.loc)
-          context = typing.context_at(line: position.line, column: position.column)
-          receiver_type = case (type = typing.type_of(node: node))
-                          when AST::Types::Self
-                            context.self_type
-                          else
-                            type
-                          end
-
-          items = []
-          method_items_for_receiver_type(receiver_type,
-                                         include_private: false,
-                                         prefix: "",
-                                         position: position,
-                                         items: items)
-          items
+          begin
+            context = typing.context_at(line: position.line, column: position.column)
+            receiver_type = case (type = typing.type_of(node: node))
+                            when AST::Types::Self
+                              context.self_type
+                            else
+                              type
+                            end
+
+            items = []
+            method_items_for_receiver_type(receiver_type,
+                                           include_private: false,
+                                           prefix: "",
+                                           position: position,
+                                           items: items)
+            items
+          rescue Typing::UnknownNodeError
+            []
+          end
         else
           []
         end
@@ -230,37 +232,27 @@ module Steep
 
       def method_items_for_receiver_type(type, include_private:, prefix:, position:, items:)
         range = range_for(position, prefix: prefix)
-        definition = case type
-                     when AST::Types::Name::Instance
-                       type_name = subtyping.factory.type_name_1(type.name)
-                       subtyping.factory.definition_builder.build_instance(type_name)
-                     when AST::Types::Name::Singleton
-                       type_name = subtyping.factory.type_name_1(type.name)
-                       subtyping.factory.definition_builder.build_singleton(type_name)
-                     when AST::Types::Name::Interface
-                       type_name = subtyping.factory.type_name_1(type.name)
-                       subtyping.factory.definition_builder.build_interface(type_name)
-                     end
-
-        if definition
-          definition.methods.each do |name, method|
-            next if disallowed_method?(name)
-
-            if include_private || method.public?
-              if name.to_s.start_with?(prefix)
-                if word_name?(name.to_s)
-                  method.defs.each do |def_type|
-                    items << MethodNameItem.new(identifier: name,
-                                                range: range,
-                                                definition: method,
-                                                def_type: def_type,
-                                                inherited_method: inherited_method?(method, definition))
-                  end
-                end
+        interface = subtyping.factory.interface(type, self_type: type, private: include_private)
+
+        interface.methods.each do |name, method_entry|
+          next if disallowed_method?(name)
+
+          if name.to_s.start_with?(prefix)
+            if word_name?(name.to_s)
+              method_entry.method_types.each do |method_type|
+                items << MethodNameItem.new(
+                  identifier: name,
+                  range: range,
+                  method_def: method_type.method_def,
+                  method_type: method_type.method_def&.type || subtyping.factory.method_type_1(method_type, self_type: type),
+                  inherited_method: inherited_method?(method_type.method_def, type)
+                )
               end
             end
           end
         end
+      rescue
+        # nop
       end
 
       def word_name?(name)
@@ -304,8 +296,13 @@ module Steep
         index
       end
 
-      def inherited_method?(method, definition)
-        method.implemented_in != definition.type_name
+      def inherited_method?(method_def, type)
+        case type
+        when AST::Types::Name::Instance, AST::Types::Name::Singleton, AST::Types::Name::Interface
+          method_def.implemented_in != type.name
+        else
+          false
+        end
       end
 
       def disallowed_method?(name)

data/lib/steep/project/file.rb

@@ -41,8 +41,8 @@ module Steep
       end
 
       def self.type_check(source, subtyping:)
-        annotations = source.annotations(block: source.node, factory: subtyping.factory, current_module: AST::Namespace.root)
-        const_env = TypeInference::ConstantEnv.new(factory: subtyping.factory, context: [AST::Namespace.root])
+        annotations = source.annotations(block: source.node, factory: subtyping.factory, current_module: RBS::Namespace.root)
+        const_env = TypeInference::ConstantEnv.new(factory: subtyping.factory, context: [RBS::Namespace.root])
         type_env = TypeInference::TypeEnv.build(annotations: annotations,
                                                 subtyping: subtyping,
                                                 const_env: const_env,
@@ -58,7 +58,7 @@ module Steep
             instance_type: nil,
             module_type: nil,
             implement_name: nil,
-            current_namespace: AST::Namespace.root,
+            current_namespace: RBS::Namespace.root,
             const_env: const_env,
             class_name: nil
           ),

data/lib/steep/project/hover_content.rb

@@ -21,9 +21,7 @@ module Steep
         @project = project
       end
 
-      def method_definition_for(factory, module_name, singleton_method: nil, instance_method: nil)
-        type_name = factory.type_name_1(module_name)
-
+      def method_definition_for(factory, type_name, singleton_method: nil, instance_method: nil)
         case
         when instance_method
           factory.definition_builder.build_instance(type_name).methods[instance_method]
@@ -86,7 +84,7 @@ module Steep
                                           when AST::Types::Name::Instance
                                             method_definition = method_definition_for(factory, receiver_type.name, instance_method: method_name)
                                             if method_definition&.defined_in
-                                              owner_name = factory.type_name(method_definition.defined_in)
+                                              owner_name = method_definition.defined_in
                                               [
                                                 InstanceMethodName.new(owner_name, method_name),
                                                 method_definition
@@ -95,7 +93,7 @@ module Steep
                                           when AST::Types::Name::Singleton
                                             method_definition = method_definition_for(factory, receiver_type.name, singleton_method: method_name)
                                             if method_definition&.defined_in
-                                              owner_name = factory.type_name(method_definition.defined_in)
+                                              owner_name = method_definition.defined_in
                                               [
                                                 SingletonMethodName.new(owner_name, method_name),
                                                 method_definition

data/lib/steep/signature/validator.rb

@@ -130,19 +130,19 @@ module Steep
         yield
       rescue RBS::InvalidTypeApplicationError => exn
         @errors << Errors::InvalidTypeApplicationError.new(
-          name: factory.type_name(exn.type_name),
+          name: exn.type_name,
           args: exn.args.map {|ty| factory.type(ty) },
           params: exn.params,
           location: exn.location
         )
       rescue RBS::NoTypeFoundError, RBS::NoSuperclassFoundError, RBS::NoMixinFoundError => exn
         @errors << Errors::UnknownTypeNameError.new(
-          name: factory.type_name(exn.type_name),
+          name: exn.type_name,
           location: exn.location
         )
       rescue RBS::InvalidOverloadMethodError => exn
         @errors << Errors::InvalidMethodOverloadError.new(
-          class_name: factory.type_name(exn.type_name),
+          class_name: exn.type_name,
           method_name: exn.method_name,
           location: exn.members[0].location
         )

data/lib/steep/subtyping/check.rb

@@ -10,8 +10,7 @@ module Steep
       end
 
       def instance_super_types(type_name, args:)
-        type_name_1 = factory.type_name_1(type_name)
-        ancestors = factory.definition_builder.one_instance_ancestors(type_name_1)
+        ancestors = factory.definition_builder.one_instance_ancestors(type_name)
 
         subst = unless args.empty?
                   args_ = args.map {|type| factory.type_1(type) }
@@ -19,7 +18,7 @@ module Steep
                 end
 
         ancestors.each_ancestor.map do |ancestor|
-          name = factory.type_name(ancestor.name)
+          name = ancestor.name
 
           case ancestor
           when RBS::Definition::Ancestor::Instance
@@ -51,11 +50,10 @@ module Steep
       end
 
       def singleton_super_types(type_name)
-        type_name_1 = factory.type_name_1(type_name)
-        ancestors = factory.definition_builder.one_singleton_ancestors(type_name_1)
+        ancestors = factory.definition_builder.one_singleton_ancestors(type_name)
 
         ancestors.each_ancestor.map do |ancestor|
-          name = factory.type_name(ancestor.name)
+          name = ancestor.name
 
           case ancestor
           when RBS::Definition::Ancestor::Instance
@@ -392,7 +390,7 @@ module Steep
       end
 
       def definition_for_type(type)
-        type_name = factory.type_name_1(type.name)
+        type_name = type.name
 
         case type
         when AST::Types::Name::Instance

data/lib/steep/subtyping/constraints.rb

@@ -104,6 +104,14 @@ module Steep
       def add(var, sub_type: nil, super_type: nil)
         subs, supers = dictionary[var]
 
+        if sub_type.is_a?(AST::Types::Logic::Base)
+          sub_type = AST::Builtin.bool_type
+        end
+
+        if super_type.is_a?(AST::Types::Logic::Base)
+          super_type = AST::Builtin.bool_type
+        end
+
         if super_type && !super_type.is_a?(AST::Types::Top)
           supers << eliminate_variable(super_type, to: AST::Types::Top.new)
         end

data/lib/steep/type_construction.rb

@@ -33,6 +33,8 @@ module Steep
       end
     end
 
+    include ModuleHelper
+
     attr_reader :checker
     attr_reader :source
     attr_reader :annotations
@@ -169,7 +171,7 @@ module Steep
 
       super_method = if definition
                        if (this_method = definition.methods[method_name])
-                         if module_context&.class_name == checker.factory.type_name(this_method.defined_in)
+                         if module_context&.class_name == this_method.defined_in
                            this_method.super_method
                          else
                            this_method
@@ -254,7 +256,7 @@ module Steep
         end
 
         if name
-          absolute_name_ = checker.factory.type_name_1(name)
+          absolute_name_ = name
           entry = checker.factory.env.class_decls[absolute_name_]
           AST::Annotation::Implements::Module.new(
             name: name,
@@ -265,7 +267,7 @@ module Steep
     end
 
     def for_module(node)
-      new_module_name = Names::Module.from_node(node.children.first) or raise "Unexpected module name: #{node.children.first}"
+      new_module_name = module_name_from_node(node.children.first) or raise "Unexpected module name: #{node.children.first}"
       new_namespace = nested_namespace_for_module(new_module_name)
 
       const_context = [new_namespace] + self.module_context.const_env.context
@@ -280,7 +282,7 @@ module Steep
         module_name = implement_module_name.name
         module_args = implement_module_name.args.map {|x| AST::Types::Var.new(name: x)}
 
-        type_name_ = checker.factory.type_name_1(implement_module_name.name)
+        type_name_ = implement_module_name.name
         module_entry = checker.factory.definition_builder.env.class_decls[type_name_]
         instance_def = checker.factory.definition_builder.build_instance(type_name_)
         module_def = checker.factory.definition_builder.build_singleton(type_name_)
@@ -359,8 +361,8 @@ module Steep
     end
 
     def for_class(node)
-      new_class_name = Names::Module.from_node(node.children.first) or raise "Unexpected class name: #{node.children.first}"
-      super_class_name = node.children[1] && Names::Module.from_node(node.children[1])
+      new_class_name = module_name_from_node(node.children.first) or raise "Unexpected class name: #{node.children.first}"
+      super_class_name = node.children[1] && module_name_from_node(node.children[1])
       new_namespace = nested_namespace_for_module(new_class_name)
 
       annots = source.annotations(block: node, factory: checker.factory, current_module: new_namespace)
@@ -375,7 +377,7 @@ module Steep
         class_name = implement_module_name.name
         class_args = implement_module_name.args.map {|x| AST::Types::Var.new(name: x)}
 
-        type_name_ = checker.factory.type_name_1(implement_module_name.name)
+        type_name_ = implement_module_name.name
         instance_def = checker.factory.definition_builder.build_instance(type_name_)
         module_def = checker.factory.definition_builder.build_singleton(type_name_)
 
@@ -445,7 +447,7 @@ module Steep
 
       module_type = case instance_type
                     when AST::Types::Name::Singleton
-                      type_name = checker.factory.type_name_1(instance_type.name)
+                      type_name = instance_type.name
 
                       case checker.factory.env.class_decls[type_name]
                       when RBS::Environment::ModuleEntry
@@ -464,16 +466,16 @@ module Steep
 
       instance_definition = case instance_type
                             when AST::Types::Name::Singleton
-                              type_name = checker.factory.type_name_1(instance_type.name)
+                              type_name = instance_type.name
                               checker.factory.definition_builder.build_singleton(type_name)
                             when AST::Types::Name::Instance
-                              type_name = checker.factory.type_name_1(instance_type.name)
+                              type_name = instance_type.name
                               checker.factory.definition_builder.build_instance(type_name)
                             end
 
       module_definition = case module_type
                           when AST::Types::Name::Singleton
-                            type_name = checker.factory.type_name_1(instance_type.name)
+                            type_name = instance_type.name
                             checker.factory.definition_builder.build_singleton(type_name)
                           else
                             nil
@@ -888,10 +890,10 @@ module Steep
             self_type = expand_self(self_type)
             definition = case self_type
                          when AST::Types::Name::Instance
-                           name = checker.factory.type_name_1(self_type.name)
+                           name = self_type.name
                            checker.factory.definition_builder.build_singleton(name)
                          when AST::Types::Name::Singleton
-                           name = checker.factory.type_name_1(self_type.name)
+                           name = self_type.name
                            checker.factory.definition_builder.build_singleton(name)
                          end
 
@@ -1270,7 +1272,7 @@ module Steep
           add_typing node, type: AST::Types::Self.new
 
         when :const
-          const_name = Names::Module.from_node(node)
+          const_name = module_name_from_node(node)
 
           if const_name
             type = type_env.get(const: const_name) do
@@ -1283,7 +1285,7 @@ module Steep
 
         when :casgn
           yield_self do
-            const_name = Names::Module.from_node(node)
+            const_name = module_name_from_node(node)
             if const_name
               const_type = type_env.get(const: const_name) {}
               value_type = synthesize(node.children.last, hint: const_type).type
@@ -1396,15 +1398,17 @@ module Steep
         when :and
           yield_self do
             left, right = node.children
-            logic = TypeInference::Logic.new(subtyping: checker)
-            truthy, falsey = logic.nodes(node: left)
 
             left_type, constr = synthesize(left)
-            truthy_env, falsey_env = logic.environments(truthy_vars: truthy.vars,
-                                                        falsey_vars: falsey.vars,
-                                                        lvar_env: constr.context.lvar_env)
 
-            right_type, constr = constr.update_lvar_env { truthy_env }.for_branch(right).synthesize(right)
+            interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
+            truthy_env, falsey_env = interpreter.eval(env: constr.context.lvar_env, type: left_type, node: left)
+
+            right_type, constr = constr
+                                   .update_lvar_env { truthy_env }
+                                   .tap {|constr| typing.add_context_for_node(right, context: constr.context) }
+                                   .for_branch(right)
+                                   .synthesize(right)
 
             type = if left_type.is_a?(AST::Types::Boolean)
                      union_type(left_type, right_type)
@@ -1426,16 +1430,18 @@ module Steep
         when :or
           yield_self do
             left, right = node.children
-            logic = TypeInference::Logic.new(subtyping: checker)
-            truthy, falsey = logic.nodes(node: left)
 
             left_type, constr = synthesize(left, hint: hint)
-            truthy_env, falsey_env = logic.environments(truthy_vars: truthy.vars,
-                                                        falsey_vars: falsey.vars,
-                                                        lvar_env: constr.context.lvar_env)
-            left_type_t, _ = logic.partition_union(left_type)
 
-            right_type, constr = constr.update_lvar_env { falsey_env }.for_branch(right).synthesize(right, hint: left_type_t)
+            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)
+            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)
 
             type = union_type(left_type_t, right_type)
 
@@ -1454,12 +1460,8 @@ module Steep
           cond, true_clause, false_clause = node.children
 
           cond_type, constr = synthesize(cond)
-          logic = TypeInference::Logic.new(subtyping: checker)
-
-          truthys, falseys = logic.nodes(node: cond)
-          truthy_env, falsey_env = logic.environments(truthy_vars: truthys.vars,
-                                                      falsey_vars: falseys.vars,
-                                                      lvar_env: constr.context.lvar_env)
+          interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: constr.typing)
+          truthy_env, falsey_env = interpreter.eval(env: constr.context.lvar_env, type: cond_type, node: cond)
 
           if true_clause
             true_pair = constr
@@ -1509,70 +1511,91 @@ module Steep
             cond, *whens, els = node.children
 
             constr = self
+            interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
 
             if cond
-              cond_type, constr = synthesize(cond)
-              cond_type = expand_alias(cond_type)
-              if cond_type.is_a?(AST::Types::Union)
-                var_names = TypeConstruction.value_variables(cond)
-                var_types = cond_type.types.dup
-              end
-            end
+              branch_pairs = []
 
-            branch_pairs = []
+              cond_type, constr = constr.synthesize(cond)
+              _, cond_vars = interpreter.decompose_value(cond)
 
-            whens.each do |clause|
-              *tests, body = clause.children
+              when_constr = constr
+              whens.each do |clause|
+                *tests, body = clause.children
 
-              test_types = []
-              clause_constr = constr
+                test_constr = when_constr
+                test_envs = []
 
-              tests.each do |test|
-                type, clause_constr = synthesize(test)
-                test_types << expand_alias(type)
-              end
-
-              if var_names && var_types && test_types.all? {|ty| ty.is_a?(AST::Types::Name::Singleton) }
-                var_types_in_body = test_types.flat_map do |test_type|
-                  filtered_types = var_types.select do |var_type|
-                    var_type.is_a?(AST::Types::Name::Base) && var_type.name == test_type.name
-                  end
-                  if filtered_types.empty?
-                    to_instance_type(test_type)
-                  else
-                    filtered_types
-                  end
+                tests.each do |test|
+                  test_node = test.updated(:send, [test, :===, cond.dup])
+                  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)
+                  test_envs << truthy_env
+                  test_constr = test_constr.update_lvar_env { falsy_env }
                 end
 
-                var_types.reject! do |type|
-                  var_types_in_body.any? do |test_type|
-                    type.is_a?(AST::Types::Name::Base) && test_type.name == type.name
-                  end
-                end
-
-                var_type_in_body = union_type(*var_types_in_body)
-                type_case_override = var_names.each.with_object({}) do |var_name, hash|
-                  hash[var_name] = var_type_in_body
-                end
+                body_constr = when_constr.update_lvar_env {|env| env.except(cond_vars).join(*test_envs) }
 
                 if body
-                  branch_pairs << clause_constr
-                                    .for_branch(body, type_case_override: type_case_override)
+                  branch_pairs << body_constr
+                                    .for_branch(body)
+                                    .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
                                     .synthesize(body, hint: hint)
                 else
-                  branch_pairs << Pair.new(type: AST::Builtin.nil_type, constr: clause_constr)
+                  branch_pairs << Pair.new(type: AST::Builtin.nil_type, constr: body_constr)
+                end
+
+                when_constr = test_constr
+              end
+
+              if els
+                begin_pos = node.loc.else.end_pos
+                end_pos = node.loc.end.begin_pos
+                typing.add_context(begin_pos..end_pos, context: when_constr.context)
+
+                branch_pairs << when_constr.synthesize(els, hint: hint)
+              end
+
+              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
+                  typing.add_error Errors::ElseOnExhaustiveCase.new(node: els, type: cond_type)
                 end
               else
-                logic = TypeInference::Logic.new(subtyping: checker)
+                unless els
+                  types << AST::Builtin.nil_type
+                end
+              end
+            else
+              branch_pairs = []
+
+              when_constr = constr
+
+              whens.each do |clause|
+                *tests, body = clause.children
 
-                truthys, falseys = logic.nodes(node: ::AST::Node.new(:begin, tests))
-                truthy_env, _ = logic.environments(truthy_vars: truthys.vars,
-                                                   falsey_vars: falseys.vars,
-                                                   lvar_env: clause_constr.context.lvar_env)
+                test_constr = when_constr
+                test_envs = []
+
+                tests.each do |test|
+                  test_type, test_constr = test_constr.synthesize(test)
+                  truthy_env, falsy_env = interpreter.eval(env: test_constr.context.lvar_env, type: test_type, node: test)
+                  test_envs << truthy_env
+                  test_constr = test_constr.update_lvar_env { falsy_env }
+                end
+
+                clause_constr = when_constr.update_lvar_env {|env| env.join(*test_envs) }
+                when_constr = test_constr
 
                 if body
-                  branch_pairs << constr
-                                    .update_lvar_env { truthy_env }
+                  branch_pairs << clause_constr
                                     .for_branch(body)
                                     .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
                                     .synthesize(body, hint: hint)
@@ -1580,34 +1603,17 @@ module Steep
                   branch_pairs << Pair.new(type: AST::Builtin.nil_type, constr: clause_constr)
                 end
               end
-            end
 
-            if els
-              if var_names && var_types
-                if var_types.empty?
-                  typing.add_error Errors::ElseOnExhaustiveCase.new(node: node, type: cond_type)
-                end
-
-                else_override = var_names.each.with_object({}) do |var_name, hash|
-                  hash[var_name] = unless var_types.empty?
-                                     union_type(*var_types)
-                                   else
-                                     AST::Builtin.any_type
-                                   end
-                end
-                branch_pairs << constr
-                                  .for_branch(els, type_case_override: else_override)
-                                  .synthesize(els, hint: hint)
-              else
-                branch_pairs << constr.synthesize(els, hint: hint)
+              if els
+                branch_pairs << when_constr.synthesize(els, hint: hint)
               end
-            end
 
-            types = branch_pairs.map(&:type)
-            constrs = branch_pairs.map(&:constr)
+              types = branch_pairs.map(&:type)
+              constrs = branch_pairs.map(&:constr)
 
-            unless var_types&.empty? || els
-              types.push AST::Builtin.nil_type
+              unless els
+                types << AST::Builtin.nil_type
+              end
             end
 
             constr = constr.update_lvar_env do |env|
@@ -1620,7 +1626,7 @@ module Steep
         when :rescue
           yield_self do
             body, *resbodies, else_node = node.children
-            body_pair = synthesize(body) if body
+            body_pair = synthesize(body, hint: hint) if body
 
             body_constr = if body_pair
                             self.update_lvar_env do |env|
@@ -1672,7 +1678,7 @@ module Steep
               resbody_construction = body_constr.for_branch(resbody, type_case_override: type_override)
 
               if body
-                resbody_construction.synthesize(body)
+                resbody_construction.synthesize(body, hint: hint)
               else
                 Pair.new(constr: body_constr, type: AST::Builtin.nil_type)
               end
@@ -1682,7 +1688,7 @@ module Steep
             resbody_envs = resbody_pairs.map {|pair| pair.context.lvar_env }
 
             if else_node
-              else_pair = (body_pair&.constr || self).for_branch(else_node).synthesize(else_node)
+              else_pair = (body_pair&.constr || self).for_branch(else_node).synthesize(else_node, hint: hint)
               add_typing(node,
                          type: union_type(*[else_pair.type, *resbody_types].compact),
                          constr: update_lvar_env {|env| env.join(*resbody_envs, env) })
@@ -1698,7 +1704,7 @@ module Steep
             klasses, asgn, body = node.children
             synthesize(klasses) if klasses
             synthesize(asgn) if asgn
-            body_type = synthesize(body).type if body
+            body_type = synthesize(body, hint: hint).type if body
             add_typing(node, type: body_type)
           end
 
@@ -1759,16 +1765,16 @@ module Steep
         when :while, :until
           yield_self do
             cond, body = node.children
-            _, constr = synthesize(cond)
+            cond_type, constr = synthesize(cond)
 
-            logic = TypeInference::Logic.new(subtyping: checker)
-            truthy, falsey = logic.nodes(node: cond)
+            interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
+            truthy_env, falsy_env = interpreter.eval(env: constr.context.lvar_env, node: cond, type: cond_type)
 
             case node.type
             when :while
-              body_env, exit_env = logic.environments(truthy_vars: truthy.vars, falsey_vars: falsey.vars, lvar_env: constr.context.lvar_env)
+              body_env, exit_env = truthy_env, falsy_env
             when :until
-              exit_env, body_env = logic.environments(truthy_vars: truthy.vars, falsey_vars: falsey.vars, lvar_env: constr.context.lvar_env)
+              exit_env, body_env = truthy_env, falsy_env
             end
 
             if body
@@ -2007,8 +2013,18 @@ module Steep
             add_typing node, type: AST::Builtin.any_type
           end
 
+        when :args
+          constr = self
+
+          each_child_node(node) do |child|
+            _, constr = constr.synthesize(child)
+          end
+
+          add_typing node, type: AST::Builtin.any_type, constr: constr
+
         else
           raise "Unexpected node: #{node.inspect}, #{node.location.expression}"
+
         end.tap do |pair|
           unless pair.is_a?(Pair) && !pair.type.is_a?(Pair)
             # Steep.logger.error { "result = #{pair.inspect}" }
@@ -2271,7 +2287,7 @@ module Steep
 
     def type_send(node, send_node:, block_params:, block_body:, unwrap: false)
       receiver, method_name, *arguments = send_node.children
-      receiver_type = receiver ? synthesize(receiver).type : AST::Types::Self.new
+      receiver_type, constr = receiver ? synthesize(receiver) : [AST::Types::Self.new, self]
 
       if unwrap
         receiver_type = unwrap(receiver_type)
@@ -2279,74 +2295,80 @@ module Steep
 
       receiver_type = expand_alias(receiver_type)
 
-      pair = case receiver_type
-             when AST::Types::Any
-               add_typing node, type: AST::Builtin.any_type
+      type, constr = case receiver_type
+                     when AST::Types::Any
+                       each_child_node(send_node) do |child|
+                         unless child.equal?(receiver)
+                           _, constr = constr.synthesize(child)
+                         end
+                       end
 
-             when nil
-               fallback_to_any node
+                       add_typing node, type: AST::Builtin.any_type
 
-             when AST::Types::Void, AST::Types::Bot, AST::Types::Top
-               fallback_to_any node do
-                 Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
-               end
+                     when nil
+                       fallback_to_any node
 
-             else
-               case expanded_receiver_type = expand_self(receiver_type)
-               when AST::Types::Self
-                 Steep.logger.debug { "`self` type cannot be resolved to concrete type" }
-                 fallback_to_any node do
-                   Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
-                 end
-               else
-                 begin
-                   interface = checker.factory.interface(receiver_type,
-                                                         private: !receiver,
-                                                         self_type: expanded_receiver_type)
-
-                   method = interface.methods[method_name]
-
-                   if method
-                     args = TypeInference::SendArgs.from_nodes(arguments)
-                     return_type, constr, _ = type_method_call(node,
-                                                               method: method,
-                                                               method_name: method_name,
-                                                               args: args,
-                                                               block_params: block_params,
-                                                               block_body: block_body,
-                                                               receiver_type: receiver_type,
-                                                               topdown_hint: true)
-
-                     add_typing node, type: return_type, constr: constr
-                   else
-                     fallback_to_any node do
-                       Errors::NoMethod.new(node: node, method: method_name, type: expanded_receiver_type)
-                     end
-                   end
-                 rescue => exn
-                   case exn
-                   when RBS::NoTypeFoundError, RBS::NoMixinFoundError, RBS::NoSuperclassFoundError, RBS::InvalidTypeApplicationError
-                     # ignore known RBS errors.
-                   else
-                     Steep.log_error(exn, message: "Unexpected error in #type_send: #{exn.message} (#{exn.class})")
-                   end
+                     when AST::Types::Void, AST::Types::Bot, AST::Types::Top
+                       fallback_to_any node do
+                         Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
+                       end
 
-                   fallback_to_any node do
-                     Errors::NoMethod.new(node: node, method: method_name, type: expanded_receiver_type)
-                   end
-                 end
-               end
-             end
+                     else
+                       case expanded_receiver_type = expand_self(receiver_type)
+                       when AST::Types::Self
+                         Steep.logger.debug { "`self` type cannot be resolved to concrete type" }
+                         fallback_to_any node do
+                           Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
+                         end
+                       else
+                         begin
+                           interface = checker.factory.interface(receiver_type,
+                                                                 private: !receiver,
+                                                                 self_type: expanded_receiver_type)
+
+                           method = interface.methods[method_name]
+
+                           if method
+                             args = TypeInference::SendArgs.from_nodes(arguments)
+                             return_type, constr, _ = constr.type_method_call(node,
+                                                                              method: method,
+                                                                              method_name: method_name,
+                                                                              args: args,
+                                                                              block_params: block_params,
+                                                                              block_body: block_body,
+                                                                              receiver_type: receiver_type,
+                                                                              topdown_hint: true)
+
+                             add_typing node, type: return_type, constr: constr
+                           else
+                             fallback_to_any node do
+                               Errors::NoMethod.new(node: node, method: method_name, type: expanded_receiver_type)
+                             end
+                           end
+                         rescue => exn
+                           case exn
+                           when RBS::NoTypeFoundError, RBS::NoMixinFoundError, RBS::NoSuperclassFoundError, RBS::InvalidTypeApplicationError
+                             # ignore known RBS errors.
+                           else
+                             Steep.log_error(exn, message: "Unexpected error in #type_send: #{exn.message} (#{exn.class})")
+                           end
 
-      case pair.type
+                           fallback_to_any node do
+                             Errors::NoMethod.new(node: node, method: method_name, type: expanded_receiver_type)
+                           end
+                         end
+                       end
+                     end
+
+      case type
       when nil, Errors::Base
         arguments.each do |arg|
           unless typing.has_type?(arg)
             if arg.type == :splat
-              type = synthesize(arg.children[0]).type
+              type, constr = constr.synthesize(arg.children[0])
               add_typing(arg, type: AST::Builtin::Array.instance_type(type))
             else
-              synthesize(arg)
+              _, constr = constr.synthesize(arg)
             end
           end
         end
@@ -2368,7 +2390,7 @@ module Steep
           end
         end
       else
-        pair
+        Pair.new(type: type, constr: constr)
       end
     end
 
@@ -2867,7 +2889,7 @@ module Steep
         decls = param_types_hash.each.with_object({}) do |(name, type), hash|
           hash[name] = TypeInference::LocalVariableTypeEnv::Entry.new(type: type)
         end
-        env.update(declared_types: env.declared_types.merge(decls))
+        env.except(decls.keys).update(assigned_types: decls)
       end.annotate(block_annotations)
 
       break_type = if block_annotations.break_type
@@ -3010,7 +3032,7 @@ module Steep
     end
 
     def nested_namespace_for_module(module_name)
-      if module_name.relative?
+      if module_name.namespace.relative?
         (current_namespace + module_name.namespace).append(module_name.name)
       else
         module_name
@@ -3019,7 +3041,7 @@ module Steep
 
     def absolute_name(module_name)
       if current_namespace
-        module_name.in_namespace(current_namespace)
+        module_name.with_prefix(current_namespace)
       else
         module_name.absolute!
       end
@@ -3037,7 +3059,7 @@ module Steep
     end
 
     def validate_method_definitions(node, module_name)
-      module_name_1 = checker.factory.type_name_1(module_name.name)
+      module_name_1 = module_name.name
       member_decl_count = checker.factory.env.class_decls[module_name_1].decls.count {|d| d.decl.each_member.count > 0 }
 
       return unless member_decl_count == 1
@@ -3185,37 +3207,12 @@ module Steep
       end
     end
 
-    def deep_expand_alias(type, recursive: Set.new, &block)
-      raise "Recursive type definition: #{type}" if recursive.member?(type)
-
-      ty = case type
-           when AST::Types::Name::Alias
-             deep_expand_alias(expand_alias(type), recursive: recursive.union([type]))
-           when AST::Types::Union
-             AST::Types::Union.build(
-               types: type.types.map {|ty| deep_expand_alias(ty, recursive: recursive, &block) },
-               location: type.location
-             )
-           else
-             type
-           end
-
-      if block_given?
-        yield ty
-      else
-        ty
-      end
+    def deep_expand_alias(type, &block)
+      checker.factory.deep_expand_alias(type, &block)
     end
 
-    def flatten_union(type, acc = [])
-      case type
-      when AST::Types::Union
-        type.types.each {|ty| flatten_union(ty, acc) }
-      else
-        acc << type
-      end
-
-      acc
+    def flatten_union(type)
+      checker.factory.flatten_union(type)
     end
 
     def select_flatten_types(type, &block)
@@ -3277,7 +3274,7 @@ module Steep
     def to_instance_type(type, args: nil)
       args = args || case type
                      when AST::Types::Name::Singleton
-                       checker.factory.env.class_decls[checker.factory.type_name_1(type.name)].type_params.each.map { AST::Builtin.any_type }
+                       checker.factory.env.class_decls[type.name].type_params.each.map { AST::Builtin.any_type }
                      else
                        raise "unexpected type to to_instance_type: #{type}"
                      end