steep 0.23.0 → 0.29.0

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
@@ -42,9 +41,8 @@ module Steep
               )
             end
           when RBS::Definition::Ancestor::Singleton
-            AST::Types::Name::Class.new(
+            AST::Types::Name::Singleton.new(
               name: name,
-              constructor: nil,
               location: nil
             )
           end
@@ -52,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
@@ -78,9 +75,8 @@ module Steep
               )
             end
           when RBS::Definition::Ancestor::Singleton
-            AST::Types::Name::Class.new(
+            AST::Types::Name::Singleton.new(
               name: name,
-              constructor: nil,
               location: nil
             )
           end
@@ -180,6 +176,14 @@ module Steep
               constraints: constraints
             )
 
+          when relation.super_type.is_a?(AST::Types::Var) && constraints.unknown?(relation.super_type.name)
+            constraints.add(relation.super_type.name, sub_type: relation.sub_type)
+            success(constraints: constraints)
+
+          when relation.sub_type.is_a?(AST::Types::Var) && constraints.unknown?(relation.sub_type.name)
+            constraints.add(relation.sub_type.name, super_type: relation.super_type)
+            success(constraints: constraints)
+
           when relation.sub_type.is_a?(AST::Types::Union)
             results = relation.sub_type.types.map do |sub_type|
               check(Relation.new(sub_type: sub_type, super_type: relation.super_type),
@@ -232,14 +236,6 @@ module Steep
               results.find(&:failure?)
             end
 
-          when relation.super_type.is_a?(AST::Types::Var) && constraints.unknown?(relation.super_type.name)
-            constraints.add(relation.super_type.name, sub_type: relation.sub_type)
-            success(constraints: constraints)
-
-          when relation.sub_type.is_a?(AST::Types::Var) && constraints.unknown?(relation.sub_type.name)
-            constraints.add(relation.sub_type.name, super_type: relation.super_type)
-            success(constraints: constraints)
-
           when relation.super_type.is_a?(AST::Types::Var) || relation.sub_type.is_a?(AST::Types::Var)
             failure(error: Result::Failure::UnknownPairError.new(relation: relation),
                     trace: trace)
@@ -266,7 +262,7 @@ module Steep
               possible_sub_types = case relation.sub_type
                                    when AST::Types::Name::Instance
                                      instance_super_types(relation.sub_type.name, args: relation.sub_type.args)
-                                   when AST::Types::Name::Class
+                                   when AST::Types::Name::Singleton
                                      singleton_super_types(relation.sub_type.name)
                                    else
                                      []
@@ -302,10 +298,9 @@ module Steep
           when relation.sub_type.is_a?(AST::Types::Tuple) && relation.super_type.is_a?(AST::Types::Tuple)
             if relation.sub_type.types.size >= relation.super_type.types.size
               pairs = relation.sub_type.types.take(relation.super_type.types.size).zip(relation.super_type.types)
-              results = pairs.flat_map do |t1, t2|
+              results = pairs.map do |t1, t2|
                 relation = Relation.new(sub_type: t1, super_type: t2)
-                [check(relation, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints),
-                 check(relation.flip, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)]
+                check(relation, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
               end
 
               if results.all?(&:success?)
@@ -318,16 +313,17 @@ module Steep
                       trace: trace)
             end
 
-          when relation.sub_type.is_a?(AST::Types::Tuple) && relation.super_type.is_a?(AST::Types::Name::Base)
-            tuple_interface = factory.interface(relation.sub_type, private: false)
-            type_interface = factory.interface(relation.super_type, private: false)
+          when relation.sub_type.is_a?(AST::Types::Tuple) && AST::Builtin::Array.instance_type?(relation.super_type)
+            tuple_element_type = AST::Types::Union.build(
+              types: relation.sub_type.types,
+              location: relation.sub_type.location
+            )
 
-            check_interface(tuple_interface,
-                            type_interface,
-                            self_type: self_type,
-                            assumption: assumption,
-                            trace: trace,
-                            constraints: constraints)
+            check(Relation.new(sub_type: tuple_element_type, super_type: relation.super_type.args[0]),
+                  self_type: self_type,
+                  assumption: assumption,
+                  trace: trace,
+                  constraints: constraints)
 
           when relation.sub_type.is_a?(AST::Types::Record) && relation.super_type.is_a?(AST::Types::Record)
             if Set.new(relation.sub_type.elements.keys).superset?(Set.new(relation.super_type.elements.keys))
@@ -394,12 +390,12 @@ 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
           factory.definition_builder.build_instance(type_name)
-        when AST::Types::Name::Class
+        when AST::Types::Name::Singleton
           factory.definition_builder.build_singleton(type_name)
         when AST::Types::Name::Interface
           factory.definition_builder.build_interface(type_name)
@@ -484,11 +480,7 @@ module Steep
           if sub_type.name == super_type.name && sub_type.args.size == super_type.args.size
             sub_type.args.zip(super_type.args)
           end
-        when sub_type.is_a?(AST::Types::Name::Class) && super_type.is_a?(AST::Types::Name::Class)
-          if sub_type.name == super_type.name
-            []
-          end
-        when sub_type.is_a?(AST::Types::Name::Module) && super_type.is_a?(AST::Types::Name::Module)
+        when sub_type.is_a?(AST::Types::Name::Singleton) && super_type.is_a?(AST::Types::Name::Singleton)
           if sub_type.name == super_type.name
             []
           end
@@ -535,29 +527,24 @@ module Steep
 
       def check_method(name, sub_method, super_method, self_type:, assumption:, trace:, constraints:)
         trace.method name, sub_method, super_method do
-          case
-          when sub_method.overload? && super_method.overload?
-            super_method.types.map do |super_type|
-              sub_method.types.map do |sub_type|
-                check_generic_method_type name,
-                                          sub_type,
-                                          super_type,
-                                          self_type: self_type,
-                                          assumption: assumption,
-                                          trace: trace,
-                                          constraints: constraints
-              end.yield_self do |results|
-                results.find(&:success?) || results[0]
-              end
+          super_method.method_types.map do |super_type|
+            sub_method.method_types.map do |sub_type|
+              check_generic_method_type name,
+                                        sub_type,
+                                        super_type,
+                                        self_type: self_type,
+                                        assumption: assumption,
+                                        trace: trace,
+                                        constraints: constraints
             end.yield_self do |results|
-              if results.all?(&:success?) || sub_method.incompatible?
-                success constraints: constraints
-              else
-                results.select(&:failure?).last
-              end
+              results.find(&:success?) || results[0]
+            end
+          end.yield_self do |results|
+            if results.all?(&:success?)
+              success constraints: constraints
+            else
+              results.select(&:failure?).last
             end
-          else
-            raise "aaaaaaaaaaaaaa"
           end
         end
       end

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
@@ -113,6 +115,7 @@ module Steep
     end
 
     def check_relation(sub_type:, super_type:, constraints: Subtyping::Constraints.empty)
+      Steep.logger.debug { "check_relation: self:#{self_type} |- #{sub_type} <: #{super_type}" }
       checker.check(Subtyping::Relation.new(sub_type: sub_type, super_type: super_type), self_type: self_type, constraints: constraints)
     end
 
@@ -168,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
@@ -253,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,
@@ -264,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
@@ -279,14 +282,13 @@ 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_)
 
         instance_type = AST::Types::Intersection.build(
           types: [
-            AST::Types::Name::Instance.new(name: module_name, args: module_args),
             AST::Builtin::Object.instance_type,
             *module_entry.self_types.map {|module_self|
               type = case
@@ -304,11 +306,12 @@ module Steep
                        )
                      end
               checker.factory.type(type)
-            }
+            },
+            AST::Types::Name::Instance.new(name: module_name, args: module_args)
           ].compact
         )
 
-        module_type = AST::Types::Name::Class.new(name: module_name, constructor: nil)
+        module_type = AST::Types::Name::Singleton.new(name: module_name)
       end
 
       if annots.instance_type
@@ -358,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)
@@ -374,12 +377,12 @@ 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_)
 
         instance_type = AST::Types::Name::Instance.new(name: class_name, args: class_args)
-        module_type = AST::Types::Name::Class.new(name: class_name, constructor: nil)
+        module_type = AST::Types::Name::Singleton.new(name: class_name)
       end
 
       if annots.instance_type
@@ -443,28 +446,36 @@ module Steep
                       end
 
       module_type = case instance_type
-                    when AST::Types::Name::Class
-                      AST::Builtin::Class.instance_type
-                    when AST::Types::Name::Module
-                      AST::Builtin::Module.instance_type
+                    when AST::Types::Name::Singleton
+                      type_name = instance_type.name
+
+                      case checker.factory.env.class_decls[type_name]
+                      when RBS::Environment::ModuleEntry
+                        AST::Builtin::Module.instance_type
+                      when RBS::Environment::ClassEntry
+                        AST::Builtin::Class.instance_type
+                      else
+                        raise
+                      end
+
                     when AST::Types::Name::Instance
-                      instance_type.to_class(constructor: nil)
+                      instance_type.to_module
                     else
-                      raise "Unexpected type for sclass node: #{type}"
+                      return
                     end
 
       instance_definition = case instance_type
-                            when AST::Types::Name::Class, AST::Types::Name::Module
-                              type_name = checker.factory.type_name_1(instance_type.name)
+                            when AST::Types::Name::Singleton
+                              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::Class, AST::Types::Name::Module
-                            type_name = checker.factory.type_name_1(instance_type.name)
+                          when AST::Types::Name::Singleton
+                            type_name = instance_type.name
                             checker.factory.definition_builder.build_singleton(type_name)
                           else
                             nil
@@ -638,7 +649,10 @@ module Steep
             when :__skip__
               add_typing(node, type: AST::Builtin.any_type)
             else
-              hint ||= context.lvar_env.declared_types[name]&.type
+              if !hint || hint.is_a?(AST::Types::Void)
+                hint = context.lvar_env.declared_types[name]&.type
+              end
+
               rhs_result = synthesize(rhs, hint: hint)
 
               constr = rhs_result.constr.update_lvar_env do |lvar_env|
@@ -683,8 +697,8 @@ module Steep
           yield_self do
             if self_class?(node)
               module_type = expand_alias(module_context.module_type)
-              type = if module_type.is_a?(AST::Types::Name::Class)
-                       AST::Types::Name::Class.new(name: module_type.name, constructor: method_context.constructor)
+              type = if module_type.is_a?(AST::Types::Name::Singleton)
+                       AST::Types::Name::Singleton.new(name: module_type.name)
                      else
                        module_type
                      end
@@ -699,8 +713,8 @@ module Steep
           yield_self do
             pair = if self_class?(node)
                      module_type = expand_alias(module_context.module_type)
-                     type = if module_type.is_a?(AST::Types::Name::Class)
-                              AST::Types::Name::Class.new(name: module_type.name, constructor: method_context.constructor)
+                     type = if module_type.is_a?(AST::Types::Name::Singleton)
+                              AST::Types::Name::Singleton.new(name: module_type.name)
                             else
                               module_type
                             end
@@ -744,6 +758,23 @@ module Steep
 
               constr.add_typing(node, type: type)
 
+            when :cvasgn
+              var_node = lhs.updated(:cvar)
+              send_node = rhs.updated(:send, [var_node, op, rhs])
+              new_node = node.updated(:cvasgn, [lhs.children[0], send_node])
+
+              type, constr = synthesize(new_node, hint: hint)
+
+              constr.add_typing(node, type: type)
+
+            when :send
+              new_rhs = rhs.updated(:send, [lhs, node.children[1], node.children[2]])
+              new_node = lhs.updated(:send, [lhs.children[0], :"#{lhs.children[1]}=", *lhs.children.drop(2), new_rhs])
+
+              type, constr = synthesize(new_node, hint: hint)
+
+              constr.add_typing(node, type: type)
+
             else
               Steep.logger.error("Unexpected op_asgn lhs: #{lhs.type}")
 
@@ -760,11 +791,10 @@ module Steep
                   synthesize(child)
                 end
 
-                super_method = Interface::Interface::Combination.overload(
-                  method_context.super_method.method_types.map {|method_type|
+                super_method = Interface::Interface::Entry.new(
+                  method_types: method_context.super_method.method_types.map {|method_type|
                     checker.factory.method_type(method_type, self_type: self_type)
-                  },
-                  incompatible: false
+                  }
                 )
                 args = TypeInference::SendArgs.from_nodes(node.children.dup)
 
@@ -811,7 +841,7 @@ module Steep
             new.typing.add_context_for_body(node, context: new.context)
 
             each_child_node(args_node) do |arg|
-              new.synthesize(arg)
+              _, new = new.synthesize(arg)
             end
 
             body_pair = if body_node
@@ -860,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::Module, AST::Types::Name::Class
-                           name = checker.factory.type_name_1(self_type.name)
+                         when AST::Types::Name::Singleton
+                           name = self_type.name
                            checker.factory.definition_builder.build_singleton(name)
                          end
 
@@ -999,11 +1029,17 @@ module Steep
           yield_self do
             var = node.children[0]
             type = context.lvar_env[var.name]
-            unless type
+
+            if type
+              add_typing(node, type: type)
+            else
               type = AST::Builtin.any_type
-              Steep.logger.error { "Unknown arg type: #{node}" }
+              if context&.method_context&.method_type
+                Steep.logger.error { "Unknown arg type: #{node}" }
+              end
+
+              lvasgn(node, type)
             end
-            add_typing(node, type: type)
           end
 
         when :optarg, :kwoptarg
@@ -1011,12 +1047,13 @@ module Steep
             var = node.children[0]
             rhs = node.children[1]
 
-            type = context.lvar_env[var.name]
+            var_type = context.lvar_env[var.name]
+            node_type, constr = synthesize(rhs, hint: var_type)
 
-            node_type, constr = synthesize(rhs, hint: type)
+            type = AST::Types::Union.build(types: [var_type, node_type])
 
             constr_ = constr.update_lvar_env do |env|
-              env.assign(var.name, node: node, type: node_type) do |declared_type, type, result|
+              env.assign(var.name, node: node, type: type) do |declared_type, type, result|
                 typing.add_error(
                   Errors::IncompatibleAssignment.new(node: node,
                                                      lhs_type: declared_type,
@@ -1026,7 +1063,7 @@ module Steep
               end
             end
 
-            add_typing(node, type: constr_.context.lvar_env[var.name], constr: constr_)
+            add_typing(node, type: type, constr: constr_)
           end
 
         when :restarg
@@ -1034,7 +1071,9 @@ module Steep
             var = node.children[0]
             type = context.lvar_env[var.name]
             unless type
-              Steep.logger.error { "Unknown variable: #{node}" }
+              if context&.method_context&.method_type
+                Steep.logger.error { "Unknown variable: #{node}" }
+              end
               typing.add_error Errors::FallbackAny.new(node: node)
               type = AST::Builtin::Array.instance_type(AST::Builtin.any_type)
             end
@@ -1047,7 +1086,9 @@ module Steep
             var = node.children[0]
             type = context.lvar_env[var.name]
             unless type
-              Steep.logger.error { "Unknown variable: #{node}" }
+              if context&.method_context&.method_type
+                Steep.logger.error { "Unknown variable: #{node}" }
+              end
               typing.add_error Errors::FallbackAny.new(node: node)
               type = AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type, AST::Builtin.any_type)
             end
@@ -1202,6 +1243,17 @@ module Steep
             type, constr = synthesize(node.children[0])
             constructor = constr.for_sclass(node, type)
 
+            unless constructor
+              typing.add_error(
+                Errors::UnsupportedSyntax.new(
+                  node: node,
+                  message: "sclass receiver must be instance type or singleton type, but type given `#{type}`"
+                )
+              )
+              constr.add_typing(node, type: AST::Builtin.nil_type)
+              return
+            end
+
             constructor.typing.add_context_for_node(node, context: constructor.context)
             constructor.typing.add_context_for_body(node, context: constructor.context)
 
@@ -1213,14 +1265,14 @@ module Steep
               end
             end
 
-            add_typing(node, type: AST::Builtin.nil_type)
+            constr.add_typing(node, type: AST::Builtin.nil_type)
           end
 
         when :self
           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
@@ -1233,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
@@ -1301,84 +1353,62 @@ module Steep
         when :array
           yield_self do
             if node.children.empty?
-              typing.add_error Errors::FallbackAny.new(node: node) unless hint
-
-              array_type = if hint
-                             if check_relation(sub_type: AST::Builtin::Array.instance_type(AST::Builtin.any_type),
-                                               super_type: hint).success?
-                               hint
-                             end
-                           end
-
-              add_typing(node, type: array_type || AST::Builtin::Array.instance_type(AST::Builtin.any_type))
-            else
-              is_tuple = nil
-
-              expand_alias(hint) do |hint|
-                is_tuple = hint.is_a?(AST::Types::Tuple)
-                is_tuple &&= node.children.all? {|child| child.type != :splat}
-                is_tuple &&= node.children.size >= hint.types.size
-                is_tuple &&= hint.types.map.with_index do |child_type, index|
-                  child_node = node.children[index]
-                  [synthesize(child_node, hint: child_type).type, child_type]
-                end.all? do |node_type, hint_type|
-                  result = check_relation(sub_type: node_type, super_type: hint_type)
-                  result.success?
+              if hint
+                array = AST::Builtin::Array.instance_type(AST::Builtin.any_type)
+                if check_relation(sub_type: array, super_type: hint).success?
+                  add_typing node, type: hint
+                else
+                  add_typing node, type: array
                 end
-              end
-
-              if is_tuple
-                array_type = hint
               else
-                element_hint = expand_alias(hint) do |hint|
-                  AST::Builtin::Array.instance_type?(hint) && hint.args[0]
+                typing.add_error Errors::FallbackAny.new(node: node)
+                add_typing node, type: AST::Builtin::Array.instance_type(AST::Builtin.any_type)
+              end
+            else
+              node_range = node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }
+
+              if hint && !(tuples = select_flatten_types(hint) {|type| type.is_a?(AST::Types::Tuple) }).empty?
+                tuples.each do |tuple|
+                  typing.new_child(node_range) do |child_typing|
+                    pair = with_new_typing(child_typing).try_tuple_type(node, tuple)
+                    if pair && pair.constr.check_relation(sub_type: pair.type, super_type: hint).success?
+                      child_typing.save!
+                      return pair.with(constr: pair.constr.with_new_typing(typing))
+                    end
+                  end
                 end
+              end
 
-                element_types = node.children.flat_map do |e|
-                  if e.type == :splat
-                    Steep.logger.info "Typing of splat in array is incompatible with Ruby; it does not use #to_a method"
-                    synthesize(e.children.first).type.yield_self do |type|
-                      expand_alias(type) do |ty|
-                        case ty
-                        when AST::Types::Union
-                          ty.types
-                        else
-                          [ty]
-                        end
-                      end
-                    end.map do |type|
-                      case
-                      when AST::Builtin::Array.instance_type?(type)
-                        type.args.first
-                      when AST::Builtin::Range.instance_type?(type)
-                        type.args.first
-                      else
-                        type
-                      end
+              if hint && !(arrays = select_flatten_types(hint) {|type| AST::Builtin::Array.instance_type?(type) }).empty?
+                arrays.each do |array|
+                  typing.new_child(node_range) do |child_typing|
+                    pair = with_new_typing(child_typing).try_array_type(node, array)
+                    if pair.constr.check_relation(sub_type: pair.type, super_type: hint).success?
+                      child_typing.save!
+                      return pair.with(constr: pair.constr.with_new_typing(typing))
                     end
-                  else
-                    [select_super_type(synthesize(e, hint: element_hint).type, element_hint)]
                   end
                 end
-                array_type = AST::Builtin::Array.instance_type(AST::Types::Union.build(types: element_types))
               end
 
-              add_typing(node, type: array_type)
+              try_array_type(node, nil)
             end
           end
 
         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)
@@ -1400,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)
 
@@ -1428,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
@@ -1483,90 +1511,109 @@ 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)
+                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
+
+                body_constr = when_constr.update_lvar_env {|env| env.except(cond_vars).join(*test_envs) }
+
+                if body
+                  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: body_constr)
+                end
+
+                when_constr = test_constr
               end
 
-              if body
-                if var_names && var_types && test_types.all? {|ty| ty.is_a?(AST::Types::Name::Class) }
-                  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
-                  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)
 
-                  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
+                branch_pairs << when_constr.synthesize(els, hint: hint)
+              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
+              types = branch_pairs.map(&:type)
+              constrs = branch_pairs.map(&:constr)
 
-                  branch_pairs << clause_constr
-                                    .for_branch(body, type_case_override: type_case_override)
-                                    .synthesize(body, hint: hint)
-                else
-                  branch_pairs << clause_constr.synthesize(body, hint: hint)
+              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
-                branch_pairs << Pair.new(type: AST::Builtin.nil_type, constr: clause_constr)
+                unless els
+                  types << AST::Builtin.nil_type
+                end
               end
-            end
+            else
+              branch_pairs = []
+
+              when_constr = constr
 
-            if els
-              if var_names && var_types
-                if var_types.empty?
-                  typing.add_error Errors::ElseOnExhaustiveCase.new(node: node, type: cond_type)
+              whens.each do |clause|
+                *tests, body = clause.children
+
+                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
 
-                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
+                clause_constr = when_constr.update_lvar_env {|env| env.join(*test_envs) }
+                when_constr = test_constr
+
+                if body
+                  branch_pairs << clause_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)
                 end
-                branch_pairs << constr
-                                  .for_branch(els, type_case_override: else_override)
-                                  .synthesize(els, hint: hint)
-              else
-                branch_pairs << constr.synthesize(els, hint: hint)
               end
-            end
 
-            types = branch_pairs.map(&:type)
-            constrs = branch_pairs.map(&:constr)
+              if els
+                branch_pairs << when_constr.synthesize(els, hint: hint)
+              end
+
+              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|
@@ -1579,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|
@@ -1617,7 +1664,7 @@ module Steep
                 instance_types = exn_types.map do |type|
                   type = expand_alias(type)
                   case
-                  when type.is_a?(AST::Types::Name::Class)
+                  when type.is_a?(AST::Types::Name::Singleton)
                     to_instance_type(type)
                   else
                     AST::Builtin.any_type
@@ -1631,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
@@ -1641,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) })
@@ -1657,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
 
@@ -1672,19 +1719,62 @@ module Steep
         when :masgn
           type_masgn(node)
 
+        when :for
+          yield_self do
+            asgn, collection, body = node.children
+
+            collection_type, constr = synthesize(collection)
+            collection_type = expand_self(collection_type)
+
+            var_type = case collection_type
+                       when AST::Types::Any
+                         AST::Types::Any.new
+                       else
+                         each = checker.factory.interface(collection_type, private: true).methods[:each]
+                         method_type = (each&.method_types || []).find {|type| type.block && type.block.type.params.first_param }
+                         method_type&.yield_self do |method_type|
+                           method_type.block.type.params.first_param&.type
+                         end
+                       end
+
+            if var_type
+              if body
+                body_constr = constr.with_updated_context(
+                  lvar_env: constr.context.lvar_env.assign(asgn.children[0].name, node: asgn, type: var_type)
+                )
+
+                typing.add_context_for_body(node, context: body_constr.context)
+                _, _, body_context = body_constr.synthesize(body)
+
+                constr = constr.update_lvar_env {|env| env.join(constr.context.lvar_env, body_context.lvar_env) }
+              else
+                constr = self
+              end
+
+              add_typing(node, type: collection_type, constr: constr)
+            else
+              fallback_to_any(node) do
+                Errors::NoMethod.new(
+                  node: node,
+                  method: :each,
+                  type: collection_type
+                )
+              end
+            end
+          end
         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
@@ -1733,9 +1823,22 @@ module Steep
           end
 
         when :irange, :erange
-          types = node.children.map {|n| synthesize(n).type }
-          type = AST::Builtin::Range.instance_type(union_type(*types))
-          add_typing(node, type: type)
+          begin_node, end_node = node.children
+
+          constr = self
+          begin_type, constr = if begin_node
+                                 constr.synthesize(begin_node)
+                               else
+                                 [AST::Builtin.nil_type, constr]
+                               end
+          end_type, constr = if end_node
+                               constr.synthesize(end_node)
+                             else
+                               [AST::Builtin.nil_type, constr]
+                             end
+
+          type = AST::Builtin::Range.instance_type(union_type(begin_type, end_type))
+          add_typing(node, type: type, constr: constr)
 
         when :regexp
           each_child_node(node) do |child|
@@ -1753,9 +1856,36 @@ module Steep
 
         when :or_asgn, :and_asgn
           yield_self do
-            _, rhs = node.children
-            rhs_type = synthesize(rhs).type
-            add_typing(node, type: rhs_type)
+            asgn, rhs = node.children
+
+            case asgn.type
+            when :lvasgn
+              type, constr = synthesize(rhs, hint: hint)
+              constr.lvasgn(asgn, type)
+            when :ivasgn
+              type, constr = synthesize(rhs, hint: hint)
+              constr.ivasgn(asgn, type)
+            when :send
+              rhs_ = node.updated(:send,
+                                  [
+                                    asgn.children[0],
+                                    :"#{asgn.children[1]}=",
+                                    asgn.children[2],
+                                    rhs
+                                  ])
+              node_type = case node.type
+                          when :or_asgn
+                            :or
+                          when :and_asgn
+                            :and
+                          end
+              node_ = node.updated(node_type, [asgn, rhs_])
+
+              synthesize(node_, hint: hint)
+            else
+              Steep.logger.error { "#{node.type} with #{asgn.type} lhs is not supported"}
+              fallback_to_any(node)
+            end
           end
 
         when :defined?
@@ -1802,8 +1932,8 @@ module Steep
                 param_type = hint.params.required[0]
                 interface = checker.factory.interface(param_type, private: true)
                 method = interface.methods[value.children[0]]
-                if method&.overload?
-                  return_types = method.types.select {|method_type|
+                if method
+                  return_types = method.method_types.select {|method_type|
                     method_type.params.each_type.count == 0
                   }.map(&:return_type)
 
@@ -1831,9 +1961,50 @@ module Steep
             add_typing node, type: AST::Builtin.any_type
           end
 
-        when :splat, :sclass, :alias
+        when :cvasgn
+          name, rhs = node.children
+
+          type, constr = synthesize(rhs, hint: hint)
+
+          var_type = if module_context&.class_variables
+                       module_context.class_variables[name]&.yield_self {|ty| checker.factory.type(ty) }
+                     end
+
+          if var_type
+            result = constr.check_relation(sub_type: type, super_type: var_type)
+
+            if result.success?
+              add_typing node, type: type, constr: constr
+            else
+              fallback_to_any node do
+                Errors::IncompatibleAssignment.new(node: node,
+                                                   lhs_type: var_type,
+                                                   rhs_type: type,
+                                                   result: result)
+              end
+            end
+          else
+            fallback_to_any(node)
+          end
+
+        when :cvar
+          name = node.children[0]
+          var_type = if module_context&.class_variables
+                       module_context.class_variables[name]&.yield_self {|ty| checker.factory.type(ty) }
+                     end
+
+          if var_type
+            add_typing node, type: var_type
+          else
+            fallback_to_any node
+          end
+
+        when :alias
+          add_typing node, type: AST::Builtin.nil_type
+
+        when :splat
           yield_self do
-            Steep.logger.error "Unsupported node #{node.type} (#{node.location.expression.source_buffer.name}:#{node.location.expression.line})"
+            Steep.logger.warn { "Unsupported node #{node.type} (#{node.location.expression.source_buffer.name}:#{node.location.expression.line})" }
 
             each_child_node node do |child|
               synthesize(child)
@@ -1842,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}" }
@@ -1883,136 +2064,202 @@ module Steep
       add_typing(node, type: ivar_type)
     end
 
+    def masgn_lhs?(lhs)
+      lhs.children.all? do |a|
+        asgn_type = if a.type == :splat
+                      a.children[0].type
+                    else
+                      a.type
+                    end
+        asgn_type == :lvasgn || asgn_type == :ivasgn
+      end
+    end
+
+    def lvasgn(node, type)
+      name = node.children[0].name
+      env = context.lvar_env.assign(name, node: node, type: type) do |declared_type, type, result|
+        typing.add_error(
+          Errors::IncompatibleAssignment.new(node: node,
+                                             lhs_type: declared_type,
+                                             rhs_type: type,
+                                             result: result)
+        )
+      end
+
+      add_typing(node, type: type, constr: with_updated_context(lvar_env: env))
+    end
+
+    def ivasgn(node, type)
+      ivar = node.children[0]
+
+      type_env.assign(ivar: ivar, type: type, self_type: self_type) do |error|
+        case error
+        when Subtyping::Result::Failure
+          var_type = type_env.get(ivar: ivar)
+          typing.add_error(Errors::IncompatibleAssignment.new(node: node,
+                                                              lhs_type: var_type,
+                                                              rhs_type: type,
+                                                              result: error))
+        when nil
+          fallback_to_any node
+        end
+      end
+
+      add_typing(node, type: type)
+    end
+
     def type_masgn(node)
       lhs, rhs = node.children
       rhs_pair = synthesize(rhs)
-      rhs_type = expand_alias(rhs_pair.type)
+      rhs_type = deep_expand_alias(rhs_pair.type)
 
       constr = rhs_pair.constr
 
-      if lhs.children.all? {|a| a.type == :lvasgn || a.type == :ivasgn}
-        case
-        when rhs.type == :array && lhs.children.size == rhs.children.size
-          # a, @b = x, y
+      unless masgn_lhs?(lhs)
+        Steep.logger.error("Unsupported masgn lhs node: only lvasgn, ivasgn, and splat are supported")
+        _, constr = constr.fallback_to_any(lhs)
+        return add_typing(node, type: rhs_type, constr: constr)
+      end
 
-          constr = lhs.children.zip(rhs.children).inject(constr) do |ctr, (lhs, rhs)|
-            case lhs.type
-            when :lvasgn
-              name = lhs.children[0].name
-              type = typing.type_of(node: rhs)
-              env = ctr.context.lvar_env.assign(name, node: node, type: type) do |declared_type, type, result|
-                typing.add_error(
-                  Errors::IncompatibleAssignment.new(node: lhs,
-                                                     lhs_type: declared_type,
-                                                     rhs_type: type,
-                                                     result: result)
-                )
-              end
-              add_typing(lhs,
-                         type: type,
-                         constr: ctr.with_updated_context(lvar_env: env))
-            when :ivasgn
-              type_ivasgn(lhs.children.first, rhs, lhs)
-              constr
-            end
+      falseys, truthys = partition_flatten_types(rhs_type) do |type|
+        type.is_a?(AST::Types::Nil) || (type.is_a?(AST::Types::Literal) && type.value == false)
+      end
+
+      unwrap_rhs_type = AST::Types::Union.build(types: truthys)
+
+      case
+      when unwrap_rhs_type.is_a?(AST::Types::Tuple) || (rhs.type == :array && rhs.children.none? {|n| n.type == :splat })
+        tuple_types = if unwrap_rhs_type.is_a?(AST::Types::Tuple)
+                        unwrap_rhs_type.types.dup
+                      else
+                        rhs.children.map do |node|
+                          typing.type_of(node: node)
+                        end
+                      end
+
+        assignment_nodes = lhs.children.dup
+        leading_assignments = []
+        trailing_assignments = []
+
+        until assignment_nodes.empty?
+          cursor = assignment_nodes.first
+
+          if cursor.type == :splat
+            break
+          else
+            leading_assignments << assignment_nodes.shift
           end
+        end
 
-          add_typing(node, type: rhs_type, constr: constr)
+        until assignment_nodes.empty?
+          cursor = assignment_nodes.last
 
-        when rhs_type.is_a?(AST::Types::Tuple)
-          # a, @b = tuple
+          if cursor.type == :splat
+            break
+          else
+            trailing_assignments.unshift assignment_nodes.pop
+          end
+        end
 
-          constr = lhs.children.zip(rhs_type.types).inject(constr) do |ctr, (lhs, type)|
-            ty = type || AST::Builtin.nil_type
+        leading_assignments.each do |asgn|
+          type = tuple_types.first
 
-            case lhs.type
-            when :lvasgn
-              name = lhs.children[0].name
-              env = ctr.context.lvar_env.assign(name, node: node, type: ty) do |declared_type, type, result|
-                typing.add_error(
-                  Errors::IncompatibleAssignment.new(node: lhs,
-                                                     lhs_type: declared_type,
-                                                     rhs_type: type,
-                                                     result: result)
-                )
-              end
-              add_typing(lhs,
-                         type: ty,
-                         constr: ctr.with_updated_context(lvar_env: env)).constr
-            when :ivasgn
-              ivar = lhs.children[0]
+          if type
+            tuple_types.shift
+          else
+            type = AST::Builtin.nil_type
+          end
 
-              type_env.assign(ivar: ivar, type: ty, self_type: self_type) do |error|
-                case error
-                when Subtyping::Result::Failure
-                  ivar_type = type_env.get(ivar: ivar)
-                  typing.add_error(Errors::IncompatibleAssignment.new(node: lhs,
-                                                                      lhs_type: ivar_type,
-                                                                      rhs_type: ty,
-                                                                      result: error))
-                when nil
-                  fallback_to_any node
-                end
-              end
+          case asgn.type
+          when :lvasgn
+            _, constr = constr.lvasgn(asgn, type)
+          when :ivasgn
+            _, constr = constr.ivasgn(asgn, type)
+          end
+        end
 
-              ctr
-            end
+        trailing_assignments.reverse_each do |asgn|
+          type = tuple_types.last
+
+          if type
+            tuple_types.pop
+          else
+            type = AST::Builtin.nil_type
           end
 
-          add_typing(node, type: rhs_type, constr: constr)
+          case asgn.type
+          when :lvasgn
+            _, constr = constr.lvasgn(asgn, type)
+          when :ivasgn
+            _, constr = constr.ivasgn(asgn, type)
+          end
+        end
 
-        when AST::Builtin::Array.instance_type?(rhs_type)
-          element_type = AST::Types::Union.build(types: [rhs_type.args.first, AST::Builtin.nil_type])
+        element_type = if tuple_types.empty?
+                         AST::Builtin.nil_type
+                       else
+                         AST::Types::Union.build(types: tuple_types)
+                       end
+        array_type = AST::Builtin::Array.instance_type(element_type)
 
-          constr = lhs.children.inject(constr) do |ctr, assignment|
-            case assignment.type
+        assignment_nodes.each do |asgn|
+          case asgn.type
+          when :splat
+            case asgn.children[0].type
             when :lvasgn
-              name = assignment.children[0].name
-              env = ctr.context.lvar_env.assign(name, node: node, type: element_type) do |declared_type, type, result|
-                typing.add_error(
-                  Errors::IncompatibleAssignment.new(node: assignment,
-                                                     lhs_type: declared_type,
-                                                     rhs_type: type,
-                                                     result: result)
-                )
-              end
+              _, constr = constr.lvasgn(asgn.children[0], array_type)
+            when :ivasgn
+              _, constr = constr.ivasgn(asgn.children[0], array_type)
+            end
+          when :lvasgn
+            _, constr = constr.lvasgn(asgn, element_type)
+          when :ivasgn
+            _,constr = constr.ivasgn(asgn, element_type)
+          end
+        end
 
-              add_typing(assignment,
-                         type: element_type,
-                         constr: ctr.with_updated_context(lvar_env: env)).constr
+        unless falseys.empty?
+          constr = constr.update_lvar_env {|lvar_env| self.context.lvar_env.join(lvar_env, self.context.lvar_env)}
+        end
 
-            when :ivasgn
-              ivar = assignment.children[0]
+        add_typing(node, type: rhs_type, constr: constr)
 
-              type_env.assign(ivar: ivar, type: element_type, self_type: self_type) do |error|
-                case error
-                when Subtyping::Result::Failure
-                  type = type_env.get(ivar: ivar)
-                  typing.add_error(Errors::IncompatibleAssignment.new(node: assignment,
-                                                                      lhs_type: type,
-                                                                      rhs_type: element_type,
-                                                                      result: error))
-                when nil
-                  fallback_to_any node
-                end
-              end
+      when flatten_union(unwrap_rhs_type).all? {|type| AST::Builtin::Array.instance_type?(type) }
+        array_elements = flatten_union(unwrap_rhs_type).map {|type| type.args[0] }
+        element_type = AST::Types::Union.build(types: array_elements + [AST::Builtin.nil_type])
+
+        constr = lhs.children.inject(constr) do |constr, assignment|
+          case assignment.type
+          when :lvasgn
+            _, constr = constr.lvasgn(assignment, element_type)
 
-              ctr
+          when :ivasgn
+            _, constr = constr.ivasgn(assignment, element_type)
+          when :splat
+            case assignment.children[0].type
+            when :lvasgn
+              _, constr = constr.lvasgn(assignment.children[0], unwrap_rhs_type)
+            when :ivasgn
+              _, constr = constr.ivasgn(assignment.children[0], unwrap_rhs_type)
+            else
+              raise
             end
           end
 
-          add_typing node, type: rhs_type, constr: constr
-
-        when rhs_type.is_a?(AST::Types::Any)
-          fallback_to_any(node)
+          constr
+        end
 
-        else
-          Steep.logger.error("Unsupported masgn: #{rhs.type} (#{rhs_type})")
-          fallback_to_any(node)
+        unless falseys.empty?
+          constr = constr.update_lvar_env {|lvar_env| self.context.lvar_env.join(lvar_env, self.context.lvar_env)}
         end
+
+        add_typing(node, type: rhs_type, constr: constr)
       else
-        Steep.logger.error("Unsupported masgn left hand side")
-        fallback_to_any(node)
+        unless rhs_type.is_a?(AST::Types::Any)
+          Steep.logger.error("Unsupported masgn rhs type: array or tuple is supported (#{rhs_type})")
+        end
+        _, constr = constr.fallback_to_any(lhs)
+        add_typing(node, type: rhs_type, constr: constr)
       end
     end
 
@@ -2040,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)
@@ -2048,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.error "`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
+
+                           fallback_to_any node do
+                             Errors::NoMethod.new(node: node, method: method_name, type: expanded_receiver_type)
+                           end
+                         end
+                       end
+                     end
 
-      case pair.type
+      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
@@ -2137,7 +2390,7 @@ module Steep
           end
         end
       else
-        pair
+        Pair.new(type: type, constr: constr)
       end
     end
 
@@ -2204,139 +2457,68 @@ module Steep
     def type_method_call(node, method_name:, receiver_type:, method:, args:, block_params:, block_body:, topdown_hint:)
       node_range = node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }
 
-      case
-      when method.union?
-        yield_self do
-          results = method.types.map do |method|
+      results = method.method_types.flat_map do |method_type|
+        Steep.logger.tagged method_type.to_s do
+          zips = args.zips(method_type.params, method_type.block&.type)
+
+          zips.map do |arg_pairs|
             typing.new_child(node_range) do |child_typing|
-              with_new_typing(child_typing).type_method_call(node,
-                                                             method_name: method_name,
-                                                             receiver_type: receiver_type,
-                                                             method: method,
-                                                             args: args,
-                                                             block_params: block_params,
-                                                             block_body: block_body,
-                                                             topdown_hint: false)
-            end
-          end
+              ret = self.with_new_typing(child_typing).try_method_type(
+                node,
+                receiver_type: receiver_type,
+                method_type: method_type,
+                args: args,
+                arg_pairs: arg_pairs,
+                block_params: block_params,
+                block_body: block_body,
+                child_typing: child_typing,
+                topdown_hint: topdown_hint
+              )
 
-          if (type, constr, error = results.find {|_, _, error| error })
-            constr.typing.save!
-            [type,
-             update_lvar_env { constr.context.lvar_env },
-             error]
-          else
-            types = results.map(&:first)
+              raise unless ret.is_a?(Array) && ret[1].is_a?(TypeConstruction)
 
-            _, constr, _ = results.first
-            constr.typing.save!
+              result, constr = ret
 
-            [union_type(*types),
-             update_lvar_env { constr.context.lvar_env },
-             nil]
+              [result, constr, method_type]
+            end
           end
         end
+      end
 
-      when method.intersection?
-        yield_self do
-          results = method.types.map do |method|
-            typing.new_child(node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }) do |child_typing|
-              with_new_typing(child_typing).type_method_call(node,
+      unless results.empty?
+        result, constr, method_type = results.find {|result, _, _| !result.is_a?(Errors::Base) } || results.last
+      else
+        method_type = method.method_types.last
+        constr = self.with_new_typing(typing.new_child(node_range))
+        result = Errors::IncompatibleArguments.new(node: node, receiver_type: receiver_type, method_type: method_type)
+      end
+      constr.typing.save!
+
+      case result
+      when Errors::Base
+        if method.method_types.size == 1
+          typing.add_error result
+          type = case method_type.return_type
+                 when AST::Types::Var
+                   AST::Builtin.any_type
+                 else
+                   method_type.return_type
+                 end
+        else
+          typing.add_error Errors::UnresolvedOverloading.new(node: node,
+                                                             receiver_type: expand_self(receiver_type),
                                                              method_name: method_name,
-                                                             receiver_type: receiver_type,
-                                                             method: method,
-                                                             args: args,
-                                                             block_params: block_params,
-                                                             block_body: block_body,
-                                                             topdown_hint: false)
-            end
-          end
-
-          successes = results.reject {|_, _, error| error }
-          unless successes.empty?
-            types = successes.map(&:first)
-            constr = successes[0][1]
-            constr.typing.save!
-
-            [AST::Types::Intersection.build(types: types),
-             update_lvar_env { constr.context.lvar_env },
-             nil]
-          else
-            type, constr, error = results.first
-            constr.typing.save!
-
-            [type,
-             update_lvar_env { constr.context.lvar_env },
-             error]
-          end
+                                                             method_types: method.method_types)
+          type = AST::Builtin.any_type
         end
 
-      when method.overload?
-        yield_self do
-          results = method.types.flat_map do |method_type|
-            Steep.logger.tagged method_type.to_s do
-              zips = args.zips(method_type.params, method_type.block&.type)
-
-              zips.map do |arg_pairs|
-                typing.new_child(node_range) do |child_typing|
-                  ret = self.with_new_typing(child_typing).try_method_type(
-                    node,
-                    receiver_type: receiver_type,
-                    method_type: method_type,
-                    args: args,
-                    arg_pairs: arg_pairs,
-                    block_params: block_params,
-                    block_body: block_body,
-                    child_typing: child_typing,
-                    topdown_hint: topdown_hint
-                  )
-
-                  raise unless ret.is_a?(Array) && ret[1].is_a?(TypeConstruction)
-
-                  result, constr = ret
-
-                  [result, constr, method_type]
-                end
-              end
-            end
-          end
-
-          unless results.empty?
-            result, constr, method_type = results.find {|result, _, _| !result.is_a?(Errors::Base) } || results.last
-          else
-            method_type = method.types.last
-            constr = self.with_new_typing(typing.new_child(node_range))
-            result = Errors::IncompatibleArguments.new(node: node, receiver_type: receiver_type, method_type: method_type)
-          end
-          constr.typing.save!
-
-          case result
-          when Errors::Base
-            if method.types.size == 1
-              typing.add_error result
-              type = case method_type.return_type
-                     when AST::Types::Var
-                       AST::Builtin.any_type
-                     else
-                       method_type.return_type
-                     end
-            else
-              typing.add_error Errors::UnresolvedOverloading.new(node: node,
-                                                                 receiver_type: expand_self(receiver_type),
-                                                                 method_name: method_name,
-                                                                 method_types: method.types)
-              type = AST::Builtin.any_type
-            end
-
-            [type,
-             update_lvar_env { constr.context.lvar_env },
-             result]
-          else # Type
-            [result,
-             update_lvar_env { constr.context.lvar_env },
-             nil]
-          end
-        end
+        [type,
+         update_lvar_env { constr.context.lvar_env },
+         result]
+      else # Type
+        [result,
+         update_lvar_env { constr.context.lvar_env },
+         nil]
       end
     end
 
@@ -2523,16 +2705,40 @@ module Steep
         if block_params && method_type.block
           block_annotations = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
           block_params_ = TypeInference::BlockParams.from_node(block_params, annotations: block_annotations)
-          block_param_hint = block_params_.params_type(
-            hint: topdown_hint ? method_type.block.type.params : nil
-          )
 
-          check_relation(sub_type: AST::Types::Proc.new(params: block_param_hint, return_type: AST::Types::Any.new),
-                         super_type: method_type.block.type,
-                         constraints: constraints).else do |result|
-            return [Errors::IncompatibleBlockParameters.new(node: node,
-                                                            method_type: method_type),
-                    constr]
+          unless block_params_
+            return [
+              Errors::UnsupportedSyntax.new(
+                node: block_params,
+                message: "Unsupported block params pattern, probably masgn?"
+              ),
+              constr
+            ]
+          end
+
+          pairs = block_params_.zip(method_type.block.type.params)
+
+          unless pairs
+            return [
+              Errors::IncompatibleBlockParameters.new(node: node, method_type: method_type),
+              constr
+            ]
+          end
+
+          pairs.each do |param, type|
+            if param.type
+              check_relation(sub_type: type, super_type: param.type, constraints: constraints).else do |result|
+                return [
+                  Errors::IncompatibleAssignment.new(
+                    node: param.node,
+                    lhs_type: param.type,
+                    rhs_type: type,
+                    result: result
+                  ),
+                  constr
+                ]
+              end
+            end
           end
         end
 
@@ -2683,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
@@ -2826,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
@@ -2835,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
@@ -2853,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
@@ -3001,20 +3207,31 @@ module Steep
       end
     end
 
-    def deep_expand_alias(type, recursive: Set.new, &block)
-      raise "Recursive type definition: #{type}" if recursive.member?(type)
+    def deep_expand_alias(type, &block)
+      checker.factory.deep_expand_alias(type, &block)
+    end
 
-      ty = case type
-           when AST::Types::Name::Alias
-             deep_expand_alias(expand_alias(type), recursive: recursive << type)
-           else
-             type
-           end
+    def flatten_union(type)
+      checker.factory.flatten_union(type)
+    end
 
-      if block_given?
-        yield ty
-      else
-        ty
+    def select_flatten_types(type, &block)
+      types = flatten_union(deep_expand_alias(type))
+      types.select(&block)
+    end
+
+    def partition_flatten_types(type, &block)
+      types = flatten_union(deep_expand_alias(type))
+      types.partition(&block)
+    end
+
+    def flatten_array_elements(type)
+      flatten_union(deep_expand_alias(type)).flat_map do |type|
+        if AST::Builtin::Array.instance_type?(type)
+          type.args
+        else
+          [type]
+        end
       end
     end
 
@@ -3056,8 +3273,8 @@ module Steep
 
     def to_instance_type(type, args: nil)
       args = args || case type
-                     when AST::Types::Name::Class, AST::Types::Name::Module
-                       checker.factory.env.class_decls[checker.factory.type_name_1(type.name)].type_params.each.map { AST::Builtin.any_type }
+                     when AST::Types::Name::Singleton
+                       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
@@ -3065,6 +3282,47 @@ module Steep
       AST::Types::Name::Instance.new(name: type.name, args: args)
     end
 
+    def try_tuple_type(node, hint)
+      if node.children.size != hint.types.size
+        return
+      end
+
+      constr = self
+      element_types = []
+
+      each_child_node(node).with_index do |child, index|
+        type, constr = constr.synthesize(child, hint: hint.types[index])
+        element_types << type
+      end
+
+      constr.add_typing(node, type: AST::Types::Tuple.new(types: element_types))
+    end
+
+    def try_array_type(node, hint)
+      element_hint = hint ? hint.args[0] : nil
+
+      constr = self
+      element_types = []
+
+      each_child_node(node) do |child|
+        case child.type
+        when :splat
+          type, constr = constr.synthesize(child.children[0], hint: hint)
+          if AST::Builtin::Array.instance_type?(type)
+            element_types << type.args[0]
+          else
+            element_types.push(*flatten_array_elements(type))
+          end
+        else
+          type, constr = constr.synthesize(child, hint: element_hint)
+          element_types << type
+        end
+      end
+
+      element_type = AST::Types::Union.build(types: element_types)
+      constr.add_typing(node, type: AST::Builtin::Array.instance_type(element_type))
+    end
+
     def try_hash_type(node, hint)
       case hint
       when AST::Types::Record