steep 1.0.0 → 1.1.0.pre.1

data/lib/steep/type_construction.rb

@@ -30,6 +30,13 @@ module Steep
       end
     end
 
+    include NodeHelper
+
+    def inspect
+      s = "#<%s:%#018x " % [self.class, object_id]
+      s + ">"
+    end
+
     include ModuleHelper
 
     attr_reader :checker
@@ -59,10 +66,6 @@ module Steep
       context.self_type
     end
 
-    def type_env
-      context.type_env
-    end
-
     def variable_context
       context.variable_context
     end
@@ -85,9 +88,9 @@ 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))
+    def with_updated_context(type_env: self.context.type_env)
+      unless type_env.equal?(self.context.type_env)
+        with(context: self.context.with(type_env: type_env))
       else
         self
       end
@@ -111,8 +114,8 @@ module Steep
       with(context: yield(self.context))
     end
 
-    def update_lvar_env
-      with_updated_context(lvar_env: yield(context.lvar_env))
+    def update_type_env
+      with_updated_context(type_env: yield(context.type_env))
     end
 
     def check_relation(sub_type:, super_type:, constraints: Subtyping::Constraints.empty)
@@ -129,14 +132,15 @@ module Steep
       end
     end
 
-    def for_new_method(method_name, node, args:, self_type:, definition:)
-      annots = source.annotations(block: node, factory: checker.factory, context: nesting)
-      type_env = TypeInference::TypeEnv.new(subtyping: checker, const_env: module_context&.const_env || self.type_env.const_env)
-
-      self.type_env.const_types.each do |name, type|
-        type_env.set(const: name, type: type)
+    def no_subtyping?(sub_type:, super_type:, constraints: Subtyping::Constraints.empty)
+      result = check_relation(sub_type: sub_type, super_type: super_type, constraints: constraints)
+      if result.failure?
+        result
       end
+    end
 
+    def for_new_method(method_name, node, args:, self_type:, definition:)
+      annots = source.annotations(block: node, factory: checker.factory, context: nesting)
       definition_method_type = if definition
                                  definition.methods[method_name]&.yield_self do |method|
                                    method.method_types
@@ -189,27 +193,6 @@ module Steep
         super_method: super_method
       )
 
-      if definition
-        definition.instance_variables.each do |name, decl|
-          type_env.set(ivar: name, type: checker.factory.type(decl.type))
-        end
-      end
-
-      type_env = type_env.with_annotations(
-        ivar_types: annots.ivar_types,
-        const_types: annots.const_types,
-        self_type: annots.self_type || self_type,
-        instance_type: module_context.instance_type,
-        class_type: module_context.module_type
-      )
-
-      lvar_env = TypeInference::LocalVariableTypeEnv.empty(
-        subtyping: checker,
-        self_type: annots.self_type || self_type,
-        instance_type: module_context.instance_type,
-        class_type: module_context.module_type
-      )
-
       method_params =
         if method_type
           TypeInference::MethodParams.build(node: node, method_type: method_type)
@@ -217,18 +200,33 @@ module Steep
           TypeInference::MethodParams.empty(node: node)
         end
 
-      method_params.each_param do |param|
-        lvar_env = lvar_env.assign(param.name, type: param.var_type, node: param.node) {
-          raise "Unexpected assignment error: #{param.name}"
-        }
+      local_variable_types = method_params.each_param.with_object({}) do |param, hash|
+        if param.name
+          hash[param.name] = param.var_type
+        end
       end
+      type_env = context.type_env.assign_local_variables(local_variable_types)
+
+      type_env = TypeInference::TypeEnvBuilder.new(
+        TypeInference::TypeEnvBuilder::Command::ImportLocalVariableAnnotations.new(annots).merge!.on_duplicate! do |name, original, annotated|
+          param = method_params.each_param.find {|param| param.name == name }
+          if result = no_subtyping?(sub_type: original, super_type: annotated)
+            typing.add_error Diagnostic::Ruby::IncompatibleAnnotation.new(
+              node: param.node,
+              var_name: name,
+              result: result,
+              relation: result.relation
+            )
+          end
+        end,
+        TypeInference::TypeEnvBuilder::Command::ImportInstanceVariableDefinition.new(definition, checker.factory),
+        TypeInference::TypeEnvBuilder::Command::ImportInstanceVariableAnnotations.new(annots).merge!
+      ).build(type_env)
 
       method_params.errors.each do |error|
         typing.add_error error
       end
 
-      lvar_env = lvar_env.annotate(annots)
-
       call_context = case self_type
                      when nil
                        TypeInference::MethodCall::UnknownContext.new()
@@ -255,7 +253,6 @@ module Steep
           break_context: nil,
           self_type: annots.self_type || self_type,
           type_env: type_env,
-          lvar_env: lvar_env,
           call_context: call_context,
           variable_context: variable_context
         ),
@@ -295,9 +292,9 @@ module Steep
       end
     end
 
-    def default_module_context(implement_module_name, const_env:)
+    def default_module_context(implement_module_name, nesting:)
       if implement_module_name
-        module_name = checker.factory.absolute_type_name(implement_module_name.name, context: const_env.context)
+        module_name = checker.factory.absolute_type_name(implement_module_name.name, context: nesting)
         module_args = implement_module_name.args.map {|name| AST::Types::Var.new(name: name) }
 
         instance_def = checker.factory.definition_builder.build_instance(module_name)
@@ -310,7 +307,7 @@ module Steep
           instance_type: instance_type,
           module_type: module_type,
           implement_name: implement_module_name,
-          const_env: const_env,
+          nesting: nesting,
           class_name: module_name,
           instance_definition: instance_def,
           module_definition: module_def
@@ -320,7 +317,7 @@ module Steep
           instance_type: nil,
           module_type: nil,
           implement_name: nil,
-          const_env: self.module_context.const_env,
+          nesting: nesting,
           class_name: self.module_context.class_name,
           module_definition: nil,
           instance_definition: nil
@@ -331,16 +328,10 @@ module Steep
     def for_module(node, new_module_name)
       new_nesting = [nesting, new_module_name || false]
 
-      module_const_env = TypeInference::ConstantEnv.new(
-        factory: checker.factory,
-        context: new_nesting,
-        resolver: self.module_context.const_env.resolver
-      )
-
       annots = source.annotations(block: node, factory: checker.factory, context: new_nesting)
 
       implement_module_name = implement_module(module_name: new_module_name, annotations: annots)
-      module_context = default_module_context(implement_module_name, const_env: module_const_env)
+      module_context = default_module_context(implement_module_name, nesting: new_nesting)
 
       unless implement_module_name
         module_context = module_context.update(
@@ -391,18 +382,6 @@ module Steep
         module_context = module_context.update(module_type: annots.self_type)
       end
 
-      module_type_env = TypeInference::TypeEnv.build(annotations: annots,
-                                                     subtyping: checker,
-                                                     const_env: module_const_env,
-                                                     signatures: checker.factory.env)
-
-      lvar_env = TypeInference::LocalVariableTypeEnv.empty(
-        subtyping: checker,
-        self_type: module_context.module_type,
-        instance_type: module_context.instance_type,
-        class_type: module_context.module_type
-      ).annotate(annots)
-
       if implement_module_name
         definition = checker.factory.definition_builder.build_instance(implement_module_name.name)
         type_params = definition.type_params_decl.map do |param|
@@ -418,6 +397,20 @@ module Steep
         variable_context = TypeInference::Context::TypeVariableContext.empty
       end
 
+      module_const_env = TypeInference::ConstantEnv.new(
+        factory: checker.factory,
+        context: new_nesting,
+        resolver: context.type_env.constant_env.resolver
+      )
+
+      module_type_env = TypeInference::TypeEnvBuilder.new(
+        TypeInference::TypeEnvBuilder::Command::ImportGlobalDeclarations.new(checker.factory),
+        TypeInference::TypeEnvBuilder::Command::ImportLocalVariableAnnotations.new(annots),
+        TypeInference::TypeEnvBuilder::Command::ImportInstanceVariableDefinition.new(module_context.module_definition, checker.factory),
+        TypeInference::TypeEnvBuilder::Command::ImportInstanceVariableAnnotations.new(annots).merge!,
+        TypeInference::TypeEnvBuilder::Command::ImportConstantAnnotations.new(annots)
+      ).build(TypeInference::TypeEnv.new(module_const_env))
+
       self.class.new(
         checker: checker,
         source: source,
@@ -430,7 +423,6 @@ module Steep
           module_context: module_context,
           self_type: module_context.module_type,
           type_env: module_type_env,
-          lvar_env: lvar_env,
           call_context: TypeInference::MethodCall::ModuleContext.new(type_name: module_context.class_name),
           variable_context: variable_context
         )
@@ -451,11 +443,11 @@ module Steep
       class_const_env = TypeInference::ConstantEnv.new(
         factory: checker.factory,
         context: new_nesting,
-        resolver: self.module_context.const_env.resolver
+        resolver: context.type_env.constant_env.resolver
       )
 
       implement_module_name = implement_module(module_name: new_class_name, super_name: super_class_name, annotations: annots)
-      module_context = default_module_context(implement_module_name, const_env: class_const_env)
+      module_context = default_module_context(implement_module_name, nesting: new_nesting)
 
       if implement_module_name
         if super_class_name && implement_module_name.name == absolute_name(super_class_name)
@@ -492,17 +484,13 @@ module Steep
       end
       variable_context = TypeInference::Context::TypeVariableContext.new(type_params)
 
-      class_type_env = TypeInference::TypeEnv.build(annotations: annots,
-                                                    subtyping: checker,
-                                                    const_env: class_const_env,
-                                                    signatures: checker.factory.env)
-
-      lvar_env = TypeInference::LocalVariableTypeEnv.empty(
-        subtyping: checker,
-        self_type: module_context.module_type,
-        instance_type: module_context.instance_type,
-        class_type: module_context.module_type
-      ).annotate(annots)
+      singleton_definition = checker.factory.definition_builder.build_singleton(module_context.class_name)
+      class_type_env = TypeInference::TypeEnvBuilder.new(
+        TypeInference::TypeEnvBuilder::Command::ImportGlobalDeclarations.new(checker.factory),
+        TypeInference::TypeEnvBuilder::Command::ImportConstantAnnotations.new(annots),
+        TypeInference::TypeEnvBuilder::Command::ImportLocalVariableAnnotations.new(annots),
+        TypeInference::TypeEnvBuilder::Command::ImportInstanceVariableDefinition.new(singleton_definition, checker.factory),
+      ).build(TypeInference::TypeEnv.new(class_const_env))
 
       class_body_context = TypeInference::Context.new(
         method_context: nil,
@@ -511,7 +499,6 @@ module Steep
         break_context: nil,
         self_type: module_context.module_type,
         type_env: class_type_env,
-        lvar_env: lvar_env,
         call_context: TypeInference::MethodCall::ModuleContext.new(type_name: module_context.class_name),
         variable_context: variable_context
       )
@@ -578,6 +565,8 @@ module Steep
                             when AST::Types::Name::Instance
                               type_name = instance_type.name
                               checker.factory.definition_builder.build_instance(type_name)
+                            else
+                              return
                             end
 
       module_definition = case module_type
@@ -592,23 +581,20 @@ module Steep
         instance_type: annots.instance_type || instance_type,
         module_type: annots.self_type || annots.module_type || module_type,
         implement_name: nil,
-        const_env: self.module_context.const_env,
+        nesting: nesting,
         class_name: self.module_context.class_name,
         module_definition: module_definition,
         instance_definition: instance_definition
       )
 
-      type_env = TypeInference::TypeEnv.build(annotations: annots,
-                                              subtyping: checker,
-                                              const_env: self.module_context.const_env,
-                                              signatures: checker.factory.env)
-
-      lvar_env = TypeInference::LocalVariableTypeEnv.empty(
-        subtyping: checker,
-        self_type: module_context.module_type,
-        instance_type: module_context.instance_type,
-        class_type: module_context.module_type
-      ).annotate(annots)
+      singleton_definition = checker.factory.definition_builder.build_singleton(module_context.class_name)
+      type_env =
+        TypeInference::TypeEnvBuilder.new(
+          TypeInference::TypeEnvBuilder::Command::ImportGlobalDeclarations.new(checker.factory),
+          TypeInference::TypeEnvBuilder::Command::ImportConstantAnnotations.new(annots),
+          TypeInference::TypeEnvBuilder::Command::ImportLocalVariableAnnotations.new(annots),
+          TypeInference::TypeEnvBuilder::Command::ImportInstanceVariableDefinition.new(instance_definition, checker.factory)
+        ).build(TypeInference::TypeEnv.new(context.type_env.constant_env))
 
       body_context = TypeInference::Context.new(
         method_context: nil,
@@ -617,7 +603,6 @@ module Steep
         break_context: nil,
         self_type: module_context.module_type,
         type_env: type_env,
-        lvar_env: lvar_env,
         call_context: TypeInference::MethodCall::ModuleContext.new(type_name: module_context.class_name),
         variable_context: TypeInference::Context::TypeVariableContext.empty  # Assuming `::Class` and `::Module` don't have type params
       )
@@ -631,39 +616,15 @@ module Steep
       )
     end
 
-    def for_branch(node, truthy_vars: Set.new, type_case_override: nil, break_context: context.break_context)
+    def for_branch(node, break_context: context.break_context)
       annots = source.annotations(block: node, factory: checker.factory, context: nesting)
 
-      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
-
-      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)
+      type_env = TypeInference::TypeEnvBuilder.new(
+        TypeInference::TypeEnvBuilder::Command::ImportLocalVariableAnnotations.new(annots).merge!.on_duplicate! do |name, outer_type, annotation_type|
+          relation = Subtyping::Relation.new(sub_type: annotation_type, super_type: outer_type)
+          if result = no_subtyping?(sub_type: annotation_type, super_type: outer_type)
             typing.add_error(
-              Diagnostic::Ruby::IncompatibleTypeCase.new(
+              Diagnostic::Ruby::IncompatibleAnnotation.new(
                 node: node,
                 var_name: name,
                 relation: relation,
@@ -672,53 +633,11 @@ module Steep
             )
           end
         end
-      end
-
-      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(
-          Diagnostic::Ruby::IncompatibleAnnotation.new(
-            node: node,
-            var_name: var,
-            relation: relation,
-            result: result
-          )
-        )
-      end
-
-      type_env = context.type_env
+      ).build(context.type_env)
 
-      if type_case_override
-        type_env = type_env.with_annotations(
-          self_type: self_type,
-          instance_type: module_context.instance_type,
-          class_type: module_context.module_type
-        )
-      end
-
-      type_env = type_env.with_annotations(
-        ivar_types: annots.ivar_types,
-        const_types: annots.const_types,
-        gvar_types: {},
-        self_type: self_type,
-        instance_type: module_context.instance_type,
-        class_type: module_context.module_type
-      ) do |var, relation, result|
-        typing.add_error(
-          Diagnostic::Ruby::IncompatibleAnnotation.new(
-            node: node,
-            var_name: var,
-            relation: relation,
-            result: result
-          )
-        )
+      update_context do |context|
+        context.with(type_env: type_env, break_context: break_context)
       end
-
-      update_context {|context|
-        context.with(type_env: type_env,
-                     break_context: break_context,
-                     lvar_env: lvar_env)
-      }
     end
 
     def add_typing(node, type:, constr: self)
@@ -774,8 +693,7 @@ module Steep
 
         when :lvasgn
           yield_self do
-            var, rhs = node.children
-            name = var
+            name, rhs = node.children
 
             case name
             when :_, :__any__
@@ -785,42 +703,56 @@ module Steep
             when :__skip__
               add_typing(node, type: AST::Builtin.any_type)
             else
-              if declared_type = context.lvar_env.declared_types[name]&.type
-                case hint
-                when nil
-                  hint = declared_type
-                else
-                  if check_relation(sub_type: declared_type, super_type: hint).success?
-                    # declared_type is compatible with hint and more specific to hint.
-                    # This typically happens when hint is untyped, top, or void.
-                    hint = declared_type
-                  end
+              if enforced_type = context.type_env.enforced_type(name)
+                case
+                when hint == nil
+                  hint = enforced_type
+                when check_relation(sub_type: enforced_type, super_type: hint).success?
+                  # enforced_type is compatible with hint and more specific to hint.
+                  # This typically happens when hint is untyped, top, or void.
+                  hint = enforced_type
                 end
               end
 
-              rhs_result = synthesize(rhs, hint: hint)
+              if rhs
+                rhs_type, rhs_constr, rhs_context = synthesize(rhs, hint: hint).to_ary
+
+                constr = rhs_constr.update_type_env do |type_env|
+                  var_type = rhs_type
+
+                  if enforced_type = type_env.enforced_type(name)
+                    if result = no_subtyping?(sub_type: rhs_type, super_type: enforced_type)
+                      typing.add_error(
+                        Diagnostic::Ruby::IncompatibleAssignment.new(
+                          node: node,
+                          lhs_type: enforced_type,
+                          rhs_type: rhs_type,
+                          result: result
+                        )
+                      )
 
-              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(
-                    Diagnostic::Ruby::IncompatibleAssignment.new(
-                      node: node,
-                      lhs_type: declared_type,
-                      rhs_type: actual_type,
-                      result: result
-                    )
-                  )
+                      var_type = enforced_type
+                    end
+
+                    if rhs_type.is_a?(AST::Types::Any)
+                      var_type = enforced_type
+                    end
+                  end
+
+                  type_env.assign_local_variable(name, var_type, enforced_type)
                 end
-              end
 
-              constr.add_typing(node, type: rhs_result.type)
+                constr.add_typing(node, type: rhs_type)
+              else
+                add_typing(node, type: enforced_type || AST::Builtin.any_type)
+              end
             end
           end
 
         when :lvar
           yield_self do
             var = node.children[0]
-            if (type = context.lvar_env[var])
+            if (type = context.type_env[var])
               add_typing node, type: type
             else
               fallback_to_any(node)
@@ -829,17 +761,21 @@ module Steep
 
         when :ivasgn
           name = node.children[0]
-          value = node.children[1]
+          rhs = node.children[1]
+
+          rhs_type, constr = synthesize(rhs, hint: context.type_env[name])
 
-          type_ivasgn(name, value, node)
+          constr.ivasgn(node, rhs_type)
 
         when :ivar
           yield_self do
             name = node.children[0]
-            type = type_env.get(ivar: name) do
+
+            if type = context.type_env[name]
+              add_typing(node, type: type)
+            else
               fallback_to_any node
             end
-            add_typing(node, type: type)
           end
 
         when :send
@@ -860,22 +796,22 @@ module Steep
 
         when :csend
           yield_self do
-            pair = if self_class?(node)
-                     module_type = expand_alias(module_context.module_type)
-                     type = if module_type.is_a?(AST::Types::Name::Singleton)
-                              AST::Types::Name::Singleton.new(name: module_type.name)
-                            else
-                              module_type
-                            end
-                     add_typing(node, type: type)
-                   else
-                     type_send(node, send_node: node, block_params: nil, block_body: nil, unwrap: true)
-                   end
+            send_type, constr =
+              if self_class?(node)
+                module_type = expand_alias(module_context.module_type)
+                type = if module_type.is_a?(AST::Types::Name::Singleton)
+                         AST::Types::Name::Singleton.new(name: module_type.name)
+                       else
+                         module_type
+                       end
+                add_typing(node, type: type).to_ary
+              else
+                type_send(node, send_node: node, block_params: nil, block_body: nil, unwrap: true).to_ary
+              end
 
-            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))
+            constr
+              .update_type_env { context.type_env.join(constr.context.type_env, context.type_env) }
+              .add_typing(node, type: union_type(send_type, AST::Builtin.nil_type))
           end
 
         when :match_with_lvasgn
@@ -1219,35 +1155,30 @@ module Steep
           value = node.children[0]
 
           if break_context
-            if break_type = break_context.break_type
-              if value
-                check(value, break_type) do |break_type, actual_type, result|
+            break_type = (break_context || raise).break_type
+
+            if value
+              check(value, break_type) do |break_type, actual_type, result|
+                typing.add_error(
+                  Diagnostic::Ruby::BreakTypeMismatch.new(
+                    node: node,
+                    expected: break_type,
+                    actual: actual_type,
+                    result: result
+                  )
+                )
+              end
+            else
+              unless break_type.is_a?(AST::Types::Bot)
+                check_relation(sub_type: AST::Builtin.nil_type, super_type: break_type).else do |result|
                   typing.add_error(
-                    Diagnostic::Ruby::BreakTypeMismatch.new(
+                    Diagnostic::Ruby::ImplicitBreakValueMismatch.new(
                       node: node,
-                      expected: break_type,
-                      actual: actual_type,
+                      jump_type: break_type,
                       result: result
                     )
                   )
                 end
-              else
-                unless break_type.is_a?(AST::Types::Bot)
-                  check_relation(sub_type: AST::Builtin.nil_type, super_type: break_type).else do |result|
-                    typing.add_error(
-                      Diagnostic::Ruby::ImplicitBreakValueMismatch.new(
-                        node: node,
-                        jump_type: break_type,
-                        result: result
-                      )
-                    )
-                  end
-                end
-              end
-            else
-              if value
-                synthesize(value)
-                typing.add_error Diagnostic::Ruby::UnexpectedJumpValue.new(node: node)
               end
             end
           else
@@ -1309,7 +1240,7 @@ module Steep
 
             node.children.each do |arg|
               if arg.is_a?(Symbol)
-                type = context.lvar_env[arg]
+                type = context.type_env[arg]
 
                 if type
                   _, constr = add_typing(node, type: type)
@@ -1339,7 +1270,7 @@ module Steep
         when :arg, :kwarg
           yield_self do
             var = node.children[0]
-            type = context.lvar_env[var]
+            type = context.type_env[var]
 
             if type
               add_typing(node, type: type)
@@ -1354,33 +1285,33 @@ module Steep
             var = node.children[0]
             rhs = node.children[1]
 
-            var_type = context.lvar_env[var]
-            node_type, constr = synthesize(rhs, hint: var_type)
+            var_type = context.type_env[var]
 
-            type = AST::Types::Union.build(types: [var_type, node_type])
-
-            constr_ = constr.update_lvar_env do |env|
-              env.assign(var, node: node, type: type) do |declared_type, type, result|
+            if var_type
+              type, constr = check(rhs, var_type) do |expected_type, actual_type, result|
                 typing.add_error(
                   Diagnostic::Ruby::IncompatibleAssignment.new(
                     node: node,
-                    lhs_type: declared_type,
-                    rhs_type: type,
+                    lhs_type: expected_type,
+                    rhs_type: actual_type,
                     result: result
                   )
                 )
               end
+            else
+              type, constr = synthesize(rhs)
             end
 
-            add_typing(node, type: type, constr: constr_)
+            constr.add_typing(node, type: type)
           end
 
         when :restarg
           yield_self do
             var = node.children[0]
-            type = context.lvar_env[var]
+            type = context.type_env[var]
+
             unless type
-              if context&.method_context&.method_type
+              if context.method_context&.method_type
                 Steep.logger.error { "Unknown variable: #{node}" }
               end
               typing.add_error Diagnostic::Ruby::FallbackAny.new(node: node)
@@ -1393,9 +1324,9 @@ module Steep
         when :kwrestarg
           yield_self do
             var = node.children[0]
-            type = context.lvar_env[var]
+            type = context.type_env[var]
             unless type
-              if context&.method_context&.method_type
+              if context.method_context&.method_type
                 Steep.logger.error { "Unknown variable: #{node}" }
               end
               typing.add_error Diagnostic::Ruby::FallbackAny.new(node: node)
@@ -1447,7 +1378,8 @@ module Steep
         when :true, :false
           ty = node.type == :true ? AST::Types::Literal.new(value: true) : AST::Types::Literal.new(value: false)
 
-          if hint && check_relation(sub_type: ty, super_type: hint).success?
+          if hint && check_relation(sub_type: ty, super_type: hint).success? && !hint.is_a?(AST::Types::Any) && !hint.is_a?(AST::Types::Top)
+
             add_typing(node, type: hint)
           else
             add_typing(node, type: AST::Types::Boolean.new)
@@ -1568,7 +1500,7 @@ module Steep
 
         when :sclass
           yield_self do
-            type, constr = synthesize(node.children[0])
+            type, constr = synthesize(node.children[0]).to_ary
 
             with_sclass_constr(node, type) do |constructor|
               unless constructor
@@ -1578,8 +1510,7 @@ module Steep
                     message: "sclass receiver must be instance type or singleton type, but type given `#{type}`"
                   )
                 )
-                constr.add_typing(node, type: AST::Builtin.nil_type)
-                return
+                return constr.add_typing(node, type: AST::Builtin.nil_type)
               end
 
               constructor.typing.add_context_for_node(node, context: constructor.context)
@@ -1739,137 +1670,152 @@ module Steep
 
         when :and
           yield_self do
-            left, right = node.children
+            left_node, right_node = node.children
 
-            left_type, constr = synthesize(left, hint: hint, condition: true)
+            left_type, constr, left_context = synthesize(left_node, hint: hint, condition: true).to_ary
 
             interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
-            truthy_env, falsey_env = interpreter.eval(env: constr.context.lvar_env, type: left_type, node: left)
+            left_truthy_env, left_falsy_env = interpreter.eval(env: left_context.type_env, node: left_node)
 
             if left_type.is_a?(AST::Types::Logic::Env)
               left_type = left_type.type
             end
 
-            right_type, constr = constr
-                                   .update_lvar_env { truthy_env }
-                                   .tap {|constr| typing.add_context_for_node(right, context: constr.context) }
-                                   .for_branch(right)
-                                   .synthesize(right, hint: hint, condition: true)
+            right_type, constr, right_context =
+              constr
+                .update_type_env { left_truthy_env }
+                .tap {|constr| typing.add_context_for_node(right_node, context: constr.context) }
+                .for_branch(right_node)
+                .synthesize(right_node, hint: hint, condition: true).to_ary
 
-            truthy_env, _ = interpreter.eval(env: constr.context.lvar_env, type: right_type, node: right)
+            right_truthy_env, right_falsy_env = interpreter.eval(env: right_context.type_env, node: right_node)
 
-            env = if right_type.is_a?(AST::Types::Bot)
-                    falsey_env
-                  else
-                    context.lvar_env.join(falsey_env, constr.context.lvar_env)
-                  end
+            env =
+              if right_type.is_a?(AST::Types::Bot)
+                left_falsy_env
+              else
+                context.type_env.join(left_falsy_env, right_context.type_env)
+              end
 
-            type = case
-                   when check_relation(sub_type: left_type, super_type: AST::Types::Boolean.new).success?
-                     union_type(left_type, right_type)
-                   else
-                     union_type(right_type, AST::Builtin.nil_type)
-                   end
+            type =
+              case
+              when check_relation(sub_type: left_type, super_type: AST::Types::Boolean.new).success?
+                union_type(left_type, right_type)
+              else
+                union_type(right_type, AST::Builtin.nil_type)
+              end
 
-            type = AST::Types::Logic::Env.new(truthy: truthy_env, falsy: env, type: type) if condition
+            if condition
+              type = AST::Types::Logic::Env.new(
+                truthy: right_truthy_env,
+                falsy: context.type_env.join(left_falsy_env, right_falsy_env),
+                type: type
+              )
+            end
 
-            add_typing(node,
-                       type: type,
-                       constr: constr.update_lvar_env { env })
+            constr.update_type_env { env }.add_typing(node, type: type)
           end
 
         when :or
           yield_self do
-            left, right = node.children
+            left_node, right_node = node.children
 
-            left_type, constr = synthesize(left, hint: hint, condition: true)
+            left_type, constr, left_context = synthesize(left_node, hint: hint, condition: true).to_ary
 
             interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
-            truthy_env, falsey_env = interpreter.eval(env: constr.context.lvar_env, type: left_type, node: left)
+            left_truthy_env, left_falsy_env = interpreter.eval(env: left_context.type_env, node: left_node)
 
             if left_type.is_a?(AST::Types::Logic::Env)
               left_type = left_type.type
             end
             left_type, _ = checker.factory.unwrap_optional(left_type)
 
-            right_type, constr = constr
-                                   .update_lvar_env { falsey_env }
-                                   .tap {|constr| typing.add_context_for_node(right, context: constr.context) }
-                                   .for_branch(right)
-                                   .synthesize(right, hint: left_type, condition: true)
+            right_type, constr, right_context =
+              constr
+                .update_type_env { left_falsy_env }
+                .tap {|constr| typing.add_context_for_node(right_node, context: constr.context) }
+                .for_branch(right_node)
+                .synthesize(right_node, hint: left_type, condition: true).to_ary
 
-            _, falsey_env = interpreter.eval(env: falsey_env, type: right_type, node: right)
+            right_truthy_env, right_falsy_env = interpreter.eval(env: left_falsy_env, node: right_node)
 
             env = if right_type.is_a?(AST::Types::Bot)
-                    truthy_env
+                    left_truthy_env
                   else
-                    context.lvar_env.join(truthy_env, constr.context.lvar_env)
+                    context.type_env.join(left_truthy_env, right_context.type_env)
                   end
 
-            type = case
-                   when check_relation(sub_type: left_type, super_type: AST::Builtin.bool_type).success? && !left_type.is_a?(AST::Types::Any)
-                     AST::Builtin.bool_type
-                   else
-                     union_type(left_type, right_type)
-                   end
+            type =
+              case
+              when check_relation(sub_type: left_type, super_type: AST::Builtin.bool_type).success? && !left_type.is_a?(AST::Types::Any)
+                AST::Builtin.bool_type
+              else
+                union_type(left_type, right_type)
+              end
 
-            type = AST::Types::Logic::Env.new(truthy: env, falsy: falsey_env, type: type) if condition
+            if condition
+              type = AST::Types::Logic::Env.new(
+                truthy: context.type_env.join(left_truthy_env, right_truthy_env),
+                falsy: right_falsy_env,
+                type: type
+              )
+            end
 
-            add_typing(node,
-                       type: type,
-                       constr: constr.update_lvar_env { env })
+            constr.update_type_env { env }.add_typing(node, type: type)
           end
 
         when :if
-          cond, true_clause, false_clause = node.children
-
-          cond_type, constr = synthesize(cond, condition: true)
-          interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: constr.typing)
-          truthy_env, falsey_env = interpreter.eval(env: constr.context.lvar_env, type: cond_type, node: cond)
-
-          if true_clause
-            true_pair = constr
-                          .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
+          yield_self do
+            cond, true_clause, false_clause = node.children
+
+            cond_type, constr = synthesize(cond, condition: true).to_ary
+            interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: constr.typing)
+            truthy_env, falsy_env = interpreter.eval(env: constr.context.type_env, node: cond)
+
+            if true_clause
+              true_pair =
+                constr
+                  .update_type_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_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
+            if false_clause
+              false_pair =
+                constr
+                  .update_type_env { falsy_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 = []
+            constr = constr.update_type_env do |env|
+              envs = []
 
-            if true_pair
-              unless true_pair.type.is_a?(AST::Types::Bot)
-                envs << true_pair.context.lvar_env
+              if true_pair
+                unless true_pair.type.is_a?(AST::Types::Bot)
+                  envs << true_pair.context.type_env
+                end
+              else
+                envs << truthy_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
+              if false_pair
+                unless false_pair.type.is_a?(AST::Types::Bot)
+                  envs << false_pair.context.type_env
+                end
+              else
+                envs << falsy_env
               end
-            else
-              envs << falsey_env
+
+              env.join(*envs)
             end
 
-            env.join(*envs)
+            node_type = union_type(true_pair&.type || AST::Builtin.nil_type, false_pair&.type || AST::Builtin.nil_type)
+            add_typing(node, type: node_type, constr: constr)
           end
 
-          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, els = node.children
@@ -1878,49 +1824,41 @@ module Steep
             interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
 
             if cond
-              branch_pairs = []
+              branch_results = []
 
-              cond_type, constr = constr.synthesize(cond)
-              _, cond_vars = interpreter.decompose_value(cond)
-              unless cond_vars.empty?
-                first_var = cond_vars.to_a[0]
-                var_node = cond.updated(:lvar, [first_var])
-              else
-                first_var = nil
-                var_node = cond
-              end
+              cond_type, constr = constr.synthesize(cond).to_ary
+              cond_value_node, cond_vars = interpreter.decompose_value(cond)
 
               when_constr = constr
               whens.each do |clause|
+                # @type var tests: Array[Parser::AST::Node]
+                # @type var body: Parser::AST::Node?
                 *tests, body = clause.children
 
                 test_constr = when_constr
+                # @type var test_envs: Array[TypeInference::TypeEnv]
                 test_envs = []
 
                 tests.each do |test|
-                  test_node = test.updated(:send, [test, :===, var_node])
-                  test_type, test_constr = test_constr.synthesize(test_node, condition: true)
-                  truthy_env, falsy_env = interpreter.eval(type: test_type, node: test_node, env: test_constr.context.lvar_env)
-                  truthy_env = cond_vars.inject(truthy_env) do |env, var|
-                    env.assign!(var, node: test_node, type: env[first_var])
-                  end
-                  falsy_env = cond_vars.inject(falsy_env) do |env, var|
-                    env.assign!(var, node: test_node, type: env[first_var])
-                  end
+                  test_node = test.updated(:send, [test, :===, cond])
+                  test_type, test_constr = test_constr.synthesize(test_node, condition: true).to_ary
+                  truthy_env, falsy_env = interpreter.eval(node: test_node, env: test_constr.context.type_env)
 
                   test_envs << truthy_env
-                  test_constr = test_constr.update_lvar_env { falsy_env }
+
+                  test_constr = test_constr.update_type_env { falsy_env }
                 end
 
-                body_constr = when_constr.update_lvar_env {|env| env.except(cond_vars).join(*test_envs) }
+                body_constr = when_constr.update_type_env {|env| env.join(*test_envs) }
 
                 if body
-                  branch_pairs << body_constr
-                                    .for_branch(body)
-                                    .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
-                                    .synthesize(body, hint: hint)
+                  branch_results <<
+                    body_constr
+                      .for_branch(body)
+                      .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
+                      .synthesize(body, hint: hint)
                 else
-                  branch_pairs << Pair.new(type: AST::Builtin.nil_type, constr: body_constr)
+                  branch_results << Pair.new(type: AST::Builtin.nil_type, constr: body_constr)
                 end
 
                 when_constr = test_constr
@@ -1931,13 +1869,14 @@ module Steep
                 end_pos = node.loc.end.begin_pos
                 typing.add_context(begin_pos..end_pos, context: when_constr.context)
 
-                branch_pairs << when_constr.synthesize(els, hint: hint)
+                branch_results << when_constr.synthesize(els, hint: hint)
               end
 
-              types = branch_pairs.map(&:type)
-              constrs = branch_pairs.map(&:constr)
+              types = branch_results.map(&:type)
+              constrs = branch_results.map(&:constr)
 
-              if when_constr.context.lvar_env[cond_vars.first].is_a?(AST::Types::Bot)
+              cond_type = when_constr.context.type_env[cond_value_node]
+              if cond_type.is_a?(AST::Types::Bot)
                 # Exhaustive
                 if els
                   typing.add_error Diagnostic::Ruby::ElseOnExhaustiveCase.new(node: els, type: cond_type)
@@ -1949,49 +1888,52 @@ module Steep
                 end
               end
             else
-              branch_pairs = []
+              branch_results = []
 
-              when_constr = constr
+              condition_constr = constr
               clause_constr = constr
 
-              whens.each do |clause|
-                *tests, body = clause.children
+              whens.each do |when_clause|
+                when_clause_constr = condition_constr
+                body_envs = []
 
-                test_constr = when_constr
+                *tests, body = when_clause.children
 
                 tests.each do |test|
-                  test_type, test_constr = test_constr.synthesize(test, condition: true)
-                  truthy_env, falsy_env = interpreter.eval(env: test_constr.context.lvar_env, type: test_type, node: test)
-                  clause_constr = clause_constr.update_lvar_env { truthy_env }
-                  test_constr = test_constr.update_lvar_env { falsy_env }
-                end
+                  test_type, condition_constr = condition_constr.synthesize(test, condition: true).to_ary
+                  truthy_env, falsy_env = interpreter.eval(env: condition_constr.context.type_env, node: test)
 
-                when_constr = test_constr
+                  condition_constr = condition_constr.update_type_env { falsy_env }
+                  body_envs << truthy_env
+                end
 
                 if body
-                  branch_pairs << clause_constr
-                                    .for_branch(body)
-                                    .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
-                                    .synthesize(body, hint: hint)
+                  branch_results <<
+                    when_clause_constr
+                      .for_branch(body)
+                      .update_type_env {|env| env.join(*body_envs) }
+                      .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
+                      .synthesize(body, hint: hint)
                 else
-                  branch_pairs << Pair.new(type: AST::Builtin.nil_type, constr: clause_constr)
+                  branch_results << Pair.new(type: AST::Builtin.nil_type, constr: when_clause_constr)
                 end
               end
 
               if els
-                branch_pairs << when_constr.synthesize(els, hint: hint)
+                branch_results << condition_constr.synthesize(els, hint: hint)
               end
 
-              types = branch_pairs.map(&:type)
-              constrs = branch_pairs.map(&:constr)
+              types = branch_results.map(&:type)
+              constrs = branch_results.map(&:constr)
 
               unless els
                 types << AST::Builtin.nil_type
               end
             end
 
-            constr = constr.update_lvar_env do |env|
-              env.join(*constrs.map {|c| c.context.lvar_env })
+            constr = constr.update_type_env do |env|
+              envs = constrs.map {|c| c.context.type_env }
+              env.join(*envs)
             end
 
             add_typing(node, type: union_type(*types), constr: constr)
@@ -2002,15 +1944,19 @@ module Steep
             body, *resbodies, else_node = node.children
             body_pair = synthesize(body, hint: hint) if body
 
+            # @type var body_constr: TypeConstruction
             body_constr = if body_pair
-                            self.update_lvar_env do |env|
-                              env.join(env, body_pair.context.lvar_env)
+                            update_type_env do |env|
+                              env.join(env, body_pair.context.type_env)
                             end
                           else
                             self
                           end
 
             resbody_pairs = resbodies.map do |resbody|
+              # @type var exn_classes: Parser::AST::Node
+              # @type var assignment: Parser::AST::Node?
+              # @type var body: Parser::AST::Node?
               exn_classes, assignment, body = resbody.children
 
               if exn_classes
@@ -2031,25 +1977,28 @@ module Steep
                 end
               end
 
-              type_override = {}
+              resbody_construction = body_constr.for_branch(resbody).update_type_env do |env|
+                assignments = {}
 
-              case
-              when exn_classes && var_name
-                instance_types = exn_types.map do |type|
-                  type = expand_alias(type)
-                  case
-                  when type.is_a?(AST::Types::Name::Singleton)
-                    to_instance_type(type)
-                  else
-                    AST::Builtin.any_type
+                case
+                when exn_classes && var_name && exn_types
+                  instance_types = exn_types.map do |type|
+                    type = expand_alias(type)
+                    case
+                    when type.is_a?(AST::Types::Name::Singleton)
+                      to_instance_type(type)
+                    else
+                      AST::Builtin.any_type
+                    end
                   end
+
+                  assignments[var_name] = AST::Types::Union.build(types: instance_types)
+                when var_name
+                  assignments[var_name] = AST::Builtin.any_type
                 end
-                type_override[var_name] = AST::Types::Union.build(types: instance_types)
-              when var_name
-                type_override[var_name] = AST::Builtin.any_type
-              end
 
-              resbody_construction = body_constr.for_branch(resbody, type_case_override: type_override)
+                env.assign_local_variables(assignments)
+              end
 
               if body
                 resbody_construction.synthesize(body, hint: hint)
@@ -2059,17 +2008,18 @@ module Steep
             end
 
             resbody_types = resbody_pairs.map(&:type)
-            resbody_envs = resbody_pairs.map {|pair| pair.context.lvar_env }
+            resbody_envs = resbody_pairs.map {|pair| pair.context.type_env }
+
+            else_constr = body_pair&.constr || self
 
             if else_node
-              else_pair = (body_pair&.constr || self).for_branch(else_node).synthesize(else_node, hint: hint)
-              add_typing(node,
-                         type: union_type(*[else_pair.type, *resbody_types].compact),
-                         constr: update_lvar_env {|env| env.join(*resbody_envs, env) })
+              else_type, else_constr = else_constr.for_branch(else_node).synthesize(else_node, hint: hint)
+              else_constr
+                .update_type_env {|env| env.join(*resbody_envs, env) }
+                .add_typing(node, type: union_type(else_type, *resbody_types))
             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) })
+              update_type_env {|env| env.join(*resbody_envs, else_constr.context.type_env) }
+                .add_typing(node, type: union_type(*[body_pair&.type, *resbody_types].compact))
             end
           end
 
@@ -2097,7 +2047,7 @@ module Steep
           yield_self do
             asgn, collection, body = node.children
 
-            collection_type, constr = synthesize(collection)
+            collection_type, constr, collection_context = synthesize(collection).to_ary
             collection_type = expand_self(collection_type)
 
             var_type = case collection_type
@@ -2110,24 +2060,31 @@ module Steep
                            method_type.block.type.params.first_param&.type
                          end
                        end
+            var_name = asgn.children[0]
 
             if var_type
               if body
-                body_constr = constr.with_updated_context(
-                  lvar_env: constr.context.lvar_env.assign(asgn.children[0], node: asgn, type: var_type)
-                )
+                body_constr = constr.update_type_env do |type_env|
+                  type_env = type_env.assign_local_variables({ var_name => var_type })
+                  pins = type_env.pin_local_variables(nil)
+                  type_env.merge(local_variable_types: pins)
+                end
 
                 typing.add_context_for_body(node, context: body_constr.context)
-                _, _, body_context = body_constr.synthesize(body)
+                _, _, body_context = body_constr.synthesize(body).to_ary
 
-                constr = constr.update_lvar_env {|env| env.join(constr.context.lvar_env, body_context.lvar_env) }
+                constr = constr.update_type_env do |env|
+                  env.join(collection_context.type_env, body_context.type_env)
+                end
               else
                 constr = self
               end
 
               add_typing(node, type: collection_type, constr: constr)
             else
-              fallback_to_any(node) do
+              constr = synthesize_children(node, skips: [collection])
+
+              constr.fallback_to_any(node) do
                 Diagnostic::Ruby::NoMethod.new(
                   node: node,
                   method: :each,
@@ -2139,10 +2096,10 @@ module Steep
         when :while, :until
           yield_self do
             cond, body = node.children
-            cond_type, constr = synthesize(cond, condition: true)
+            cond_type, constr = synthesize(cond, condition: true).to_ary
 
             interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
-            truthy_env, falsy_env = interpreter.eval(env: constr.context.lvar_env, node: cond, type: cond_type)
+            truthy_env, falsy_env = interpreter.eval(env: constr.context.type_env, node: cond)
 
             case node.type
             when :while
@@ -2152,19 +2109,19 @@ module Steep
             end
 
             if body
-              _, 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) }
+              pins = body_env.pin_local_variables(nil)
+              body_env = body_env.merge(local_variable_types: pins)
+
+              _, body_constr =
+                constr
+                  .update_type_env { body_env }
+                  .for_branch(body, break_context: TypeInference::Context::BreakContext.new(break_type: hint || AST::Builtin.nil_type, next_type: nil))
+                  .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
+                  .synthesize(body).to_ary
+
+              constr = constr.update_type_env {|env| env.join(exit_env, body_constr.context.type_env) }
             else
-              constr = constr.update_lvar_env { exit_env }
+              constr = constr.update_type_env { exit_env }
             end
 
             add_typing(node, type: AST::Builtin.nil_type, constr: constr)
@@ -2174,21 +2131,18 @@ module Steep
           yield_self do
             cond, body = node.children
 
-            cond_pair = synthesize(cond)
+            _, cond_constr, = synthesize(cond).to_ary
 
             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
-                                       ))
+              for_loop =
+                cond_constr
+                  .update_type_env {|env| env.merge(local_variable_types: env.pin_local_variables(nil)) }
+                  .for_branch(body, break_context: TypeInference::Context::BreakContext.new(break_type: hint || AST::Builtin.nil_type, next_type: nil))
 
               typing.add_context_for_node(body, context: for_loop.context)
-              body_pair = for_loop.synthesize(body)
+              _, body_constr, body_context = for_loop.synthesize(body)
 
-              constr = cond_pair.constr.update_lvar_env {|env| env.join(env, body_pair.context.lvar_env) }
+              constr = cond_constr.update_type_env {|env| env.join(env, body_context.type_env) }
 
               add_typing(node, type: AST::Builtin.nil_type, constr: constr)
             else
@@ -2269,37 +2223,48 @@ module Steep
         when :gvasgn
           yield_self do
             name, rhs = node.children
-            type = type_env.get(gvar: name) do
-              fallback_to_any node
-            end
+            lhs_type = context.type_env[name]
 
-            check(rhs, type) do |_, rhs_type, result|
-              typing.add_error(
-                Diagnostic::Ruby::IncompatibleAssignment.new(
-                  node: node,
-                  lhs_type: type,
-                  rhs_type: rhs_type,
-                  result: result
+            rhs_type, constr = synthesize(rhs, hint: lhs_type).to_ary
+
+            if lhs_type
+              result = constr.check_relation(sub_type: rhs_type, super_type: lhs_type)
+
+              if result.failure?
+                constr.typing.add_error(
+                  Diagnostic::Ruby::IncompatibleAssignment.new(
+                    node: node,
+                    lhs_type: lhs_type,
+                    rhs_type: rhs_type,
+                    result: result
+                  )
                 )
-              )
+              end
+            else
+              constr.typing.add_error(Diagnostic::Ruby::UnknownGlobalVariable.new(node: node, name: name))
             end
+
+            constr.add_typing(node, type: rhs_type)
           end
 
         when :gvar
           yield_self do
             name = node.children.first
-            type = type_env.get(gvar: name) do
-              typing.add_error Diagnostic::Ruby::FallbackAny.new(node: node)
+            if type = context.type_env[name]
+              add_typing(node, type: type)
+            else
+              fallback_to_any(node) do
+                Diagnostic::Ruby::UnknownGlobalVariable.new(node: node, name: name)
+              end
             end
-
-            add_typing(node, type: type)
           end
 
         when :block_pass
           yield_self do
             value = node.children[0]
 
-            if hint.is_a?(AST::Types::Proc) && value.type == :sym
+            case
+            when hint.is_a?(AST::Types::Proc) && value && value.type == :sym
               if hint.one_arg?
                 # Assumes Symbol#to_proc implementation
                 param_type = hint.type.params.required[0]
@@ -2333,9 +2298,18 @@ module Steep
               else
                 Steep.logger.error "Passing multiple args through Symbol#to_proc is not supported yet"
               end
+            when value == nil
+              type = AST::Types::Proc.new(
+                type: method_context.method_type.block.type,
+                location: nil,
+                block: nil
+              )
+              if method_context.method_type.block.optional?
+                type = AST::Types::Union.build(types: [type, AST::Builtin.nil_type])
+              end
             end
 
-            type ||= synthesize(node.children[0], hint: hint).type
+            type ||= synthesize(value, hint: hint).type
 
             add_typing node, type: type
           end
@@ -2452,33 +2426,6 @@ module Steep
       end
     end
 
-    def type_ivasgn(name, rhs, 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,
-        instance_type: module_context.instance_type,
-        class_type: module_context.module_type
-      ) do |error|
-        if error
-          type = type_env.get(ivar: name)
-          typing.add_error(
-            Diagnostic::Ruby::IncompatibleAssignment.new(
-              node: node,
-              lhs_type: type,
-              rhs_type: rhs_type,
-              result: error
-            )
-          )
-        else
-          fallback_to_any node
-        end
-      end
-      add_typing(node, type: ivar_type)
-    end
-
     def masgn_lhs?(lhs)
       lhs.children.all? do |a|
         asgn_type = if a.type == :splat
@@ -2492,233 +2439,140 @@ module Steep
 
     def lvasgn(node, type)
       name = node.children[0]
-      env = context.lvar_env.assign(name, node: node, type: type) do |declared_type, type, result|
-        typing.add_error(
-          Diagnostic::Ruby::IncompatibleAssignment.new(
-            node: node,
-            lhs_type: declared_type,
-            rhs_type: type,
-            result: result
-          )
-        )
-      end
 
-      add_typing(node, type: type, constr: with_updated_context(lvar_env: env))
-    end
-
-    def ivasgn(node, type)
-      ivar = node.children[0]
-
-      type_env.assign(
-        ivar: ivar,
-        type: type,
-        self_type: self_type,
-        instance_type: module_context.instance_type,
-        class_type: module_context.module_type
-      ) do |error|
-        if error
-          var_type = type_env.get(ivar: ivar)
+      if enforced_type = context.type_env.enforced_type(name)
+        if result = no_subtyping?(sub_type: type, super_type: enforced_type)
           typing.add_error(
             Diagnostic::Ruby::IncompatibleAssignment.new(
               node: node,
-              lhs_type: var_type,
+              lhs_type: enforced_type,
               rhs_type: type,
-              result: error
+              result: result
             )
           )
-        else
-          fallback_to_any node
+
+          type = enforced_type
         end
       end
 
-      add_typing(node, type: type)
+      update_type_env {|env| env.assign_local_variable(name, type, enforced_type) }
+        .add_typing(node, type: type)
     end
 
-    def type_masgn(node)
-      lhs, rhs = node.children
-      rhs_pair = synthesize(rhs)
-      rhs_type = deep_expand_alias(rhs_pair.type)
-
-      constr = rhs_pair.constr
-
-      unless masgn_lhs?(lhs)
-        Steep.logger.error("Unsupported masgn lhs node: only lvasgn, ivasgn, and splat are supported")
-        _, constr = constr.fallback_to_any(lhs)
-        return add_typing(node, type: rhs_type, constr: constr)
-      end
-
-      falseys, truthys = partition_flatten_types(rhs_type) do |type|
-        type.is_a?(AST::Types::Nil) || (type.is_a?(AST::Types::Literal) && type.value == false)
-      end
-
-      unwrap_rhs_type = AST::Types::Union.build(types: truthys)
-
-      case
-      when unwrap_rhs_type.is_a?(AST::Types::Tuple) || (rhs.type == :array && rhs.children.none? {|n| n.type == :splat })
-        tuple_types = if unwrap_rhs_type.is_a?(AST::Types::Tuple)
-                        unwrap_rhs_type.types.dup
-                      else
-                        rhs.children.map do |node|
-                          typing.type_of(node: node)
-                        end
-                      end
-
-        assignment_nodes = lhs.children.dup
-        leading_assignments = []
-        trailing_assignments = []
+    def ivasgn(node, rhs_type)
+      name = node.children[0]
 
-        until assignment_nodes.empty?
-          cursor = assignment_nodes.first
+      lhs_type = context.type_env[name]
 
-          if cursor.type == :splat
-            break
-          else
-            leading_assignments << assignment_nodes.shift
-          end
+      if lhs_type
+        if (result = check_relation(sub_type: rhs_type, super_type: lhs_type)).failure?
+          typing.add_error(
+            Diagnostic::Ruby::IncompatibleAssignment.new(node: node, lhs_type: lhs_type, rhs_type: rhs_type, result: result)
+          )
         end
+      else
+        typing.add_error(Diagnostic::Ruby::UnknownInstanceVariable.new(node: node, name: name))
+      end
 
-        until assignment_nodes.empty?
-          cursor = assignment_nodes.last
-
-          if cursor.type == :splat
-            break
-          else
-            trailing_assignments.unshift assignment_nodes.pop
-          end
-        end
+      add_typing(node, type: rhs_type)
+    end
 
-        leading_assignments.each do |asgn|
-          type = tuple_types.first
+    def type_masgn_type(mlhs_node, rhs_type, masgn:, optional:)
+      # @type var constr: TypeConstruction
+      constr = self
 
-          if type
-            tuple_types.shift
-          else
-            type = AST::Builtin.nil_type
-          end
+      if assignments = masgn.expand(mlhs_node, rhs_type || AST::Builtin.any_type, optional)
+        assignments.each do |pair|
+          node, type = pair
 
-          case asgn.type
-          when :lvasgn
-            _, constr = constr.lvasgn(asgn, type)
-          when :ivasgn
-            _, constr = constr.ivasgn(asgn, type)
+          if assignments.optional
+            type = AST::Builtin.optional(type)
           end
-        end
 
-        trailing_assignments.reverse_each do |asgn|
-          type = tuple_types.last
-
-          if type
-            tuple_types.pop
+          if node.type == :splat
+            asgn_node = node.children[0]
+            next unless asgn_node
+            var_type = asgn_node.type
           else
-            type = AST::Builtin.nil_type
+            asgn_node = node
+            var_type = type
           end
 
-          case asgn.type
+          case asgn_node.type
           when :lvasgn
-            _, constr = constr.lvasgn(asgn, type)
+            _, constr = constr.lvasgn(asgn_node, type)
           when :ivasgn
-            _, constr = constr.ivasgn(asgn, type)
+            _, constr = constr.ivasgn(asgn_node, type)
+          when :gvasgn
+            raise
+          when :mlhs
+            constr = (constr.type_masgn_type(asgn_node, type, masgn: masgn, optional: optional) or return)
           end
-        end
 
-        element_type = if tuple_types.empty?
-                         AST::Builtin.nil_type
-                       else
-                         AST::Types::Union.build(types: tuple_types)
-                       end
-        array_type = AST::Builtin::Array.instance_type(element_type)
-
-        assignment_nodes.each do |asgn|
-          case asgn.type
-          when :splat
-            case asgn.children[0]&.type
-            when :lvasgn
-              _, constr = constr.lvasgn(asgn.children[0], array_type)
-            when :ivasgn
-              _, constr = constr.ivasgn(asgn.children[0], array_type)
-            end
-          when :lvasgn
-            _, constr = constr.lvasgn(asgn, element_type)
-          when :ivasgn
-            _,constr = constr.ivasgn(asgn, element_type)
+          if node.type == :splat
+            _, constr = constr.add_typing(node, type: type)
           end
         end
 
-        unless falseys.empty?
-          constr = constr.update_lvar_env {|lvar_env| self.context.lvar_env.join(lvar_env, self.context.lvar_env)}
-        end
-
-        add_typing(node, type: rhs_type, constr: constr)
+        constr
+      end
+    end
 
-      when flatten_union(unwrap_rhs_type).all? {|type| AST::Builtin::Array.instance_type?(type) }
-        array_elements = flatten_union(unwrap_rhs_type).map {|type| type.args[0] }
-        element_type = AST::Types::Union.build(types: array_elements + [AST::Builtin.nil_type])
+    def type_masgn(node)
+      lhs, rhs = node.children
 
-        constr = lhs.children.inject(constr) do |constr, assignment|
-          case assignment.type
-          when :lvasgn
-            _, constr = constr.lvasgn(assignment, element_type)
+      masgn = TypeInference::MultipleAssignment.new()
+      hint = masgn.hint_for_mlhs(lhs, context.type_env)
 
-          when :ivasgn
-            _, constr = constr.ivasgn(assignment, element_type)
-          when :splat
-            case assignment.children[0]&.type
-            when :lvasgn
-              _, constr = constr.lvasgn(assignment.children[0], unwrap_rhs_type)
-            when :ivasgn
-              _, constr = constr.ivasgn(assignment.children[0], unwrap_rhs_type)
-            when nil
-              # foo, * = bar
-            else
-              raise
-            end
-          end
+      rhs_type, lhs_constr = try_tuple_type!(rhs, hint: hint).to_ary
+      rhs_type = deep_expand_alias(rhs_type)
 
-          constr
-        end
+      falsys, truthys = partition_flatten_types(rhs_type) do |type|
+        type.is_a?(AST::Types::Nil) || (type.is_a?(AST::Types::Literal) && type.value == false)
+      end
 
-        unless falseys.empty?
-          constr = constr.update_lvar_env {|lvar_env| self.context.lvar_env.join(lvar_env, self.context.lvar_env)}
-        end
+      truthy_rhs_type = AST::Types::Union.build(types: truthys)
+      optional = !falsys.empty?
 
-        add_typing(node, type: rhs_type, constr: constr)
+      if truthy_rhs_type.is_a?(AST::Types::Tuple) || AST::Builtin::Array.instance_type?(truthy_rhs_type) || truthy_rhs_type.is_a?(AST::Types::Any)
+        constr = lhs_constr.type_masgn_type(lhs, truthy_rhs_type, masgn: masgn, optional: optional)
       else
-        unless rhs_type.is_a?(AST::Types::Any)
-          Steep.logger.error("Unsupported masgn rhs type: array or tuple is supported (#{rhs_type})")
-        end
+        ary_type = try_convert(truthy_rhs_type, :to_ary) || try_convert(truthy_rhs_type, :to_a) || AST::Types::Tuple.new(types: [truthy_rhs_type])
+        constr = lhs_constr.type_masgn_type(lhs, ary_type, masgn: masgn, optional: optional)
+      end
 
-        untyped = AST::Builtin.any_type
+      unless constr
+        typing.add_error(
+          Diagnostic::Ruby::MultipleAssignmentConversionError.new(
+            node: rhs,
+            original_type: rhs_type,
+            returned_type: ary_type || AST::Builtin.bottom_type
+          )
+        )
 
-        constr = lhs.children.inject(constr) do |constr, assignment|
-          case assignment.type
+        constr = lhs_constr
+
+        each_descendant_node(lhs) do |node|
+          case node.type
           when :lvasgn
-            _, constr = constr.lvasgn(assignment, untyped)
+            _, constr = constr.lvasgn(node, AST::Builtin.any_type).to_ary
           when :ivasgn
-            _, constr = constr.ivasgn(assignment, untyped)
-          when :splat
-            case assignment.children[0]&.type
-            when :lvasgn
-              _, constr = constr.lvasgn(assignment.children[0], untyped)
-            when :ivasgn
-              _, constr = constr.ivasgn(assignment.children[0], untyped)
-            when nil
-              # foo, * = bar
-            else
-              raise
-            end
+            _, constr = constr.ivasgn(node, AST::Builtin.any_type).to_ary
+          when :gvasgn
+            raise
+          else
+            _, constr = constr.add_typing(node, type: AST::Builtin.any_type).to_ary
           end
-
-          constr
         end
-
-        add_typing(node, type: rhs_type, constr: constr)
       end
+
+      constr.add_typing(node, type: truthy_rhs_type)
     end
 
     def synthesize_constant(node, parent_node, constant_name)
       const_name = module_name_from_node(parent_node, constant_name)
 
-      if const_name && type = type_env.get(const: const_name) { break }
+      if const_name && type = context.type_env.annotated_constant(const_name)
         # const-type annotation wins
         if node
           constr = synthesize_children(node)
@@ -2732,7 +2586,7 @@ module Steep
         when !parent_node
           constr = self
 
-          if (type, name = module_context.const_env.resolve(constant_name))
+          if (type, name = context.type_env.constant(constant_name, false))
             if node
               _, constr = add_typing(node, type: type)
             end
@@ -2742,7 +2596,7 @@ module Steep
         when parent_node.type == :cbase
           _, constr = add_typing(parent_node, type: AST::Builtin.nil_type)
 
-          if (type, name = constr.module_context.const_env.toplevel(constant_name))
+          if (type, name = constr.context.type_env.constant(constant_name, true))
             if node
               _, constr = constr.add_typing(node, type: type)
             end
@@ -2750,12 +2604,12 @@ module Steep
             return [type, constr, name]
           end
         else
-          parent_type, constr = synthesize(parent_node)
+          parent_type, constr = synthesize(parent_node).to_ary
           parent_type = deep_expand_alias(parent_type)
 
           case parent_type
           when AST::Types::Name::Singleton
-            if (type, name = module_context.const_env.resolve_child(parent_type.name, constant_name))
+            if (type, name = constr.context.type_env.constant(parent_type.name, constant_name))
               if node
                 _, constr = add_typing(node, type: type)
               end
@@ -2817,6 +2671,7 @@ module Steep
       end
 
       block_constr = for_block(
+        body_node,
         block_params: params,
         block_param_hint: params_hint,
         block_type_hint: return_hint,
@@ -2827,13 +2682,6 @@ module Steep
 
       block_constr.typing.add_context_for_body(node, context: block_constr.context)
 
-      default_proc_function =
-        Interface::Function.new(
-          params: Interface::Function::Params.empty,
-          return_type: AST::Builtin.any_type,
-          location: nil
-        )
-
       params.params.each do |param|
         _, block_constr = block_constr.synthesize(param.node, hint: param.type)
       end
@@ -2878,6 +2726,10 @@ module Steep
         )
 
         if expected_block_type = block_constr.block_context.body_type
+          type_vars = expected_block_type.free_variables
+          subst = Interface::Substitution.build(type_vars, type_vars.map { AST::Builtin.any_type })
+          expected_block_type = expected_block_type.subst(subst)
+
           check_relation(sub_type: return_type, super_type: expected_block_type).else do |result|
             block_constr.typing.add_error(
               Diagnostic::Ruby::BlockBodyTypeMismatch.new(
@@ -2921,6 +2773,20 @@ module Steep
       constr
     end
 
+    KNOWN_PURE_METHODS = Set[
+      MethodName("::Array#[]"),
+      MethodName("::Hash#[]")
+    ]
+
+    def pure_send?(call, receiver, arguments)
+      return false unless call.node.type == :send || call.node.type == :csend
+      return false unless call.pure? || KNOWN_PURE_METHODS.superset?(Set.new(call.method_decls.map(&:method_name)))
+
+      [receiver, *arguments].all? do |node|
+        !node || value_node?(node) || context.type_env[node]
+      end
+    end
+
     def type_send_interface(node, interface:, receiver:, receiver_type:, method_name:, arguments:, block_params:, block_body:)
       method = interface.methods[method_name]
 
@@ -2937,8 +2803,28 @@ module Steep
         if call && constr
           case method_name.to_s
           when "[]=", /\w=\Z/
-            if typing.has_type?(arguments.last)
-              call = call.with_return_type(typing.type_of(node: arguments.last))
+            last_arg = arguments.last or raise
+            if typing.has_type?(last_arg)
+              call = call.with_return_type(typing.type_of(node: last_arg))
+            end
+          end
+
+          if call.is_a?(TypeInference::MethodCall::Typed)
+            if (pure_call, type = constr.context.type_env.pure_method_calls[node])
+              if type
+                call = pure_call.update(node: node, return_type: type)
+                constr.add_typing(node, type: call.return_type)
+              end
+            else
+              if pure_send?(call, receiver, arguments)
+                constr = constr.update_type_env do |env|
+                  env.add_pure_call(node, call, call.return_type)
+                end
+              else
+                constr = constr.update_type_env do |env|
+                  env.invalidate_pure_node(receiver)
+                end
+              end
             end
           end
 
@@ -2997,6 +2883,17 @@ module Steep
           )
         end
 
+        if node.type == :block
+          send_node = node.children[0]
+          case send_node.type
+          when :super, :zsuper
+            method_name = method_context.name
+            return fallback_to_any(send_node) do
+              Diagnostic::Ruby::UnexpectedSuper.new(node: send_node, method: method_name)
+            end
+          end
+        end
+
         constr.add_call(
           TypeInference::MethodCall::NoMethodError.new(
             node: node,
@@ -3093,6 +2990,15 @@ module Steep
                                                          private: private,
                                                          self_type: AST::Types::Self.new)
 
+                         if send_node.type == :super || send_node.type == :zsuper
+                            method_name = method_context.name
+                            unless method_context.super_method
+                              return fallback_to_any(send_node) do
+                                Diagnostic::Ruby::UnexpectedSuper.new(node: send_node, method: method_name)
+                              end
+                            end
+                         end
+
                          constr.type_send_interface(node,
                                                     interface: interface,
                                                     receiver: receiver,
@@ -3144,6 +3050,9 @@ module Steep
       array_compact: Set[
         MethodName("::Array#compact"),
         MethodName("::Enumerable#compact")
+      ],
+      hash_compact: Set[
+        MethodName("::Hash#compact")
       ]
     }
 
@@ -3170,6 +3079,29 @@ module Steep
               method_decls: decls
             )
 
+            return [call, constr]
+          end
+        end
+      when decl = decls.find {|decl| SPECIAL_METHOD_NAMES[:hash_compact].include?(decl.method_name) }
+        if arguments.empty? && !block_params
+          # compact
+          return_type = method_type.type.return_type
+          if AST::Builtin::Hash.instance_type?(return_type)
+            key = return_type.args[0]
+            value = return_type.args[1]
+            type = AST::Builtin::Hash.instance_type(key, unwrap(value))
+
+            _, constr = add_typing(node, type: type)
+            call = TypeInference::MethodCall::Special.new(
+              node: node,
+              context: constr.context.method_context,
+              method_name: decl.method_name,
+              receiver_type: receiver_type,
+              actual_method_type: method_type.with(type: method_type.type.with(return_type: type)),
+              return_type: type,
+              method_decls: decls
+            )
+
             return [call, constr]
           end
         end
@@ -3239,7 +3171,7 @@ module Steep
 
       [
         call,
-        update_lvar_env { constr.context.lvar_env }
+        update_type_env { constr.context.type_env }
       ]
     end
 
@@ -3306,10 +3238,18 @@ module Steep
 
       constr = self
 
+      constr = constr.with(
+        context: context.with(
+          variable_context: TypeInference::Context::TypeVariableContext.new(
+            type_params,
+            parent_context: context.variable_context
+          )
+        )
+      )
+
       method_type = method_type.instantiate(instantiation)
 
       variance = Subtyping::VariableVariance.from_method_type(method_type)
-      occurence = Subtyping::VariableOccurence.from_method_type(method_type)
       constraints = Subtyping::Constraints.new(unknowns: type_params.map(&:name))
       ccontext = Subtyping::Constraints::Context.new(
         self_type: self_type,
@@ -3426,6 +3366,7 @@ module Steep
             if pairs
               # Block parameters are compatible with the block type
               block_constr = constr.for_block(
+                block_body,
                 block_params: block_params_,
                 block_param_hint: method_type.block.type.params,
                 block_type_hint: method_type.block.type.return_type,
@@ -3434,15 +3375,13 @@ module Steep
                 node_type_hint: method_type.type.return_type
               )
               block_constr = block_constr.with_new_typing(
-                block_constr.typing.new_child(
-                  range: block_constr.typing.block_range(node)
-                )
+                block_constr.typing.new_child(block_constr.typing.block_range(node))
               )
 
               block_constr.typing.add_context_for_body(node, context: block_constr.context)
 
               pairs.each do |param, type|
-                _, block_constr = block_constr.synthesize(param.node, hint: param.type || type)
+                _, block_constr = block_constr.synthesize(param.node, hint: param.type || type).to_ary
 
                 if param.type
                   check_relation(sub_type: type, super_type: param.type, constraints: constraints).else do |result|
@@ -3467,16 +3406,20 @@ module Steep
 
               if solved
                 # Ready for type check the body of the block
-                block_constr = block_constr.update_lvar_env {|env| env.subst(s) }
-                if block_body
-                  block_body_type = block_constr.synthesize_block(
-                    node: node,
-                    block_body: block_body,
-                    block_type_hint: method_type.block.type.return_type
+                block_constr = block_constr.update_type_env {|env| env.subst(s) }
+                block_constr = block_constr.update_context {|context|
+                  context.with(
+                    type_env: context.type_env.subst(s),
+                    block_context: context.block_context&.subst(s),
+                    break_context: context.break_context&.subst(s)
                   )
-                else
-                  block_body_type = AST::Builtin.nil_type
-                end
+                }
+
+                block_body_type = block_constr.synthesize_block(
+                  node: node,
+                  block_body: block_body,
+                  block_type_hint: method_type.block.type.return_type
+                )
 
                 result = check_relation(sub_type: block_body_type,
                                         super_type: method_type.block.type.return_type,
@@ -3537,10 +3480,20 @@ module Steep
               errors << error
             end
 
-            errors << Diagnostic::Ruby::UnexpectedBlockGiven.new(
-              node: node,
-              method_type: method_type
-            )
+            case node.children[0].type
+            when :super, :zsuper
+              unless method_context.super_method
+                errors << Diagnostic::Ruby::UnexpectedSuper.new(
+                  node: node.children[0],
+                  method: method_name
+                )
+              end
+            else
+              errors << Diagnostic::Ruby::UnexpectedBlockGiven.new(
+                node: node,
+                method_type: method_type
+              )
+            end
 
             method_type = eliminate_vars(method_type, type_param_names)
             return_type = method_type.type.return_type
@@ -3652,6 +3605,12 @@ module Steep
                  )
                end
 
+        constr = constr.with(
+          context: constr.context.with(
+            variable_context: context.variable_context
+          )
+        )
+
         [
           call,
           constr
@@ -3683,12 +3642,13 @@ module Steep
       end
 
       block_constr = for_block(
+        block_body,
         block_params: block_params,
         block_param_hint: nil,
-        block_type_hint: AST::Builtin.any_type,
+        block_type_hint: nil,
         block_block_hint: nil,
         block_annotations: block_annotations,
-        node_type_hint: AST::Builtin.any_type
+        node_type_hint: nil
       )
 
       block_constr.typing.add_context_for_body(node, context: block_constr.context)
@@ -3713,7 +3673,7 @@ module Steep
       end
     end
 
-    def for_block(block_params:, block_param_hint:, block_type_hint:, block_block_hint:, block_annotations:, node_type_hint:)
+    def for_block(body_node, block_params:, block_param_hint:, block_type_hint:, block_block_hint:, block_annotations:, node_type_hint:)
       block_param_pairs = block_param_hint && block_params.zip(block_param_hint, block_block_hint)
 
       param_types_hash = {}
@@ -3729,14 +3689,32 @@ module Steep
         end
       end
 
-      decls = param_types_hash.each.with_object({}) do |(name, type), hash|
-        hash[name] = TypeInference::LocalVariableTypeEnv::Entry.new(type: type)
+      param_types = param_types_hash.each.with_object({}) do |pair, hash|
+        # @type var hash: Hash[Symbol, [AST::Types::t, AST::Types::t?]]
+        name, type = pair
+        hash[name] = [type, nil]
       end
-      lvar_env = context.lvar_env
-                   .pin_assignments
-                   .except(decls.keys)
-                   .update(assigned_types: decls)
-                   .annotate(block_annotations)
+
+      pins = context.type_env.pin_local_variables(nil)
+
+      type_env = context.type_env
+      type_env = type_env.merge(local_variable_types: pins)
+      type_env = type_env.merge(local_variable_types: param_types)
+      type_env = TypeInference::TypeEnvBuilder.new(
+        TypeInference::TypeEnvBuilder::Command::ImportLocalVariableAnnotations.new(block_annotations).merge!.on_duplicate! do |name, outer_type, inner_type|
+          next if outer_type.is_a?(AST::Types::Var) || inner_type.is_a?(AST::Types::Var)
+          next unless body_node
+
+          if result = no_subtyping?(sub_type: outer_type, super_type: inner_type)
+            typing.add_error Diagnostic::Ruby::IncompatibleAnnotation.new(
+              node: body_node,
+              var_name: name,
+              result: result,
+              relation: result.relation
+            )
+          end
+        end
+      ).build(type_env)
 
       break_type = if block_annotations.break_type
                      union_type(node_type_hint, block_annotations.break_type)
@@ -3745,21 +3723,18 @@ module Steep
                    end
 
       block_context = TypeInference::Context::BlockContext.new(
-        body_type: block_annotations.block_type || block_type_hint || AST::Builtin.any_type
+        body_type: block_annotations.block_type || block_type_hint
       )
       break_context = TypeInference::Context::BreakContext.new(
-        break_type: break_type,
-        next_type: block_context.body_type
+        break_type: break_type || AST::Builtin.any_type,
+        next_type: block_context.body_type || AST::Builtin.any_type
       )
 
       self_type = self.self_type
       module_context = self.module_context
 
       if implements = block_annotations.implement_module_annotation
-        module_context = default_module_context(
-          implements.name,
-          const_env: self.module_context.const_env
-        )
+        module_context = default_module_context(implements.name, nesting: nesting)
 
         self_type = module_context.module_type
       end
@@ -3779,8 +3754,7 @@ module Steep
           module_context: module_context,
           break_context: break_context,
           self_type: self_type,
-          type_env: type_env.dup,
-          lvar_env: lvar_env,
+          type_env: type_env,
           call_context: self.context.call_context,
           variable_context: variable_context
         )
@@ -3800,35 +3774,10 @@ module Steep
       end
     end
 
-    def each_child_node(node)
-      if block_given?
-        node.children.each do |child|
-          if child.is_a?(::AST::Node)
-            yield child
-          end
-        end
-      else
-        enum_for :each_child_node, node
-      end
-    end
-
     def nesting
       module_context&.nesting
     end
 
-    def absolute_nested_module_name(module_name)
-      n = nesting
-      while n && !n[1]
-        n = n[0]
-      end
-
-      if n
-        module_name.absolute!
-      else
-        n + module_name
-      end
-    end
-
     def absolute_name(name)
       checker.factory.absolute_type_name(name, context: nesting)
     end
@@ -4025,12 +3974,14 @@ module Steep
     end
 
     def try_tuple_type!(node, hint: nil)
-      if node.type == :array && (hint.nil? || hint.is_a?(AST::Types::Tuple))
-        node_range = node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }
+      if node.type == :array
+        if hint.nil? || hint.is_a?(AST::Types::Tuple)
+          node_range = node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }
 
-        typing.new_child(node_range) do |child_typing|
-          if pair = with_new_typing(child_typing).try_tuple_type(node, hint)
-            return pair.with(constr: pair.constr.save_typing)
+          typing.new_child(node_range) do |child_typing|
+            if pair = with_new_typing(child_typing).try_tuple_type(node, hint)
+              return pair.with(constr: pair.constr.save_typing)
+            end
           end
         end
       end
@@ -4065,13 +4016,13 @@ module Steep
         return
       end
 
-      interface = checker.factory.interface(type, private: false)
+      interface = checker.factory.interface(type, private: false, self_type: self_type)
       if entry = interface.methods[method]
         method_type = entry.method_types.find do |method_type|
           method_type.type.params.optional?
         end
 
-        method_type.type.return_type
+        method_type.type.return_type if method_type
       end
     rescue => exn
       Steep.log_error(exn, message: "Unexpected error when converting #{type.to_s} with #{method}")
@@ -4109,20 +4060,15 @@ module Steep
       constr.add_typing(node, type: AST::Builtin::Array.instance_type(element_type))
     end
 
-    # Try to give record type to hash_node.
-    #
-    # Returns nil when it cannot have a record type.
-    # `record_type` can be nil when the keys are not specified.
-    #
     def type_hash_record(hash_node, record_type)
       raise unless hash_node.type == :hash || hash_node.type == :kwargs
 
       constr = self
 
       if record_type
-        elements = record_type.elements.dup
+        hints = record_type.elements.dup
       else
-        elements = {}
+        hints = {}
       end
 
       elems = {}
@@ -4137,7 +4083,18 @@ module Steep
             key = key_node.children[0]
 
             _, constr = constr.synthesize(key_node, hint: AST::Types::Literal.new(value: key))
-            value_type, constr = constr.synthesize(value_node, hint: elements[key])
+
+            value_type, constr = constr.synthesize(value_node, hint: hints[key])
+
+            if hints.key?(key)
+              hint_type = hints[key]
+              case
+              when value_type.is_a?(AST::Types::Any)
+                value_type = hints[key]
+              when hint_type.is_a?(AST::Types::Var)
+                value_type = value_type
+              end
+            end
 
             elems[key] = value_type
           else
@@ -4240,11 +4197,11 @@ module Steep
     def pick_one_of(types, range:)
       types.each do |type|
         with_child_typing(range: range) do |constr|
-          type_, constr = yield type, constr
-
-          constr.check_relation(sub_type: type_, super_type: type).then do
-            constr = constr.save_typing
-            return Pair.new(type: type, constr: constr)
+          if (type_, constr = yield(type, constr))
+            constr.check_relation(sub_type: type_, super_type: type).then do
+              constr = constr.save_typing
+              return Pair.new(type: type, constr: constr)
+            end
           end
         end
       end