steep 0.14.0 → 0.15.0

data/lib/steep/type_construction.rb

@@ -1,5 +1,38 @@
 module Steep
   class TypeConstruction
+    class Pair
+      attr_reader :type
+      attr_reader :constr
+
+      def initialize(type:, constr:)
+        @type = type
+        @constr = constr
+      end
+
+      def with(type: self.type, constr: self.constr)
+        self.class.new(
+          type: type,
+          constr: constr
+        )
+      end
+
+      def +(other)
+        if type.is_a?(AST::Types::Bot)
+          other.with(type: type)
+        else
+          other
+        end
+      end
+
+      def context
+        constr.context
+      end
+
+      def to_ary
+        [type, constr, context]
+      end
+    end
+
     attr_reader :checker
     attr_reader :source
     attr_reader :annotations
@@ -50,6 +83,36 @@ module Steep
       )
     end
 
+    def with_updated_context(lvar_env: self.context.lvar_env)
+      if lvar_env != self.context.lvar_env
+        with(context: self.context.with(lvar_env: lvar_env))
+      else
+        self
+      end
+    end
+
+    def with(annotations: self.annotations, context: self.context, typing: self.typing)
+      if context != self.context || typing != self.typing
+        self.class.new(
+          checker: checker,
+          source: source,
+          annotations: annotations,
+          typing: typing,
+          context: context
+        )
+      else
+        self
+      end
+    end
+
+    def update_context()
+      with(context: yield(self.context))
+    end
+
+    def update_lvar_env
+      with_updated_context(lvar_env: yield(context.lvar_env))
+    end
+
     def check_relation(sub_type:, super_type:, constraints: Subtyping::Constraints.empty)
       checker.check(Subtyping::Relation.new(sub_type: sub_type, super_type: super_type), self_type: self_type, constraints: constraints)
     end
@@ -100,7 +163,7 @@ module Steep
                        else
                          method_type.block.type
                        end
-          var_types[block_arg.children[0].name] = block_type
+          var_types[block_arg.children[0]] = block_type
         end
       end
 
@@ -123,12 +186,6 @@ module Steep
         super_method: super_method
       )
 
-      if var_types
-        var_types.each do |name, type|
-          type_env.set(lvar: name, type: type)
-        end
-      end
-
       if definition
         definition.instance_variables.each do |name, decl|
           type_env.set(ivar: name, type: checker.factory.type(decl.type))
@@ -136,12 +193,27 @@ module Steep
       end
 
       type_env = type_env.with_annotations(
-        lvar_types: annots.lvar_types,
         ivar_types: annots.ivar_types,
         const_types: annots.const_types,
         self_type: annots.self_type || self_type
       )
 
+      lvar_env = TypeInference::LocalVariableTypeEnv.empty(
+        subtyping: checker,
+        self_type: annots.self_type || self_type
+      )
+
+      if var_types
+        lvar_env = lvar_env.update(
+          assigned_types: var_types.each.with_object({}) {|(var, type), hash|
+            arg_node = args.find {|arg| arg.children[0] == var }
+            hash[var.name] = TypeInference::LocalVariableTypeEnv::Entry.new(type: type, nodes: [arg_node].compact)
+          }
+        )
+      end
+
+      lvar_env = lvar_env.annotate(annots)
+
       self.class.new(
         checker: checker,
         source: source,
@@ -152,7 +224,8 @@ module Steep
           block_context: nil,
           break_context: nil,
           self_type: annots.self_type || self_type,
-          type_env: type_env
+          type_env: type_env,
+          lvar_env: lvar_env
         ),
         typing: typing,
       )
@@ -242,6 +315,11 @@ module Steep
                                                      const_env: module_const_env,
                                                      signatures: checker.factory.env)
 
+      lvar_env = TypeInference::LocalVariableTypeEnv.empty(
+        subtyping: checker,
+        self_type: module_context_.module_type
+      ).annotate(annots)
+
       self.class.new(
         checker: checker,
         source: source,
@@ -253,7 +331,8 @@ module Steep
           break_context: nil,
           module_context: module_context_,
           self_type: module_context_.module_type,
-          type_env: module_type_env
+          type_env: module_type_env,
+          lvar_env: lvar_env
         )
       )
     end
@@ -341,51 +420,90 @@ module Steep
                                                     const_env: class_const_env,
                                                     signatures: checker.factory.env)
 
+      lvar_env = TypeInference::LocalVariableTypeEnv.empty(
+        subtyping: checker,
+        self_type: module_context.module_type
+      ).annotate(annots)
+
+      class_body_context = TypeInference::Context.new(
+        method_context: nil,
+        block_context: nil,
+        module_context: module_context,
+        break_context: nil,
+        self_type: module_context.module_type,
+        type_env: class_type_env,
+        lvar_env: lvar_env
+      )
 
       self.class.new(
         checker: checker,
         source: source,
         annotations: annots,
         typing: typing,
-        context: TypeInference::Context.new(
-          method_context: nil,
-          block_context: nil,
-          module_context: module_context,
-          break_context: nil,
-          self_type: module_context.module_type,
-          type_env: class_type_env
-        )
+        context: class_body_context
       )
     end
 
     def for_branch(node, truthy_vars: Set.new, type_case_override: nil, break_context: context.break_context)
       annots = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
 
-      lvar_types = self.type_env.lvar_types.each.with_object({}) do |(var, type), env|
-        if truthy_vars.member?(var)
-          env[var] = unwrap(type)
-        else
-          env[var] = type
+      lvar_env = context.lvar_env
+
+      unless truthy_vars.empty?
+        lvar_env = lvar_env.yield_self do |env|
+          decls = env.declared_types.each.with_object({}) do |(name, entry), hash|
+            if truthy_vars.include?(name)
+              hash[name] = entry.update(type: unwrap(entry.type))
+            else
+              hash[name] = entry
+            end
+          end
+
+          assignments = env.assigned_types.each.with_object({}) do |(name, entry), hash|
+            if truthy_vars.include?(name)
+              hash[name] = entry.update(type: unwrap(entry.type))
+            else
+              hash[name] = entry
+            end
+          end
+
+          env.update(declared_types: decls, assigned_types: assignments)
         end
       end
 
-      type_env = self.type_env.with_annotations(lvar_types: lvar_types, self_type: self_type) do |var, relation, result|
-        raise "Unexpected annotate failure: #{relation}"
+      if type_case_override
+        lvar_env = type_case_override.inject(lvar_env) do |lvar_env, (name, type)|
+          lvar_env.assign!(name, node: node, type: type) do |declared_type, assigned_type, result|
+            relation = Subtyping::Relation.new(sub_type: assigned_type, super_type: declared_type)
+            typing.add_error(
+              Errors::IncompatibleTypeCase.new(
+                node: node,
+                var_name: name,
+                relation: relation,
+                result: result
+              )
+            )
+          end
+        end
       end
 
-      if type_case_override
-        type_env = type_env.with_annotations(lvar_types: type_case_override, self_type: self_type) do |var, relation, result|
-          typing.add_error(
-            Errors::IncompatibleTypeCase.new(node: node,
+      lvar_env = lvar_env.annotate(annots) do |var, outer_type, inner_type, result|
+        relation = Subtyping::Relation.new(sub_type: inner_type, super_type: outer_type)
+        typing.add_error(
+          Errors::IncompatibleAnnotation.new(node: node,
                                              var_name: var,
                                              relation: relation,
                                              result: result)
-          )
-        end
+        )
+      end
+
+      type_env = context.type_env
+
+      if type_case_override
+        type_env = type_env.with_annotations(self_type: self_type)
       end
 
       type_env = type_env.with_annotations(
-        lvar_types: annots.lvar_types,
         ivar_types: annots.ivar_types,
         const_types: annots.const_types,
         gvar_types: {},
@@ -399,19 +517,18 @@ module Steep
         )
       end
 
-      with(context: context.with(type_env: type_env, break_context: break_context))
+      update_context {|context|
+        context.with(type_env: type_env,
+                     break_context: break_context,
+                     lvar_env: lvar_env)
+      }
     end
 
-    NOTHING = ::Object.new
+    def add_typing(node, type:, constr: self)
+      raise if constr.typing != self.typing
 
-    def with(annotations: NOTHING, context: NOTHING)
-      self.class.new(
-        checker: checker,
-        source: source,
-        annotations: annotations.equal?(NOTHING) ? self.annotations : annotations,
-        typing: typing,
-        context: context.equal?(NOTHING) ? self.context : context
-      )
+      typing.add_typing(node, type, nil)
+      Pair.new(type: type, constr: constr)
     end
 
     def synthesize(node, hint: nil)
@@ -420,43 +537,63 @@ module Steep
         case node.type
         when :begin, :kwbegin
           yield_self do
+            end_pos = node.loc.expression.end_pos
+
             *mid_nodes, last_node = each_child_node(node).to_a
-            mid_nodes.each do |child|
-              synthesize(child)
-            end
             if last_node
-              type = synthesize(last_node, hint: hint)
+              pair = mid_nodes.inject(Pair.new(type: AST::Builtin.nil_type, constr: self)) do |pair, node|
+                pair.constr.synthesize(node).yield_self {|p| pair + p }.tap do |new_pair|
+                  if new_pair.constr.context != pair.constr.context
+                    # update context
+                    range = node.loc.expression.end_pos..end_pos
+                    typing.add_context(range, context: new_pair.constr.context)
+                  end
+                end
+              end
+
+              p = pair.constr.synthesize(last_node, hint: hint)
+              last_pair = pair + p
+              last_pair.constr.add_typing(node, type: last_pair.type, constr: last_pair.constr)
             else
-              type = AST::Builtin.nil_type
+              add_typing(node, type: AST::Builtin.nil_type)
             end
-
-            typing.add_typing(node, type, context)
           end
 
         when :lvasgn
           yield_self do
-            var = node.children[0]
-            rhs = node.children[1]
+            var, rhs = node.children
+            name = var.name
 
-            case var.name
+            case name
             when :_, :__any__
-              synthesize(rhs, hint: AST::Builtin.any_type)
-              typing.add_typing(node, AST::Builtin.any_type, context)
+              synthesize(rhs, hint: AST::Builtin.any_type).yield_self do |pair|
+                add_typing(node, type: AST::Builtin.any_type, constr: pair.constr)
+              end
             when :__skip__
-              typing.add_typing(node, AST::Builtin.any_type, context)
+              add_typing(node, type: AST::Builtin.any_type)
             else
-              type_assignment(var, rhs, node, hint: hint)
+              rhs_result = synthesize(rhs, hint: hint || context.lvar_env.declared_types[name]&.type)
+              constr = rhs_result.constr.update_lvar_env do |lvar_env|
+                lvar_env.assign(name, node: node, type: rhs_result.type) do |declared_type, actual_type, result|
+                  typing.add_error(Errors::IncompatibleAssignment.new(node: node,
+                                                                      lhs_type: declared_type,
+                                                                      rhs_type: actual_type,
+                                                                      result: result))
+                end
+              end
+
+              add_typing(node, type: rhs_result.type, constr: constr)
             end
           end
 
         when :lvar
           yield_self do
             var = node.children[0]
-            type = type_env.get(lvar: var.name) do
-              fallback_to_any node
+            if (type = context.lvar_env[var.name])
+              add_typing node, type: type
+            else
+              fallback_to_any(node)
             end
-
-            typing.add_typing node, type, context
           end
 
         when :ivasgn
@@ -471,7 +608,7 @@ module Steep
             type = type_env.get(ivar: name) do
               fallback_to_any node
             end
-            typing.add_typing(node, type, context)
+            add_typing(node, type: type)
           end
 
         when :send
@@ -484,7 +621,7 @@ module Steep
                        module_type
                      end
 
-              typing.add_typing(node, type, context)
+              add_typing(node, type: type)
             else
               type_send(node, send_node: node, block_params: nil, block_body: nil)
             end
@@ -492,83 +629,58 @@ module Steep
 
         when :csend
           yield_self do
-            type = if self_class?(node)
+            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)
                             else
                               module_type
                             end
-                     typing.add_typing(node, type, context)
+                     add_typing(node, type: type)
                    else
                      type_send(node, send_node: node, block_params: nil, block_body: nil, unwrap: true)
                    end
 
-            union_type(type, AST::Builtin.nil_type)
+            lvar_env = context.lvar_env.join(pair.context.lvar_env, context.lvar_env)
+            add_typing(node,
+                       type: union_type(pair.type, AST::Builtin.nil_type),
+                       constr: pair.constr.with_updated_context(lvar_env: lvar_env))
           end
 
         when :match_with_lvasgn
           each_child_node(node) do |child|
             synthesize(child)
           end
-          typing.add_typing(node, AST::Builtin.any_type, context)
+          add_typing(node, type: AST::Builtin.any_type)
 
         when :op_asgn
           yield_self do
             lhs, op, rhs = node.children
 
-            synthesize(rhs)
+            case lhs.type
+            when :lvasgn
+              var_node = lhs.updated(:lvar)
+              send_node = rhs.updated(:send, [var_node, op, rhs])
+              new_node = node.updated(:lvasgn, [lhs.children[0], send_node])
 
-            lhs_type = case lhs.type
-                       when :lvasgn
-                         type_env.get(lvar: lhs.children.first.name) do
-                           break
-                         end
-                       when :ivasgn
-                         type_env.get(ivar: lhs.children.first) do
-                           break
-                         end
-                       else
-                         Steep.logger.error("Unexpected op_asgn lhs: #{lhs.type}")
-                         nil
-                       end
+              type, constr = synthesize(new_node, hint: hint)
 
-            case
-            when lhs_type == AST::Builtin.any_type
-              typing.add_typing(node, lhs_type, context)
-            when !lhs_type
-              fallback_to_any(node)
-            else
-              lhs_interface = checker.factory.interface(lhs_type, private: false)
-              op_method = lhs_interface.methods[op]
+              constr.add_typing(node, type: type)
 
-              if op_method
-                args = TypeInference::SendArgs.from_nodes([rhs])
-                return_type, _ = type_method_call(node,
-                                                  receiver_type: lhs_type,
-                                                  method_name: op,
-                                                  method: op_method,
-                                                  args: args,
-                                                  block_params: nil,
-                                                  block_body: nil,
-                                                  topdown_hint: true)
+            when :ivasgn
+              var_node = lhs.updated(:ivar)
+              send_node = rhs.updated(:send, [var_node, op, rhs])
+              new_node = node.updated(:ivasgn, [lhs.children[0], send_node])
 
-                result = check_relation(sub_type: return_type, super_type: lhs_type)
-                if result.failure?
-                  typing.add_error(
-                    Errors::IncompatibleAssignment.new(
-                      node: node,
-                      lhs_type: lhs_type,
-                      rhs_type: return_type,
-                      result: result
-                    )
-                  )
-                end
-              else
-                typing.add_error Errors::NoMethod.new(node: node, method: op, type: expand_self(lhs_type))
-              end
+              type, constr = synthesize(new_node, hint: hint)
+
+              constr.add_typing(node, type: type)
+
+            else
+              Steep.logger.error("Unexpected op_asgn lhs: #{lhs.type}")
 
-              typing.add_typing(node, lhs_type, context)
+              _, constr = synthesize(rhs)
+              constr.add_typing(node, type: AST::Builtin.any_type)
             end
           end
 
@@ -597,7 +709,7 @@ module Steep
                                                   block_body: nil,
                                                   topdown_hint: true)
 
-                typing.add_typing node, return_type, context
+                add_typing node, type: return_type
               else
                 fallback_to_any node do
                   Errors::UnexpectedSuper.new(node: node, method: method_context.name)
@@ -619,49 +731,64 @@ module Steep
           end
 
         when :def
-          new = for_new_method(node.children[0],
-                               node,
-                               args: node.children[1].children,
-                               self_type: module_context&.instance_type,
-                               definition: module_context&.instance_definition)
-
-          each_child_node(node.children[1]) do |arg|
-            new.synthesize(arg)
-          end
-
-          if node.children[2]
-            return_type = expand_alias(new.method_context&.return_type)
-            if return_type && !return_type.is_a?(AST::Types::Void)
-              new.check(node.children[2], return_type) do |_, actual_type, result|
-                typing.add_error(Errors::MethodBodyTypeMismatch.new(node: node,
-                                                                    expected: new.method_context&.return_type,
-                                                                    actual: actual_type,
-                                                                    result: result))
-              end
-            else
-              new.synthesize(node.children[2])
+          yield_self do
+            name, args_node, body_node = node.children
+
+            new = for_new_method(name,
+                                 node,
+                                 args: args_node.children,
+                                 self_type: module_context&.instance_type,
+                                 definition: module_context&.instance_definition)
+            new.typing.add_context_for_node(node, context: new.context)
+            new.typing.add_context_for_body(node, context: new.context)
+
+            each_child_node(args_node) do |arg|
+              new.synthesize(arg)
             end
-          else
-            return_type = expand_alias(new.method_context&.return_type)
-            if return_type && !return_type.is_a?(AST::Types::Void)
-              result = check_relation(sub_type: AST::Builtin.nil_type, super_type: return_type)
-              if result.failure?
-                typing.add_error(Errors::MethodBodyTypeMismatch.new(node: node,
-                                                                    expected: new.method_context&.return_type,
-                                                                    actual: AST::Builtin.nil_type,
-                                                                    result: result))
-              end
+
+            body_pair = if body_node
+                          return_type = expand_alias(new.method_context&.return_type)
+                          if return_type && !return_type.is_a?(AST::Types::Void)
+                            new.check(body_node, return_type) do |_, actual_type, result|
+                              typing.add_error(Errors::MethodBodyTypeMismatch.new(node: node,
+                                                                                  expected: new.method_context&.return_type,
+                                                                                  actual: actual_type,
+                                                                                  result: result))
+                            end
+                          else
+                            new.synthesize(body_node)
+                          end
+                        else
+                          return_type = expand_alias(new.method_context&.return_type)
+                          if return_type && !return_type.is_a?(AST::Types::Void)
+                            result = check_relation(sub_type: AST::Builtin.nil_type, super_type: return_type)
+                            if result.failure?
+                              typing.add_error(Errors::MethodBodyTypeMismatch.new(node: node,
+                                                                                  expected: new.method_context&.return_type,
+                                                                                  actual: AST::Builtin.nil_type,
+                                                                                  result: result))
+                            end
+                          end
+
+                          Pair.new(type: AST::Builtin.nil_type, constr: new)
+                        end
+
+            if body_node
+              begin_pos = body_node.loc.expression.end_pos
+              end_pos = node.loc.end.begin_pos
+
+              typing.add_context(begin_pos..end_pos, context: body_pair.context)
             end
-          end
 
-          if module_context
-            module_context.defined_instance_methods << node.children[0]
-          end
+            if module_context
+              module_context.defined_instance_methods << node.children[0]
+            end
 
-          typing.add_typing(node, AST::Builtin.any_type, new.context)
+            add_typing(node, type: AST::Builtin::Symbol.instance_type)
+          end
 
         when :defs
-          synthesize(node.children[0]).tap do |self_type|
+          synthesize(node.children[0]).type.tap do |self_type|
             self_type = expand_self(self_type)
             definition = case self_type
                          when AST::Types::Name::Instance
@@ -677,6 +804,8 @@ module Steep
                                  args: node.children[2].children,
                                  self_type: self_type,
                                  definition: definition)
+            new.typing.add_context_for_node(node, context: new.context)
+            new.typing.add_context_for_body(node, context: new.context)
 
             each_child_node(node.children[2]) do |arg|
               new.synthesize(arg)
@@ -703,7 +832,7 @@ module Steep
             end
           end
 
-          typing.add_typing(node, AST::Builtin::Symbol.instance_type, context)
+          add_typing(node, type: AST::Builtin::Symbol.instance_type)
 
         when :return
           yield_self do
@@ -716,7 +845,7 @@ module Steep
                                    nil
                                  else
                                    method_return_type
-                                 end)
+                                 end).type
               end
 
               value_type = if return_types.size == 1
@@ -739,7 +868,7 @@ module Steep
               end
             end
 
-            typing.add_typing(node, AST::Builtin.any_type, context)
+            add_typing(node, type: AST::Builtin.bottom_type)
           end
 
         when :break
@@ -765,7 +894,7 @@ module Steep
             typing.add_error Errors::UnexpectedJump.new(node: node)
           end
 
-          typing.add_typing(node, AST::Builtin.any_type, context)
+          add_typing(node, type: AST::Builtin.bottom_type)
 
         when :next
           value = node.children[0]
@@ -790,77 +919,99 @@ module Steep
             typing.add_error Errors::UnexpectedJump.new(node: node)
           end
 
-          typing.add_typing(node, AST::Builtin.any_type, context)
+          add_typing(node, type: AST::Builtin.bottom_type)
 
         when :retry
           unless break_context
             typing.add_error Errors::UnexpectedJump.new(node: node)
           end
-          typing.add_typing(node, AST::Builtin.any_type, context)
+          add_typing(node, type: AST::Builtin.bottom_type)
 
         when :arg, :kwarg, :procarg0
           yield_self do
             var = node.children[0]
-            type = type_env.get(lvar: var.name) do
-              fallback_to_any node
+            type = context.lvar_env[var.name]
+            unless type
+              type = AST::Builtin.any_type
+              Steep.logger.error { "Unknown arg type: #{node}" }
             end
-            typing.add_typing(node, type, context)
+            add_typing(node, type: type)
           end
 
         when :optarg, :kwoptarg
           yield_self do
             var = node.children[0]
             rhs = node.children[1]
-            type_assignment(var, rhs, node, hint: hint)
+
+            type = context.lvar_env[var.name]
+
+            node_type, constr = synthesize(rhs, hint: type)
+
+            constr_ = constr.update_lvar_env do |env|
+              env.assign(var.name, node: node, type: node_type) do |declared_type, type, result|
+                typing.add_error(
+                  Errors::IncompatibleAssignment.new(node: node,
+                                                     lhs_type: declared_type,
+                                                     rhs_type: type,
+                                                     result: result)
+                )
+              end
+            end
+
+            add_typing(node, type: constr_.context.lvar_env[var.name], constr: constr_)
           end
 
         when :restarg
           yield_self do
             var = node.children[0]
-            type = type_env.get(lvar: var.name) do
+            type = context.lvar_env[var.name]
+            unless type
+              Steep.logger.error { "Unknown variable: #{node}" }
               typing.add_error Errors::FallbackAny.new(node: node)
-              AST::Builtin::Array.instance_type(AST::Builtin.any_type)
+              type = AST::Builtin::Array.instance_type(AST::Builtin.any_type)
             end
 
-            typing.add_typing(node, type, context)
+            add_typing(node, type: type)
           end
 
         when :kwrestarg
           yield_self do
             var = node.children[0]
-            type = type_env.get(lvar: var.name) do
+            type = context.lvar_env[var.name]
+            unless type
+              Steep.logger.error { "Unknown variable: #{node}" }
               typing.add_error Errors::FallbackAny.new(node: node)
-              AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type, AST::Builtin.any_type)
+              type = AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type, AST::Builtin.any_type)
             end
 
-            typing.add_typing(node, type, context)
+            add_typing(node, type: type)
           end
 
         when :float
-          typing.add_typing(node, AST::Builtin::Float.instance_type, context)
+          add_typing(node, type: AST::Builtin::Float.instance_type)
 
         when :nil
-          typing.add_typing(node, AST::Builtin.nil_type, context)
+          add_typing(node, type: AST::Builtin.nil_type)
 
         when :int
           yield_self do
-            literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_)}
+            literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_) }
 
             if literal_type
-              typing.add_typing(node, literal_type, context)
+              add_typing(node, type: literal_type)
             else
-              typing.add_typing(node, AST::Builtin::Integer.instance_type, context)
+              add_typing(node, type: AST::Builtin::Integer.instance_type)
             end
           end
 
         when :sym
           yield_self do
-            literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_)}
+            literal_type = expand_alias(hint) {|hint| test_literal_type(node.children[0], hint) }
 
             if literal_type
-              typing.add_typing(node, literal_type, context)
+              add_typing(node, type: literal_type)
             else
-              typing.add_typing(node, AST::Builtin::Symbol.instance_type, context)
+              add_typing(node, type: AST::Builtin::Symbol.instance_type)
             end
           end
 
@@ -869,14 +1020,14 @@ module Steep
             literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_)}
 
             if literal_type
-              typing.add_typing(node, literal_type, context)
+              add_typing(node, type: literal_type)
             else
-              typing.add_typing(node, AST::Builtin::String.instance_type, context)
+              add_typing(node, type: AST::Builtin::String.instance_type)
             end
           end
 
         when :true, :false
-          typing.add_typing(node, AST::Types::Boolean.new, context)
+          add_typing(node, type: AST::Types::Boolean.new)
 
         when :hash
           yield_self do
@@ -894,14 +1045,14 @@ module Steep
               case child.type
               when :pair
                 key, value = child.children
-                key_types << synthesize(key).yield_self do |type|
+                key_types << synthesize(key).type.yield_self do |type|
                   select_super_type(type, key_hint)
                 end
-                value_types << synthesize(value).yield_self do |type|
+                value_types << synthesize(value).type.yield_self do |type|
                   select_super_type(type, value_hint)
                 end
               when :kwsplat
-                expand_alias(synthesize(child.children[0])) do |splat_type, original_type|
+                expand_alias(synthesize(child.children[0]).type) do |splat_type, original_type|
                   if AST::Builtin::Hash.instance_type?(splat_type)
                     key_types << splat_type.args[0]
                     value_types << splat_type.args[1]
@@ -923,7 +1074,7 @@ module Steep
               typing.add_error Errors::FallbackAny.new(node: node)
             end
 
-            typing.add_typing(node, AST::Builtin::Hash.instance_type(key_type, value_type), context)
+            add_typing(node, type: AST::Builtin::Hash.instance_type(key_type, value_type))
           end
 
         when :dstr, :xstr
@@ -931,43 +1082,49 @@ module Steep
             synthesize(child)
           end
 
-          typing.add_typing(node, AST::Builtin::String.instance_type, context)
+          add_typing(node, type: AST::Builtin::String.instance_type)
 
         when :dsym
           each_child_node(node) do |child|
             synthesize(child)
           end
 
-          typing.add_typing(node, AST::Builtin::Symbol.instance_type, context)
+          add_typing(node, type: AST::Builtin::Symbol.instance_type)
 
         when :class
           yield_self do
             for_class(node).tap do |constructor|
+              constructor.typing.add_context_for_node(node, context: constructor.context)
+              constructor.typing.add_context_for_body(node, context: constructor.context)
+
               constructor.synthesize(node.children[2]) if node.children[2]
 
               if constructor.module_context&.implement_name && !namespace_module?(node)
                 constructor.validate_method_definitions(node, constructor.module_context.implement_name)
               end
-
-              typing.add_typing(node, AST::Builtin.nil_type, constructor.context)
             end
+
+            add_typing(node, type: AST::Builtin.nil_type)
           end
 
         when :module
           yield_self do
             for_module(node).yield_self do |constructor|
+              constructor.typing.add_context_for_node(node, context: constructor.context)
+              constructor.typing.add_context_for_body(node, context: constructor.context)
+
               constructor.synthesize(node.children[1]) if node.children[1]
 
               if constructor.module_context&.implement_name && !namespace_module?(node)
                 constructor.validate_method_definitions(node, constructor.module_context.implement_name)
               end
-
-              typing.add_typing(node, AST::Builtin.nil_type, constructor.context)
             end
+
+            add_typing(node, type: AST::Builtin.nil_type)
           end
 
         when :self
-          typing.add_typing node, AST::Types::Self.new, context
+          add_typing node, type: AST::Types::Self.new
 
         when :const
           const_name = Names::Module.from_node(node)
@@ -975,7 +1132,7 @@ module Steep
             type = type_env.get(const: const_name) do
               fallback_to_any node
             end
-            typing.add_typing node, type, context
+            add_typing node, type: type
           else
             fallback_to_any node
           end
@@ -984,7 +1141,7 @@ module Steep
           yield_self do
             const_name = Names::Module.from_node(node)
             if const_name
-              value_type = synthesize(node.children.last)
+              value_type = synthesize(node.children.last).type
               type = type_env.assign(const: const_name, type: value_type, self_type: self_type) do |error|
                 case error
                 when Subtyping::Result::Failure
@@ -998,9 +1155,9 @@ module Steep
                 end
               end
 
-              typing.add_typing(node, type, context)
+              add_typing(node, type: type)
             else
-              synthesize(node.children.last)
+              synthesize(node.children.last).type
               fallback_to_any(node)
             end
           end
@@ -1020,7 +1177,7 @@ module Steep
                 end
               end
 
-              typing.add_typing(node, block_type.type.return_type, context)
+              add_typing(node, type: block_type.type.return_type)
             else
               typing.add_error(Errors::UnexpectedYield.new(node: node))
               fallback_to_any node
@@ -1034,16 +1191,9 @@ module Steep
             if method_context&.method
               if method_context.super_method
                 types = method_context.super_method.method_types.map {|method_type|
-                  case method_type
-                  when Ruby::Signature::MethodType
-                    checker.factory.method_type(method_type, self_type: self_type).return_type
-                  when :any
-                    AST::Builtin.any_type
-                  else
-                    raise "Unexpected method_type: #{method_type.inspect}"
-                  end
+                  checker.factory.method_type(method_type, self_type: self_type).return_type
                 }
-                typing.add_typing(node, union_type(*types), context)
+                add_typing(node, type: union_type(*types))
               else
                 typing.add_error(Errors::UnexpectedSuper.new(node: node, method: method_context.name))
                 fallback_to_any node
@@ -1065,7 +1215,7 @@ module Steep
                              end
                            end
 
-              typing.add_typing(node, array_type || AST::Builtin::Array.instance_type(AST::Builtin.any_type), context)
+              add_typing(node, type: array_type || AST::Builtin::Array.instance_type(AST::Builtin.any_type))
             else
               is_tuple = nil
 
@@ -1075,7 +1225,7 @@ module Steep
                 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), child_type]
+                  [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?
@@ -1092,7 +1242,7 @@ module Steep
                 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).yield_self do |type|
+                    synthesize(e.children.first).type.yield_self do |type|
                       expand_alias(type) do |ty|
                         case ty
                         when AST::Types::Union
@@ -1112,155 +1262,237 @@ module Steep
                       end
                     end
                   else
-                    [select_super_type(synthesize(e), element_hint)]
+                    [select_super_type(synthesize(e).type, element_hint)]
                   end
                 end
                 array_type = AST::Builtin::Array.instance_type(AST::Types::Union.build(types: element_types))
               end
 
-              typing.add_typing(node, array_type, context)
+              add_typing(node, type: array_type)
             end
           end
 
         when :and
           yield_self do
             left, right = node.children
-            left_type = synthesize(left)
+            logic = TypeInference::Logic.new(subtyping: checker)
+            truthy, falsey = logic.nodes(node: left)
 
-            truthy_vars = TypeConstruction.truthy_variables(left)
-            right_type, right_env = for_branch(right, truthy_vars: truthy_vars).yield_self do |constructor|
-              type = constructor.synthesize(right)
-              [type, constructor.type_env]
-            end
+            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)
 
-            type_env.join!([right_env, TypeInference::TypeEnv.new(subtyping: checker,
-                                                                  const_env: nil)])
+            right_type, constr = constr.update_lvar_env { truthy_env }.for_branch(right).synthesize(right)
 
-            if left_type.is_a?(AST::Types::Boolean)
-              typing.add_typing(node, union_type(left_type, right_type), context)
-            else
-              typing.add_typing(node, union_type(right_type, AST::Builtin.nil_type), context)
-            end
+            type = if left_type.is_a?(AST::Types::Boolean)
+                     union_type(left_type, right_type)
+                   else
+                     union_type(right_type, AST::Builtin.nil_type)
+                   end
+
+            add_typing(node,
+                       type: type,
+                       constr: constr.update_lvar_env do
+                         if right_type.is_a?(AST::Types::Bot)
+                           falsey_env
+                         else
+                           context.lvar_env.join(falsey_env, constr.context.lvar_env)
+                         end
+                       end)
           end
 
         when :or
           yield_self do
-            c1, c2 = node.children
-            t1 = synthesize(c1, hint: hint)
-            t2 = synthesize(c2, hint: unwrap(t1))
-            type = union_type(unwrap(t1), t2)
-            typing.add_typing(node, type, context)
+            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)
+
+            type = union_type(left_type_t, right_type)
+
+            add_typing(node,
+                       type: type,
+                       constr: constr.update_lvar_env do
+                         if right_type.is_a?(AST::Types::Bot)
+                           truthy_env
+                         else
+                           context.lvar_env.join(truthy_env, constr.context.lvar_env)
+                         end
+                       end)
           end
 
         when :if
           cond, true_clause, false_clause = node.children
-          synthesize cond
 
-          truthy_vars = TypeConstruction.truthy_variables(cond)
+          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)
 
           if true_clause
-            true_type, true_env = for_branch(true_clause, truthy_vars: truthy_vars).yield_self do |constructor|
-              type = constructor.synthesize(true_clause, hint: hint)
-              [type, constructor.type_env]
-            end
+            true_pair = constr
+                          .update_lvar_env { truthy_env }
+                          .for_branch(true_clause)
+                          .tap {|constr| typing.add_context_for_node(true_clause, context: constr.context) }
+                          .synthesize(true_clause, hint: hint)
           end
+
           if false_clause
-            false_type, false_env = for_branch(false_clause).yield_self do |constructor|
-              type = constructor.synthesize(false_clause, hint: hint)
-              [type, constructor.type_env]
+            false_pair = constr
+                           .update_lvar_env { falsey_env }
+                           .for_branch(false_clause)
+                           .tap {|constr| typing.add_context_for_node(false_clause, context: constr.context) }
+                           .synthesize(false_clause, hint: hint)
+          end
+
+          constr = constr.update_lvar_env do |env|
+            envs = []
+
+            if true_pair
+              unless true_pair.type.is_a?(AST::Types::Bot)
+                envs << true_pair.context.lvar_env
+              end
+            else
+              envs << truthy_env
+            end
+
+            if false_pair
+              unless false_pair.type.is_a?(AST::Types::Bot)
+                envs << false_pair.context.lvar_env
+              end
+            else
+              envs << falsey_env
             end
+
+            env.join(*envs)
           end
 
-          type_env.join!([true_env, false_env].compact)
-          typing.add_typing(node, union_type(true_type, false_type), context)
+          add_typing(node,
+                     type: union_type(true_pair&.type || AST::Builtin.nil_type,
+                                      false_pair&.type || AST::Builtin.nil_type),
+                     constr: constr)
 
         when :case
           yield_self do
-            cond, *whens = node.children
+            cond, *whens, els = node.children
+
+            constr = self
 
             if cond
-              cond_type = expand_alias(synthesize(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
 
-            pairs = whens.each.with_object([]) do |clause, pairs|
-              if clause&.type == :when
-                test_types = clause.children.take(clause.children.size - 1).map do |child|
-                  expand_alias(synthesize(child, hint: hint))
-                end
+            branch_pairs = []
 
-                if (body = clause.children.last)
-                  if var_names && var_types && test_types.all? {|type| type.is_a?(AST::Types::Name::Class)}
-                    var_types_in_body = test_types.flat_map {|test_type|
-                      filtered_types = var_types.select {|var_type| var_type.is_a?(AST::Types::Name::Base) && var_type.name == test_type.name}
-                      if filtered_types.empty?
-                        to_instance_type(test_type)
-                      else
-                        filtered_types
-                      end
-                    }
-                    var_types.reject! {|type|
-                      var_types_in_body.any? {|test_type|
-                        type.is_a?(AST::Types::Name::Base) && test_type.name == type.name
-                      }
-                    }
-
-                    type_case_override = var_names.each.with_object({}) do |var_name, hash|
-                      hash[var_name] = union_type(*var_types_in_body)
+            whens.each do |clause|
+              *tests, body = clause.children
+
+              test_types = []
+              clause_constr = constr
+
+              tests.each do |test|
+                type, clause_constr = synthesize(test)
+                test_types << expand_alias(type)
+              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
+
+                  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
-                  else
-                    type_case_override = nil
                   end
 
-                  for_branch(body, type_case_override: type_case_override).yield_self do |body_construction|
-                    type = body_construction.synthesize(body, hint: hint)
-                    pairs << [type, body_construction.type_env]
+                  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
+
+                  branch_pairs << clause_constr
+                                    .for_branch(body, type_case_override: type_case_override)
+                                    .synthesize(body, hint: hint)
                 else
-                  pairs << [AST::Builtin.nil_type, nil]
+                  branch_pairs << clause_constr.synthesize(body, hint: hint)
                 end
               else
-                if clause
-                  if var_types
-                    if !var_types.empty?
-                      type_case_override = var_names.each.with_object({}) do |var_name, hash|
-                        hash[var_name] = union_type(*var_types)
-                      end
-                      var_types.clear
-                    else
-                      typing.add_error Errors::ElseOnExhaustiveCase.new(node: node, type: cond_type)
-                      type_case_override = var_names.each.with_object({}) do |var_name, hash|
-                        hash[var_name] = AST::Builtin.any_type
-                      end
-                    end
-                  end
+                branch_pairs << Pair.new(type: AST::Builtin.nil_type, constr: clause_constr)
+              end
+            end
 
-                  for_branch(clause, type_case_override: type_case_override).yield_self do |body_construction|
-                    type = body_construction.synthesize(clause, hint: hint)
-                    pairs << [type, body_construction.type_env]
-                  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)
               end
             end
 
-            types = pairs.map(&:first)
-            envs = pairs.map(&:last)
+            types = branch_pairs.map(&:type)
+            constrs = branch_pairs.map(&:constr)
 
-            unless var_types&.empty? || whens.last
+            unless var_types&.empty? || els
               types.push AST::Builtin.nil_type
             end
 
-            type_env.join!(envs.compact)
-            typing.add_typing(node, union_type(*types), context)
+            constr = constr.update_lvar_env do |env|
+              env.join(*constrs.map {|c| c.context.lvar_env })
+            end
+
+            add_typing(node, type: union_type(*types), constr: constr)
           end
 
         when :rescue
           yield_self do
             body, *resbodies, else_node = node.children
-            body_type = synthesize(body) if body
+            body_pair = synthesize(body) if body
+
+            body_constr = if body_pair
+                            self.update_lvar_env do |env|
+                              env.join(env, body_pair.context.lvar_env)
+                            end
+                          else
+                            self
+                          end
 
             resbody_pairs = resbodies.map do |resbody|
               exn_classes, assignment, body = resbody.children
@@ -1268,7 +1500,7 @@ module Steep
               if exn_classes
                 case exn_classes.type
                 when :array
-                  exn_types = exn_classes.children.map {|child| synthesize(child)}
+                  exn_types = exn_classes.children.map {|child| synthesize(child).type }
                 else
                   Steep.logger.error "Unexpected exception list: #{exn_classes.type}"
                 end
@@ -1301,27 +1533,28 @@ module Steep
                 type_override[var_name] = AST::Builtin.any_type
               end
 
-              resbody_construction = for_branch(resbody, type_case_override: type_override)
+              resbody_construction = body_constr.for_branch(resbody, type_case_override: type_override)
 
-              type = if body
-                       resbody_construction.synthesize(body)
-                     else
-                       AST::Builtin.nil_type
-                     end
-              [type, resbody_construction.type_env]
+              if body
+                resbody_construction.synthesize(body)
+              else
+                Pair.new(constr: body_constr, type: AST::Builtin.nil_type)
+              end
             end
-            resbody_types, resbody_envs = resbody_pairs.transpose
+
+            resbody_types = resbody_pairs.map(&:type)
+            resbody_envs = resbody_pairs.map {|pair| pair.context.lvar_env }
 
             if else_node
-              else_construction = for_branch(else_node)
-              else_type = else_construction.synthesize(else_node)
-              else_env = else_construction.type_env
+              else_pair = (body_pair&.constr || self).for_branch(else_node).synthesize(else_node)
+              add_typing(node,
+                         type: union_type(*[else_pair.type, *resbody_types].compact),
+                         constr: update_lvar_env {|env| env.join(*resbody_envs, env) })
+            else
+              add_typing(node,
+                         type: union_type(*[body_pair&.type, *resbody_types].compact),
+                         constr: update_lvar_env {|env| env.join(*resbody_envs, (body_pair&.constr || self).context.lvar_env) })
             end
-
-            type_env.join!([*resbody_envs, else_env].compact)
-
-            types = [body_type, *resbody_types, else_type].compact
-            typing.add_typing(node, union_type(*types), context)
           end
 
         when :resbody
@@ -1329,66 +1562,105 @@ module Steep
             klasses, asgn, body = node.children
             synthesize(klasses) if klasses
             synthesize(asgn) if asgn
-            body_type = synthesize(body) if body
-            typing.add_typing(node, body_type, context)
+            body_type = synthesize(body).type if body
+            add_typing(node, type: body_type)
           end
 
         when :ensure
           yield_self do
             body, ensure_body = node.children
-            body_type = synthesize(body) if body
+            body_type = synthesize(body).type if body
             synthesize(ensure_body) if ensure_body
-            typing.add_typing(node, union_type(body_type), context)
+            add_typing(node, type: union_type(body_type))
           end
 
         when :masgn
           type_masgn(node)
 
-        when :while, :while_post, :until, :until_post
+        when :while, :until
           yield_self do
             cond, body = node.children
+            _, constr = synthesize(cond)
+
+            logic = TypeInference::Logic.new(subtyping: checker)
+            truthy, falsey = logic.nodes(node: cond)
 
-            synthesize(cond)
-            truthy_vars = node.type == :while ? TypeConstruction.truthy_variables(cond) : Set.new
+            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)
+            when :until
+              exit_env, body_env = logic.environments(truthy_vars: truthy.vars, falsey_vars: falsey.vars, lvar_env: constr.context.lvar_env)
+            end
 
             if body
-              for_loop = for_branch(body,
-                                    truthy_vars: truthy_vars,
-                                    break_context: TypeInference::Context::BreakContext.new(
-                                      break_type: nil,
-                                      next_type: nil
-                                    ))
-              for_loop.synthesize(body)
-              type_env.join!([for_loop.type_env])
+              _, body_constr = constr
+                                 .update_lvar_env { body_env.pin_assignments }
+                                 .for_branch(body,
+                                             break_context: TypeInference::Context::BreakContext.new(
+                                               break_type: nil,
+                                               next_type: nil
+                                             ))
+                                 .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
+                                 .synthesize(body)
+
+              constr = constr.update_lvar_env {|env| env.join(exit_env, body_constr.context.lvar_env) }
+            else
+              constr = constr.update_lvar_env { exit_env }
             end
 
-            typing.add_typing(node, AST::Builtin.any_type, context)
+            add_typing(node, type: AST::Builtin.nil_type, constr: constr)
+          end
+
+        when :while_post, :until_post
+          yield_self do
+            cond, body = node.children
+
+            cond_pair = synthesize(cond)
+
+            if body
+              for_loop = cond_pair.constr
+                           .update_lvar_env {|env| env.pin_assignments }
+                           .for_branch(body,
+                                       break_context: TypeInference::Context::BreakContext.new(
+                                         break_type: nil,
+                                         next_type: nil
+                                       ))
+
+              typing.add_context_for_node(body, context: for_loop.context)
+              body_pair = for_loop.synthesize(body)
+
+              constr = cond_pair.constr.update_lvar_env {|env| env.join(env, body_pair.context.lvar_env) }
+
+              add_typing(node, type: AST::Builtin.nil_type, constr: constr)
+            else
+              add_typing(node, type: AST::Builtin.nil_type, constr: cond_pair.constr)
+            end
           end
 
         when :irange, :erange
-          types = node.children.map {|n| synthesize(n)}
+          types = node.children.map {|n| synthesize(n).type }
           type = AST::Builtin::Range.instance_type(union_type(*types))
-          typing.add_typing(node, type, context)
+          add_typing(node, type: type)
 
         when :regexp
           each_child_node(node) do |child|
             synthesize(child)
           end
 
-          typing.add_typing(node, AST::Builtin::Regexp.instance_type, context)
+          add_typing(node, type: AST::Builtin::Regexp.instance_type)
 
         when :regopt
           # ignore
-          typing.add_typing(node, AST::Builtin.any_type, context)
+          add_typing(node, type: AST::Builtin.any_type)
 
         when :nth_ref, :back_ref
-          typing.add_typing(node, AST::Builtin::String.instance_type, context)
+          add_typing(node, type: AST::Builtin::String.instance_type)
 
         when :or_asgn, :and_asgn
           yield_self do
             _, rhs = node.children
-            rhs_type = synthesize(rhs)
-            typing.add_typing(node, rhs_type, context)
+            rhs_type = synthesize(rhs).type
+            add_typing(node, type: rhs_type)
           end
 
         when :defined?
@@ -1396,7 +1668,7 @@ module Steep
             synthesize(child)
           end
 
-          typing.add_typing(node, AST::Builtin.any_type, context)
+          add_typing(node, type: AST::Builtin.any_type)
 
         when :gvasgn
           yield_self do
@@ -1422,7 +1694,7 @@ module Steep
               typing.add_error Errors::FallbackAny.new(node: node)
             end
 
-            typing.add_typing(node, type, context)
+            add_typing(node, type: type)
           end
 
         when :block_pass
@@ -1450,9 +1722,9 @@ module Steep
               end
             end
 
-            type ||= synthesize(node.children[0], hint: hint)
+            type ||= synthesize(node.children[0], hint: hint).type
 
-            typing.add_typing node, type, context
+            add_typing node, type: type
           end
 
         when :blockarg
@@ -1461,7 +1733,7 @@ module Steep
               synthesize(child)
             end
 
-            typing.add_typing node, AST::Builtin.any_type, context
+            add_typing node, type: AST::Builtin.any_type
           end
 
         when :splat, :sclass, :alias
@@ -1472,55 +1744,35 @@ module Steep
               synthesize(child)
             end
 
-            typing.add_typing node, AST::Builtin.any_type, context
+            add_typing node, type: AST::Builtin.any_type
           end
 
         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}" }
+            # Steep.logger.error { "node = #{node.type}" }
+            raise "#synthesize should return an instance of Pair: #{pair.class}"
+          end
         end
       end
     end
 
     def check(node, type, constraints: Subtyping::Constraints.empty)
-      type_ = synthesize(node, hint: type)
+      pair = synthesize(node, hint: type)
 
-      result = check_relation(sub_type: type_, super_type: type, constraints: constraints)
+      result = check_relation(sub_type: pair.type, super_type: type, constraints: constraints)
       if result.failure?
-        yield(type, type_, result)
-      end
-    end
-
-    def type_assignment(var, rhs, node, hint: nil)
-      if rhs
-        expand_alias(synthesize(rhs, hint: type_env.lvar_types[var.name] || hint)) do |rhs_type|
-          node_type = assign_type_to_variable(var, rhs_type, node)
-          typing.add_typing(node, node_type, context)
-        end
+        yield(type, pair.type, result)
+        pair.with(type: type)
       else
-        raise
-        lhs_type = variable_type(var)
-
-        if lhs_type
-          typing.add_typing(node, lhs_type, context)
-        else
-          fallback_to_any node
-        end
-      end
-    end
-
-    def assign_type_to_variable(var, type, node)
-      name = var.name
-      type_env.assign(lvar: name, type: type, self_type: self_type) do |result|
-        var_type = type_env.get(lvar: name)
-        typing.add_error(Errors::IncompatibleAssignment.new(node: node,
-                                                            lhs_type: var_type,
-                                                            rhs_type: type,
-                                                            result: result))
+        pair
       end
     end
 
     def type_ivasgn(name, rhs, node)
-      rhs_type = synthesize(rhs, hint: type_env.get(ivar: name) { fallback_to_any(node) })
+      rhs_type = synthesize(rhs, hint: type_env.get(ivar: name) { fallback_to_any(node) }).type
       ivar_type = type_env.assign(ivar: name, type: rhs_type, self_type: self_type) do |error|
         case error
         when Subtyping::Result::Failure
@@ -1533,102 +1785,111 @@ module Steep
           fallback_to_any node
         end
       end
-      typing.add_typing(node, ivar_type, context)
+      add_typing(node, type: ivar_type)
     end
 
     def type_masgn(node)
       lhs, rhs = node.children
-      rhs_original = synthesize(rhs)
-      rhs_type = expand_alias(rhs_original)
-
-      case
-      when rhs.type == :array && lhs.children.all? {|a| a.type == :lvasgn || a.type == :ivasgn} && lhs.children.size == rhs.children.size
-        pairs = lhs.children.zip(rhs.children)
-        pairs.each do |(l, r)|
-          case
-          when l.type == :lvasgn
-            type_assignment(l.children.first, r, l)
-          when l.type == :ivasgn
-            type_ivasgn(l.children.first, r, l)
-          end
-        end
+      rhs_pair = synthesize(rhs)
+      rhs_type = expand_alias(rhs_pair.type)
 
-        typing.add_typing(node, rhs_type, context)
+      constr = rhs_pair.constr
 
-      when rhs_type.is_a?(AST::Types::Tuple) && lhs.children.all? {|a| a.type == :lvasgn || a.type == :ivasgn}
-        lhs.children.each.with_index do |asgn, index|
-          type = rhs_type.types[index]
-
-          case
-          when asgn.type == :lvasgn && asgn.children[0].name != :_
-            type ||= AST::Builtin.nil_type
-            type_env.assign(lvar: asgn.children[0].name, type: type, self_type: self_type) do |result|
-              var_type = type_env.get(lvar: asgn.children[0].name)
-              typing.add_error(Errors::IncompatibleAssignment.new(node: node,
-                                                                  lhs_type: var_type,
-                                                                  rhs_type: type,
-                                                                  result: result))
-            end
-          when asgn.type == :ivasgn
-            type ||= AST::Builtin.nil_type
-            type_env.assign(ivar: asgn.children[0], type: type) do |result|
-              var_type = type_env.get(ivar: asgn.children[0])
-              typing.add_error(Errors::IncompatibleAssignment.new(node: node,
-                                                                  lhs_type: var_type,
-                                                                  rhs_type: type,
-                                                                  result: result))
+      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
+
+          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
           end
-        end
 
-        typing.add_typing(node, rhs_type, context)
+          add_typing(node, type: rhs_type, constr: constr)
 
-      when rhs_type.is_a?(AST::Types::Any)
-        fallback_to_any(node)
+        when rhs_type.is_a?(AST::Types::Tuple)
+          # a, @b = tuple
 
-      when AST::Builtin::Array.instance_type?(rhs_type)
-        element_type = rhs_type.args.first
+          constr = lhs.children.zip(rhs_type.types).inject(constr) do |ctr, (lhs, type)|
+            ty = type || AST::Builtin.nil_type
 
-        lhs.children.each do |assignment|
-          case assignment.type
-          when :lvasgn
-            assign_type_to_variable(assignment.children.first, element_type, assignment)
-          when :ivasgn
-            assignment.children.first.yield_self do |ivar|
-              type_env.assign(ivar: ivar, type: element_type, self_type: self_type) do |error|
+            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]
+
+              type_env.assign(ivar: ivar, type: ty, 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,
+                  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
+
+              ctr
             end
           end
-        end
 
-        typing.add_typing node, rhs_type, context
+          add_typing(node, type: rhs_type, constr: constr)
 
-      when rhs_type.is_a?(AST::Types::Union) &&
-        rhs_type.types.all? {|type| AST::Builtin::Array.instance_type?(type)}
+        when AST::Builtin::Array.instance_type?(rhs_type)
+          element_type = AST::Types::Union.build(types: [rhs_type.args.first, AST::Builtin.nil_type])
 
-        types = rhs_type.types.flat_map do |type|
-          type.args.first
-        end
+          constr = lhs.children.inject(constr) do |ctr, assignment|
+            case assignment.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
 
-        element_type = AST::Types::Union.build(types: types)
+              add_typing(assignment,
+                         type: element_type,
+                         constr: ctr.with_updated_context(lvar_env: env)).constr
 
-        lhs.children.each do |assignment|
-          case assignment.type
-          when :lvasgn
-            assign_type_to_variable(assignment.children.first, element_type, assignment)
-          when :ivasgn
-            assignment.children.first.yield_self do |ivar|
-              type_env.assign(ivar: ivar, type: element_type) do |error|
+            when :ivasgn
+              ivar = assignment.children[0]
+
+              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)
@@ -1640,14 +1901,22 @@ module Steep
                   fallback_to_any node
                 end
               end
+
+              ctr
             end
           end
-        end
 
-        typing.add_typing node, rhs_type, context
+          add_typing node, type: rhs_type, constr: constr
+
+        when rhs_type.is_a?(AST::Types::Any)
+          fallback_to_any(node)
 
+        else
+          Steep.logger.error("Unsupported masgn: #{rhs.type} (#{rhs_type})")
+          fallback_to_any(node)
+        end
       else
-        Steep.logger.error("Unsupported masgn: #{rhs.type} (#{rhs_type})")
+        Steep.logger.error("Unsupported masgn left hand side")
         fallback_to_any(node)
       end
     end
@@ -1662,7 +1931,8 @@ module Steep
         return_hint = type_hint.return_type
       end
 
-      block_type = type_block(block_param_hint: params_hint,
+      block_pair = type_block(node: node,
+                              block_param_hint: params_hint,
                               block_type_hint: return_hint,
                               node_type_hint: nil,
                               block_params: params,
@@ -1670,12 +1940,12 @@ module Steep
                               block_annotations: block_annotations,
                               topdown_hint: true)
 
-      typing.add_typing node, block_type, context
+      add_typing node, type: block_pair.type
     end
 
     def type_send(node, send_node:, block_params:, block_body:, unwrap: false)
       receiver, method_name, *arguments = send_node.children
-      receiver_type = receiver ? synthesize(receiver) : AST::Types::Self.new
+      receiver_type = receiver ? synthesize(receiver).type : AST::Types::Self.new
 
       if unwrap
         receiver_type = unwrap(receiver_type)
@@ -1683,70 +1953,70 @@ module Steep
 
       receiver_type = expand_alias(receiver_type)
 
-      return_type = case receiver_type
-                    when AST::Types::Any
-                      typing.add_typing node, AST::Builtin.any_type, context
-
-                    when nil
-                      fallback_to_any node
-
-                    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
-
-                    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, _ = 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)
-
-                            typing.add_typing node, return_type, context
-                          else
-                            fallback_to_any node do
-                              Errors::NoMethod.new(node: node, method: method_name, type: expanded_receiver_type)
-                            end
-                          end
-                        rescue => exn
-                          $stderr.puts exn.inspect
-                          exn.backtrace.each do |t|
-                            $stderr.puts t
-                          end
+      pair = case receiver_type
+             when AST::Types::Any
+               add_typing node, type: AST::Builtin.any_type
+
+             when nil
+               fallback_to_any node
+
+             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
+
+             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
+                   $stderr.puts exn.inspect
+                   exn.backtrace.each do |t|
+                     $stderr.puts t
+                   end
 
-                          fallback_to_any node do
-                            Errors::NoMethod.new(node: node, method: method_name, type: expanded_receiver_type)
-                          end
-                        end
-                      end
-                    end
+                   fallback_to_any node do
+                     Errors::NoMethod.new(node: node, method: method_name, type: expanded_receiver_type)
+                   end
+                 end
+               end
+             end
 
-      case return_type
+      case pair.type
       when nil, Errors::Base
         arguments.each do |arg|
           unless typing.has_type?(arg)
             if arg.type == :splat
-              type = synthesize(arg.children[0])
-              typing.add_typing(arg, AST::Builtin::Array.instance_type(type), context)
+              type = synthesize(arg.children[0]).type
+              add_typing(arg, type: AST::Builtin::Array.instance_type(type))
             else
               synthesize(arg)
             end
@@ -1759,16 +2029,18 @@ module Steep
             params = TypeInference::BlockParams.from_node(block_params, annotations: block_annotations)
             pairs = params.each.map {|param| [param, AST::Builtin.any_type]}
 
-            for_block, _ = for_block(block_annotations: block_annotations,
-                                     param_pairs: pairs,
-                                     method_return_type: AST::Builtin.any_type,
-                                     typing: typing)
+            for_block, _ = constr.for_block(block_annotations: block_annotations,
+                                            param_pairs: pairs,
+                                            method_return_type: AST::Builtin.any_type,
+                                            typing: typing)
+
+            for_block.typing.add_context_for_body(node, context: for_block.context)
 
             for_block.synthesize(block_body)
           end
         end
       else
-        return_type
+        pair
       end
     end
 
@@ -1789,6 +2061,8 @@ module Steep
         )
       end
 
+      lvar_env = context.lvar_env.pin_assignments.annotate(block_annotations)
+
       return_type = if block_annotations.break_type
                       union_type(method_return_type, block_annotations.break_type)
                     else
@@ -1816,7 +2090,8 @@ module Steep
           module_context: module_context,
           break_context: break_context,
           self_type: block_annotations.self_type || self_type,
-          type_env: block_type_env
+          type_env: block_type_env,
+          lvar_env: lvar_env
         )
       ), return_type]
     end
@@ -1830,70 +2105,72 @@ module Steep
     end
 
     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|
-            typing.new_child do |child_typing|
-              type, error = 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)
-              [
-                type,
-                child_typing,
-                error
-              ]
-            end
-          end
-
-          if (type, typing, error = results.find {|_, _, error| error })
-            typing.save!
-            [type, error]
+            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
+
+          if (type, constr, error = results.find {|_, _, error| error })
+            constr.typing.save!
+            [type,
+             update_lvar_env { constr.context.lvar_env },
+             error]
           else
-            _, typing, _ = results.first
-            typing.save!
+            types = results.map(&:first)
+
+            _, constr, _ = results.first
+            constr.typing.save!
 
-            [union_type(*results.map(&:first)), nil]
+            [union_type(*types),
+             update_lvar_env { constr.context.lvar_env },
+             nil]
           end
         end
 
       when method.intersection?
         yield_self do
           results = method.types.map do |method|
-            typing.new_child do |child_typing|
-              type, error = 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)
-              [
-                type,
-                child_typing,
-                error
-              ]
-            end
-          end
-
-          successes = results.select {|_, _, error| !error }
+            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,
+                                                             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 {|type, typing, _| type }
-            typing = successes[0][1]
-            typing.save!
+            types = successes.map(&:first)
+            constr = successes[0][1]
+            constr.typing.save!
 
-            [AST::Types::Intersection.build(types: types), nil]
+            [AST::Types::Intersection.build(types: types),
+             update_lvar_env { constr.context.lvar_env },
+             nil]
           else
-            type, typing, error = results.first
-            typing.save!
+            type, constr, error = results.first
+            constr.typing.save!
 
-            [type, error]
+            [type,
+             update_lvar_env { constr.context.lvar_env },
+             error]
           end
         end
 
@@ -1901,55 +2178,40 @@ module Steep
         yield_self do
           results = method.types.flat_map do |method_type|
             Steep.logger.tagged method_type.to_s do
-              case method_type
-              when Interface::MethodType
-                zips = args.zips(method_type.params, method_type.block&.type)
-
-                zips.map do |arg_pairs|
-                  typing.new_child do |child_typing|
-                    result = 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
-                    )
-
-                    [result, child_typing, method_type]
-                  end
-                end
-              when :any
-                typing.new_child do |child_typing|
-                  this = self.with_new_typing(child_typing)
-
-                  args.args.each do |arg|
-                    this.synthesize(arg)
-                  end
+              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
+                  )
 
-                  if block_body
-                    this.synthesize(block_body)
-                  end
+                  raise unless ret.is_a?(Array) && ret[1].is_a?(TypeConstruction)
 
-                  child_typing.add_typing node, AST::Builtin.any_type, context
+                  result, constr = ret
 
-                  [[AST::Builtin.any_type, child_typing, :any]]
+                  [result, constr, method_type]
                 end
               end
             end
           end
 
           unless results.empty?
-            result, call_typing, method_type = results.find {|result, _, _| !result.is_a?(Errors::Base) } || results.last
+            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)
-            call_typing = typing.new_child
           end
-          call_typing.save!
+          constr.typing.save!
 
           case result
           when Errors::Base
@@ -1969,9 +2231,13 @@ module Steep
               type = AST::Builtin.any_type
             end
 
-            [type, result]
+            [type,
+             update_lvar_env { constr.context.lvar_env },
+             result]
           else # Type
-            [result, nil]
+            [result,
+             update_lvar_env { constr.context.lvar_env },
+             nil]
           end
         end
       end
@@ -1984,7 +2250,7 @@ module Steep
       when :hash
         keyword_hash_type = AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type,
                                                              AST::Builtin.any_type)
-        typing.add_typing node, keyword_hash_type, context
+        add_typing node, type: keyword_hash_type
 
         given_keys = Set.new()
 
@@ -2008,7 +2274,7 @@ module Steep
                                params.rest_keywords
                              end
 
-              typing.add_typing key_node, AST::Builtin::Symbol.instance_type, context
+              add_typing key_node, type: AST::Builtin::Symbol.instance_type
 
               given_keys << key_symbol
 
@@ -2090,7 +2356,7 @@ module Steep
           hash_type = AST::Types::Record.new(elements: hash_elements)
         end
 
-        node_type = synthesize(node, hint: hash_type)
+        node_type = synthesize(node, hint: hash_type).type
 
         check_relation(sub_type: node_type, super_type: hash_type).else do
           return Errors::ArgumentTypeMismatch.new(
@@ -2118,6 +2384,8 @@ module Steep
         context: context
       )
 
+      constr = construction
+
       method_type.instantiate(instantiation).yield_self do |method_type|
         constraints = Subtyping::Constraints.new(unknowns: fresh_types.map(&:name))
         variance = Subtyping::VariableVariance.from_method_type(method_type)
@@ -2127,23 +2395,20 @@ module Steep
           case pair
           when Array
             (arg_node, param_type) = pair
-
             param_type = param_type.subst(instantiation)
 
-            arg_type = if arg_node.type == :splat
-                         type = construction.synthesize(arg_node.children[0])
-                         child_typing.add_typing(arg_node, type, context)
-                       else
-                         construction.synthesize(arg_node, hint: topdown_hint ? param_type : nil)
-                       end
+            arg_type, constr = if arg_node.type == :splat
+                                 constr.synthesize(arg_node.children[0])
+                               else
+                                 constr.synthesize(arg_node, hint: topdown_hint ? param_type : nil)
+                               end
 
             check_relation(sub_type: arg_type, super_type: param_type, constraints: constraints).else do |result|
-              return Errors::ArgumentTypeMismatch.new(
-                node: arg_node,
-                receiver_type: receiver_type,
-                expected: param_type,
-                actual: arg_type
-              )
+              return [Errors::ArgumentTypeMismatch.new(node: arg_node,
+                                                       receiver_type: receiver_type,
+                                                       expected: param_type,
+                                                       actual: arg_type),
+                      constr]
             end
           else
             # keyword
@@ -2153,7 +2418,7 @@ module Steep
                                        constraints: constraints)
 
             if result.is_a?(Errors::Base)
-              return result
+              return [result, constr]
             end
           end
         end
@@ -2168,10 +2433,9 @@ module Steep
           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
-            )
+            return [Errors::IncompatibleBlockParameters.new(node: node,
+                                                            method_type: method_type),
+                    constr]
           end
         end
 
@@ -2182,50 +2446,53 @@ module Steep
 
           begin
             method_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: occurence.params)).yield_self do |method_type|
-              block_type = construction.type_block(block_param_hint: method_type.block.type.params,
-                                                   block_type_hint: method_type.block.type.return_type,
-                                                   node_type_hint: method_type.return_type,
-                                                   block_params: block_params_,
-                                                   block_body: block_body,
-                                                   block_annotations: block_annotations,
-                                                   topdown_hint: topdown_hint)
-
-              result = check_relation(sub_type: block_type.return_type,
+              type, _ = constr.type_block(node: node,
+                                          block_param_hint: method_type.block.type.params,
+                                          block_type_hint: method_type.block.type.return_type,
+                                          node_type_hint: method_type.return_type,
+                                          block_params: block_params_,
+                                          block_body: block_body,
+                                          block_annotations: block_annotations,
+                                          topdown_hint: topdown_hint)
+
+              result = check_relation(sub_type: type.return_type,
                                       super_type: method_type.block.type.return_type,
                                       constraints: constraints)
 
               case result
               when Subtyping::Result::Success
                 method_type.return_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: fresh_vars)).yield_self do |ret_type|
-                  if block_annotations.break_type
-                    AST::Types::Union.new(types: [block_annotations.break_type, ret_type])
-                  else
-                    ret_type
-                  end
+                  ty = if block_annotations.break_type
+                         AST::Types::Union.new(types: [block_annotations.break_type, ret_type])
+                       else
+                         ret_type
+                       end
+                  [ty, constr]
                 end
 
               when Subtyping::Result::Failure
-                Errors::BlockTypeMismatch.new(node: node,
-                                              expected: method_type.block.type,
-                                              actual: block_type,
-                                              result: result)
+                [Errors::BlockTypeMismatch.new(node: node,
+                                               expected: method_type.block.type,
+                                               actual: type,
+                                               result: result),
+                 constr]
               end
             end
 
           rescue Subtyping::Constraints::UnsatisfiableConstraint => exn
-            Errors::UnsatisfiableConstraint.new(node: node,
-                                                method_type: method_type,
-                                                var: exn.var,
-                                                sub_type: exn.sub_type,
-                                                super_type: exn.super_type,
-                                                result: exn.result)
+            [Errors::UnsatisfiableConstraint.new(node: node,
+                                                 method_type: method_type,
+                                                 var: exn.var,
+                                                 sub_type: exn.sub_type,
+                                                 super_type: exn.super_type,
+                                                 result: exn.result),
+             constr]
           end
 
         when method_type.block && args.block_pass_arg
           begin
             method_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: occurence.params)).yield_self do |method_type|
-              block_type = synthesize(args.block_pass_arg,
-                                      hint: topdown_hint ? method_type.block.type : nil)
+              block_type, constr = constr.synthesize(args.block_pass_arg, hint: topdown_hint ? method_type.block.type : nil)
               result = check_relation(
                 sub_type: block_type,
                 super_type: method_type.block.yield_self {|expected_block|
@@ -2240,40 +2507,58 @@ module Steep
 
               case result
               when Subtyping::Result::Success
-                method_type.return_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: fresh_vars))
+                [
+                  method_type.return_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: fresh_vars)),
+                  constr
+                ]
 
               when Subtyping::Result::Failure
-                Errors::BlockTypeMismatch.new(node: node,
-                                              expected: method_type.block.type,
-                                              actual: block_type,
-                                              result: result)
+                [
+                  Errors::BlockTypeMismatch.new(node: node,
+                                                expected: method_type.block.type,
+                                                actual: block_type,
+                                                result: result),
+                  constr
+                ]
               end
             end
 
           rescue Subtyping::Constraints::UnsatisfiableConstraint => exn
-            Errors::UnsatisfiableConstraint.new(node: node,
-                                                method_type: method_type,
-                                                var: exn.var,
-                                                sub_type: exn.sub_type,
-                                                super_type: exn.super_type,
-                                                result: exn.result)
+            [
+              Errors::UnsatisfiableConstraint.new(node: node,
+                                                  method_type: method_type,
+                                                  var: exn.var,
+                                                  sub_type: exn.sub_type,
+                                                  super_type: exn.super_type,
+                                                  result: exn.result),
+              constr
+            ]
           end
 
         when (!method_type.block || method_type.block.optional?) && !block_params && !block_body && !args.block_pass_arg
           # OK, without block
-          method_type.subst(constraints.solution(checker, variance: variance, variables: fresh_vars, self_type: self_type)).return_type
+          [
+            method_type.subst(constraints.solution(checker, variance: variance, variables: fresh_vars, self_type: self_type)).return_type,
+            constr
+          ]
 
         when !method_type.block && (block_params || args.block_pass_arg)
-          Errors::UnexpectedBlockGiven.new(
-            node: node,
-            method_type: method_type
-          )
+          [
+            Errors::UnexpectedBlockGiven.new(
+              node: node,
+              method_type: method_type
+            ),
+            constr
+          ]
 
         when method_type.block && !method_type.block.optional? && !block_params && !block_body && !args.block_pass_arg
-          Errors::RequiredBlockMissing.new(
-            node: node,
-            method_type: method_type
-          )
+          [
+            Errors::RequiredBlockMissing.new(
+              node: node,
+              method_type: method_type
+            ),
+            constr
+          ]
 
         else
           raise "Unexpected case condition"
@@ -2281,7 +2566,7 @@ module Steep
       end
     end
 
-    def type_block(block_param_hint:, block_type_hint:, node_type_hint:, block_params:, block_body:, block_annotations:, topdown_hint:)
+    def type_block(node:, block_param_hint:, block_type_hint:, node_type_hint:, block_params:, block_body:, block_annotations:, topdown_hint:)
       block_param_pairs = block_param_hint && block_params.zip(block_param_hint)
 
       param_types_hash = {}
@@ -2297,15 +2582,12 @@ module Steep
         end
       end
 
-      block_type_env = type_env.dup.tap do |env|
-        param_types_hash.each do |name, type|
-          env.set(lvar: name, type: type)
-        end
-
-        block_annotations.lvar_types.each do |name, type|
-          env.set(lvar: name, type: type)
+      lvar_env = context.lvar_env.pin_assignments.yield_self do |env|
+        decls = param_types_hash.each.with_object({}) do |(name, type), hash|
+          hash[name] = TypeInference::LocalVariableTypeEnv::Entry.new(type: type)
         end
-      end
+        env.update(declared_types: env.declared_types.merge(decls))
+      end.annotate(block_annotations)
 
       break_type = if block_annotations.break_type
                      union_type(node_type_hint, block_annotations.break_type)
@@ -2334,33 +2616,38 @@ module Steep
           module_context: module_context,
           break_context: break_context,
           self_type: block_annotations.self_type || self_type,
-          type_env: block_type_env
+          type_env: type_env.dup,
+          lvar_env: lvar_env
         )
       )
 
+      for_block_body.typing.add_context_for_body(node, context: for_block_body.context)
+
       if block_body
-        return_type = if (body_type = block_context.body_type)
-                        for_block_body.check(block_body, body_type) do |expected, actual, result|
-                          typing.add_error Errors::BlockTypeMismatch.new(node: block_body,
-                                                                         expected: expected,
-                                                                         actual: actual,
-                                                                         result: result)
+        body_pair = if (body_type = block_context.body_type)
+                      for_block_body.check(block_body, body_type) do |expected, actual, result|
+                        typing.add_error Errors::BlockTypeMismatch.new(node: block_body,
+                                                                       expected: expected,
+                                                                       actual: actual,
+                                                                       result: result)
 
-                        end
-                        body_type
-                      else
-                        for_block_body.synthesize(block_body, hint: topdown_hint ? block_type_hint : nil)
                       end
+                    else
+                      for_block_body.synthesize(block_body, hint: topdown_hint ? block_type_hint : nil)
+                    end
+
+        range = block_body.loc.expression.end_pos..node.loc.end.begin_pos
+        typing.add_context(range, context: body_pair.context)
       else
-        return_type = AST::Builtin.any_type
+        body_pair = Pair.new(type: AST::Builtin.nil_type, constr: for_block_body)
       end
 
-      AST::Types::Proc.new(
-        params: block_param_hint || block_params.params_type,
-        return_type: return_type
-      ).tap do |type|
-        Steep.logger.debug "block_type == #{type}"
-      end
+      body_pair.with(
+        type: AST::Types::Proc.new(
+          params: block_param_hint || block_params.params_type,
+          return_type: body_pair.type
+        )
+      )
     end
 
     def each_child_node(node)
@@ -2464,6 +2751,7 @@ module Steep
     end
 
     def union_type(*types)
+      raise if types.empty?
       AST::Types::Union.build(types: types)
     end
 
@@ -2552,7 +2840,7 @@ module Steep
         typing.add_error Errors::FallbackAny.new(node: node)
       end
 
-      typing.add_typing node, AST::Builtin.any_type, context
+      add_typing node, type: AST::Builtin.any_type
     end
 
     def self_class?(node)
@@ -2598,21 +2886,6 @@ module Steep
       end
     end
 
-    def self.truthy_variables(node)
-      case node&.type
-      when :lvar
-        Set.new([node.children.first.name])
-      when :lvasgn
-        Set.new([node.children.first.name]) + truthy_variables(node.children[1])
-      when :and
-        truthy_variables(node.children[0]) + truthy_variables(node.children[1])
-      when :begin
-        truthy_variables(node.children.last)
-      else
-        Set.new()
-      end
-    end
-
     def self.value_variables(node)
       case node&.type
       when :lvar
@@ -2692,7 +2965,7 @@ module Steep
     def try_hash_type(node, hint)
       case hint
       when AST::Types::Record
-        typing.new_child do |child_typing|
+        typing.new_child(node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }) do |child_typing|
           new_construction = with_new_typing(child_typing)
           elements = {}
 
@@ -2709,7 +2982,7 @@ module Steep
                           end
 
               value_hint = hint.elements[key_value]
-              value_type = new_construction.synthesize(value, hint: value_hint)
+              value_type = new_construction.synthesize(value, hint: value_hint).type
 
               if value_hint
                 if check_relation(sub_type: value_type, super_type: value_hint).success?
@@ -2726,12 +2999,15 @@ module Steep
           child_typing.save!
 
           hash = AST::Types::Record.new(elements: elements)
-          typing.add_typing(node, hash, context)
+          add_typing(node, type: hash)
         end
       when AST::Types::Union
-        hint.types.find do |type|
-          try_hash_type(node, type)
+        hint.types.each do |type|
+          if pair = try_hash_type(node, type)
+            return pair
+          end
         end
+        nil
       end
     end
   end