steep 0.37.0 → 0.42.0

data/lib/steep/subtyping/constraints.rb

@@ -207,7 +207,7 @@ module Steep
         end
       end
 
-      def solution(checker, variance:, variables:, self_type:)
+      def solution(checker, variance:, variables:, self_type:, instance_type:, class_type:)
         vars = []
         types = []
 
@@ -218,7 +218,7 @@ module Steep
               lower_bound = lower_bound(var)
               relation = Relation.new(sub_type: lower_bound, super_type: upper_bound)
 
-              checker.check(relation, self_type: self_type, constraints: self.class.empty).yield_self do |result|
+              checker.check(relation, self_type: self_type, instance_type: instance_type, class_type: class_type, constraints: self.class.empty).yield_self do |result|
                 if result.success?
                   vars << var
 

data/lib/steep/type_construction.rb

@@ -115,8 +115,15 @@ module Steep
     end
 
     def check_relation(sub_type:, super_type:, constraints: Subtyping::Constraints.empty)
-      Steep.logger.debug { "check_relation: self:#{self_type} |- #{sub_type} <: #{super_type}" }
-      checker.check(Subtyping::Relation.new(sub_type: sub_type, super_type: super_type), self_type: self_type, constraints: constraints)
+      Steep.logger.debug { "check_relation: self:#{self_type}, instance:#{module_context.instance_type}, class:#{module_context.module_type} |- #{sub_type} <: #{super_type}" }
+      relation = Subtyping::Relation.new(sub_type: sub_type, super_type: super_type)
+      checker.check(
+        relation,
+        self_type: self_type,
+        instance_type: module_context.instance_type,
+        class_type: module_context.module_type,
+        constraints: constraints
+      )
     end
 
     def for_new_method(method_name, node, args:, self_type:, definition:)
@@ -142,10 +149,14 @@ module Steep
 
       if annots&.return_type && method_type&.type&.return_type
         check_relation(sub_type: annots.return_type, super_type: method_type.type.return_type).else do |result|
-          typing.add_error Errors::MethodReturnTypeAnnotationMismatch.new(node: node,
-                                                                          method_type: method_type.type.return_type,
-                                                                          annotation_type: annots.return_type,
-                                                                          result: result)
+          typing.add_error(
+            Diagnostic::Ruby::MethodReturnTypeAnnotationMismatch.new(
+              node: node,
+              method_type: method_type.type.return_type,
+              annotation_type: annots.return_type,
+              result: result
+            )
+          )
         end
       end
 
@@ -154,7 +165,7 @@ module Steep
       if method_type
         var_types = TypeConstruction.parameter_types(args, method_type.type)
         unless TypeConstruction.valid_parameter_env?(var_types, args.reject {|arg| arg.type == :blockarg}, method_type.type.params)
-          typing.add_error Errors::MethodArityMismatch.new(node: node)
+          typing.add_error Diagnostic::Ruby::MethodArityMismatch.new(node: node, method_type: method_type)
         end
       end
 
@@ -196,12 +207,16 @@ module Steep
       type_env = type_env.with_annotations(
         ivar_types: annots.ivar_types,
         const_types: annots.const_types,
-        self_type: annots.self_type || self_type
+        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
+        self_type: annots.self_type || self_type,
+        instance_type: module_context.instance_type,
+        class_type: module_context.module_type
       )
 
       if var_types
@@ -355,7 +370,9 @@ module Steep
 
       lvar_env = TypeInference::LocalVariableTypeEnv.empty(
         subtyping: checker,
-        self_type: module_context_.module_type
+        self_type: module_context_.module_type,
+        instance_type: module_context_.instance_type,
+        class_type: module_context_.module_type
       ).annotate(annots)
 
       self.class.new(
@@ -399,6 +416,9 @@ module Steep
 
         instance_type = AST::Types::Name::Instance.new(name: class_name, args: class_args)
         module_type = AST::Types::Name::Singleton.new(name: class_name)
+      else
+        instance_type = AST::Builtin::Object.instance_type
+        module_type = AST::Builtin::Object.module_type
       end
 
       if annots.instance_type
@@ -430,7 +450,9 @@ module Steep
 
       lvar_env = TypeInference::LocalVariableTypeEnv.empty(
         subtyping: checker,
-        self_type: module_context.module_type
+        self_type: module_context.module_type,
+        instance_type: module_context.instance_type,
+        class_type: module_context.module_type
       ).annotate(annots)
 
       class_body_context = TypeInference::Context.new(
@@ -516,7 +538,9 @@ module Steep
 
       lvar_env = TypeInference::LocalVariableTypeEnv.empty(
         subtyping: checker,
-        self_type: module_context.module_type
+        self_type: module_context.module_type,
+        instance_type: module_context.instance_type,
+        class_type: module_context.module_type
       ).annotate(annots)
 
       body_context = TypeInference::Context.new(
@@ -571,7 +595,7 @@ module Steep
           lvar_env.assign!(name, node: node, type: type) do |declared_type, assigned_type, result|
             relation = Subtyping::Relation.new(sub_type: assigned_type, super_type: declared_type)
             typing.add_error(
-              Errors::IncompatibleTypeCase.new(
+              Diagnostic::Ruby::IncompatibleTypeCase.new(
                 node: node,
                 var_name: name,
                 relation: relation,
@@ -585,30 +609,40 @@ module Steep
       lvar_env = lvar_env.annotate(annots) do |var, outer_type, inner_type, result|
         relation = Subtyping::Relation.new(sub_type: inner_type, super_type: outer_type)
         typing.add_error(
-          Errors::IncompatibleAnnotation.new(node: node,
-                                             var_name: var,
-                                             relation: relation,
-                                             result: result)
+          Diagnostic::Ruby::IncompatibleAnnotation.new(
+            node: node,
+            var_name: var,
+            relation: relation,
+            result: result
+          )
         )
       end
 
       type_env = context.type_env
 
       if type_case_override
-        type_env = type_env.with_annotations(self_type: self_type)
+        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
+        self_type: self_type,
+        instance_type: module_context.instance_type,
+        class_type: module_context.module_type
       ) do |var, relation, result|
         typing.add_error(
-          Errors::IncompatibleAnnotation.new(node: node,
-                                             var_name: var,
-                                             relation: relation,
-                                             result: result)
+          Diagnostic::Ruby::IncompatibleAnnotation.new(
+            node: node,
+            var_name: var,
+            relation: relation,
+            result: result
+          )
         )
       end
 
@@ -642,7 +676,7 @@ module Steep
       Pair.new(type: call.return_type, constr: self)
     end
 
-    def synthesize(node, hint: nil)
+    def synthesize(node, hint: nil, condition: false)
       Steep.logger.tagged "synthesize:(#{node.location.expression.to_s.split(/:/, 2).last})" do
         Steep.logger.debug node.type
         case node.type
@@ -691,10 +725,14 @@ module Steep
 
               constr = rhs_result.constr.update_lvar_env do |lvar_env|
                 lvar_env.assign(name, node: node, type: rhs_result.type) do |declared_type, actual_type, result|
-                  typing.add_error(Errors::IncompatibleAssignment.new(node: node,
-                                                                      lhs_type: declared_type,
-                                                                      rhs_type: actual_type,
-                                                                      result: result))
+                  typing.add_error(
+                    Diagnostic::Ruby::IncompatibleAssignment.new(
+                      node: node,
+                      lhs_type: declared_type,
+                      rhs_type: actual_type,
+                      result: result
+                    )
+                  )
                 end
               end
 
@@ -849,7 +887,7 @@ module Steep
                 constr.add_call(call)
               else
                 fallback_to_any node do
-                  Errors::UnexpectedSuper.new(node: node, method: method_context.name)
+                  Diagnostic::Ruby::UnexpectedSuper.new(node: node, method: method_context.name)
                 end
               end
             else
@@ -879,18 +917,20 @@ module Steep
             new.typing.add_context_for_node(node, context: new.context)
             new.typing.add_context_for_body(node, context: new.context)
 
-            each_child_node(args_node) do |arg|
-              _, new = new.synthesize(arg)
-            end
+            new = new.synthesize_children(args_node)
 
             body_pair = if body_node
                           return_type = expand_alias(new.method_context&.return_type)
                           if return_type && !return_type.is_a?(AST::Types::Void)
                             new.check(body_node, return_type) do |_, actual_type, result|
-                              typing.add_error(Errors::MethodBodyTypeMismatch.new(node: node,
-                                                                                  expected: new.method_context&.return_type,
-                                                                                  actual: actual_type,
-                                                                                  result: result))
+                              typing.add_error(
+                                Diagnostic::Ruby::MethodBodyTypeMismatch.new(
+                                  node: node,
+                                  expected: new.method_context&.return_type,
+                                  actual: actual_type,
+                                  result: result
+                                )
+                              )
                             end
                           else
                             new.synthesize(body_node)
@@ -900,10 +940,14 @@ module Steep
                           if return_type && !return_type.is_a?(AST::Types::Void)
                             result = check_relation(sub_type: AST::Builtin.nil_type, super_type: return_type)
                             if result.failure?
-                              typing.add_error(Errors::MethodBodyTypeMismatch.new(node: node,
-                                                                                  expected: new.method_context&.return_type,
-                                                                                  actual: AST::Builtin.nil_type,
-                                                                                  result: result))
+                              typing.add_error(
+                                Diagnostic::Ruby::MethodBodyTypeMismatch.new(
+                                  node: node,
+                                  expected: new.method_context&.return_type,
+                                  actual: AST::Builtin.nil_type,
+                                  result: result
+                                )
+                              )
                             end
                           end
 
@@ -936,14 +980,17 @@ module Steep
                            checker.factory.definition_builder.build_singleton(name)
                          end
 
+            args_node = node.children[2]
             new = for_new_method(node.children[1],
                                  node,
-                                 args: node.children[2].children,
+                                 args: args_node.children,
                                  self_type: self_type,
                                  definition: definition)
             new.typing.add_context_for_node(node, context: new.context)
             new.typing.add_context_for_body(node, context: new.context)
 
+            new = new.synthesize_children(args_node)
+
             each_child_node(node.children[2]) do |arg|
               new.synthesize(arg)
             end
@@ -952,10 +999,14 @@ module Steep
               return_type = expand_alias(new.method_context&.return_type)
               if return_type && !return_type.is_a?(AST::Types::Void)
                 new.check(node.children[3], return_type) do |return_type, actual_type, result|
-                  typing.add_error(Errors::MethodBodyTypeMismatch.new(node: node,
-                                                                      expected: return_type,
-                                                                      actual: actual_type,
-                                                                      result: result))
+                  typing.add_error(
+                    Diagnostic::Ruby::MethodBodyTypeMismatch.new(
+                      node: node,
+                      expected: return_type,
+                      actual: actual_type,
+                      result: result
+                    )
+                  )
                 end
               else
                 new.synthesize(node.children[3])
@@ -996,10 +1047,14 @@ module Steep
                   result = check_relation(sub_type: value_type, super_type: method_return_type)
 
                   if result.failure?
-                    typing.add_error(Errors::ReturnTypeMismatch.new(node: node,
-                                                                    expected: method_context&.return_type,
-                                                                    actual: value_type,
-                                                                    result: result))
+                    typing.add_error(
+                      Diagnostic::Ruby::ReturnTypeMismatch.new(
+                        node: node,
+                        expected: method_context&.return_type,
+                        actual: value_type,
+                        result: result
+                      )
+                    )
                   end
                 end
               end
@@ -1012,23 +1067,39 @@ module Steep
           value = node.children[0]
 
           if break_context
-            case
-            when value && break_context.break_type
-              check(value, break_context.break_type) do |break_type, actual_type, result|
-                typing.add_error Errors::BreakTypeMismatch.new(node: node,
-                                                               expected: break_type,
-                                                               actual: actual_type,
-                                                               result: result)
+            if break_type = break_context.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
+                check_relation(sub_type: AST::Builtin.nil_type, super_type: break_type).else do |result|
+                  typing.add_error(
+                    Diagnostic::Ruby::BreakTypeMismatch.new(
+                      node: node,
+                      expected: break_type,
+                      actual: AST::Builtin.nil_type,
+                      result: result
+                    )
+                  )
+                end
               end
-            when !value
-              # ok
             else
-              synthesize(value) if value
-              typing.add_error Errors::UnexpectedJumpValue.new(node: node)
+              if value
+                synthesize(value)
+                typing.add_error Diagnostic::Ruby::UnexpectedJumpValue.new(node: node)
+              end
             end
           else
-            synthesize(value)
-            typing.add_error Errors::UnexpectedJump.new(node: node)
+            synthesize(value) if value
+            typing.add_error Diagnostic::Ruby::UnexpectedJump.new(node: node)
           end
 
           add_typing(node, type: AST::Builtin.bottom_type)
@@ -1037,30 +1108,48 @@ module Steep
           value = node.children[0]
 
           if break_context
-            case
-            when value && break_context.next_type
-              check(value, break_context.next_type) do |break_type, actual_type, result|
-                typing.add_error Errors::BreakTypeMismatch.new(node: node,
-                                                               expected: break_type,
-                                                               actual: actual_type,
-                                                               result: result)
+            if next_type = break_context.next_type
+              next_type = deep_expand_alias(next_type)
+
+              if value
+                _, constr = check(value, next_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
+                check_relation(sub_type: AST::Builtin.nil_type, super_type: next_type).else do |result|
+                  typing.add_error(
+                    Diagnostic::Ruby::BreakTypeMismatch.new(
+                      node: node,
+                      expected: next_type,
+                      actual: AST::Builtin.nil_type,
+                      result: result
+                    )
+                  )
+                end
               end
-            when !value
-              # ok
             else
-              synthesize(value) if value
-              typing.add_error Errors::UnexpectedJumpValue.new(node: node)
+              if value
+                synthesize(value)
+                typing.add_error Diagnostic::Ruby::UnexpectedJumpValue.new(node: node)
+              end
             end
           else
-            synthesize(value)
-            typing.add_error Errors::UnexpectedJump.new(node: node)
+            synthesize(value) if value
+            typing.add_error Diagnostic::Ruby::UnexpectedJump.new(node: node)
           end
 
           add_typing(node, type: AST::Builtin.bottom_type)
 
         when :retry
           unless break_context
-            typing.add_error Errors::UnexpectedJump.new(node: node)
+            typing.add_error Diagnostic::Ruby::UnexpectedJump.new(node: node)
           end
           add_typing(node, type: AST::Builtin.bottom_type)
 
@@ -1073,10 +1162,6 @@ module Steep
               add_typing(node, type: type)
             else
               type = AST::Builtin.any_type
-              if context&.method_context&.method_type
-                Steep.logger.error { "Unknown arg type: #{node}" }
-              end
-
               lvasgn(node, type)
             end
           end
@@ -1094,10 +1179,12 @@ module Steep
             constr_ = constr.update_lvar_env do |env|
               env.assign(var.name, node: node, type: type) do |declared_type, type, result|
                 typing.add_error(
-                  Errors::IncompatibleAssignment.new(node: node,
-                                                     lhs_type: declared_type,
-                                                     rhs_type: type,
-                                                     result: result)
+                  Diagnostic::Ruby::IncompatibleAssignment.new(
+                    node: node,
+                    lhs_type: declared_type,
+                    rhs_type: type,
+                    result: result
+                  )
                 )
               end
             end
@@ -1113,7 +1200,7 @@ module Steep
               if context&.method_context&.method_type
                 Steep.logger.error { "Unknown variable: #{node}" }
               end
-              typing.add_error Errors::FallbackAny.new(node: node)
+              typing.add_error Diagnostic::Ruby::FallbackAny.new(node: node)
               type = AST::Builtin::Array.instance_type(AST::Builtin.any_type)
             end
 
@@ -1128,7 +1215,7 @@ module Steep
               if context&.method_context&.method_type
                 Steep.logger.error { "Unknown variable: #{node}" }
               end
-              typing.add_error Errors::FallbackAny.new(node: node)
+              typing.add_error Diagnostic::Ruby::FallbackAny.new(node: node)
               type = AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type, AST::Builtin.any_type)
             end
 
@@ -1211,7 +1298,7 @@ module Steep
                     key_types << splat_type.args[0]
                     value_types << splat_type.args[1]
                   else
-                    typing.add_error Errors::UnexpectedSplat.new(node: child, type: original_type)
+                    typing.add_error Diagnostic::Ruby::UnexpectedSplat.new(node: child, type: original_type)
                     key_types << AST::Builtin.any_type
                     value_types << AST::Builtin.any_type
                   end
@@ -1225,7 +1312,7 @@ module Steep
             value_type = value_types.empty? ? AST::Builtin.any_type : AST::Types::Union.build(types: value_types)
 
             if key_types.empty? && value_types.empty? && !hint
-              typing.add_error Errors::FallbackAny.new(node: node)
+              typing.add_error Diagnostic::Ruby::FallbackAny.new(node: node)
             end
 
             add_typing(node, type: AST::Builtin::Hash.instance_type(key_type, value_type))
@@ -1250,13 +1337,32 @@ module Steep
             constr = self
 
             name, sup, _ = node.children
-            _, constr = constr.synthesize(name)
+            if name.type == :const
+              # skip the last constant reference
+              if const_parent = name.children[0]
+                _, constr = constr.synthesize(const_parent)
+              end
+            else
+              _, constr = constr.synthesize(name)
+            end
             _, constr = constr.synthesize(sup) if sup
 
             constr.for_class(node).tap do |constructor|
+              if module_type = constructor.module_context&.module_type
+                _, constructor = constructor.add_typing(name, type: module_type)
+              else
+                _, constructor = constructor.fallback_to_any(name)
+              end
+
+              constructor.typing.source_index.add_definition(
+                constant: constructor.module_context.class_name,
+                definition: node
+              )
+
               constructor.typing.add_context_for_node(node, context: constructor.context)
               constructor.typing.add_context_for_body(node, context: constructor.context)
 
+              constructor.synthesize(node.children[1]) if node.children[1]
               constructor.synthesize(node.children[2]) if node.children[2]
 
               if constructor.module_context&.implement_name && !namespace_module?(node)
@@ -1275,6 +1381,11 @@ module Steep
             _, constr = constr.synthesize(name)
 
             for_module(node).yield_self do |constructor|
+              constructor.typing.source_index.add_definition(
+                constant: constructor.module_context.class_name,
+                definition: node
+              )
+
               constructor.typing.add_context_for_node(node, context: constructor.context)
               constructor.typing.add_context_for_body(node, context: constructor.context)
 
@@ -1295,7 +1406,7 @@ module Steep
 
             unless constructor
               typing.add_error(
-                Errors::UnsupportedSyntax.new(
+                Diagnostic::Ruby::UnsupportedSyntax.new(
                   node: node,
                   message: "sclass receiver must be instance type or singleton type, but type given `#{type}`"
                 )
@@ -1335,6 +1446,10 @@ module Steep
           const_name = constr.module_name_from_node(node)
 
           if const_name
+            if constant = module_context.const_env.lookup_constant(const_name)
+              typing.source_index.add_reference(constant: constant.name, ref: node)
+            end
+
             type = type_env.get(const: const_name) do
               constr.fallback_to_any(node)
             end
@@ -1352,18 +1467,38 @@ module Steep
             const_name = constr.module_name_from_node(node)
 
             if const_name
+              if constant = module_context.const_env.lookup_constant(const_name)
+                typing.source_index.add_definition(constant: constant.name, definition: node)
+              end
+
               const_type = type_env.get(const: const_name) {}
               value_type, constr = constr.synthesize(node.children.last, hint: const_type)
-              type = type_env.assign(const: const_name, type: value_type, self_type: self_type) do |error|
+              type = type_env.assign(
+                const: const_name,
+                type: value_type,
+                self_type: self_type,
+                instance_type: module_context.instance_type,
+                class_type: module_context.module_type
+              ) do |error|
                 case error
                 when Subtyping::Result::Failure
                   const_type = type_env.get(const: const_name)
-                  typing.add_error(Errors::IncompatibleAssignment.new(node: node,
-                                                                      lhs_type: const_type,
-                                                                      rhs_type: value_type,
-                                                                      result: error))
+                  typing.add_error(
+                    Diagnostic::Ruby::IncompatibleAssignment.new(
+                      node: node,
+                      lhs_type: const_type,
+                      rhs_type: value_type,
+                      result: error
+                    )
+                  )
                 when nil
-                  typing.add_error(Errors::UnknownConstantAssigned.new(node: node, type: value_type))
+                  typing.add_error(
+                    Diagnostic::Ruby::UnknownConstantAssigned.new(
+                      node: node,
+                      name: const_name,
+                      context: module_context
+                    )
+                  )
                 end
               end
 
@@ -1381,17 +1516,21 @@ module Steep
               block_type.type.params.flat_unnamed_params.map(&:last).zip(node.children).each do |(type, node)|
                 if node && type
                   check(node, type) do |_, rhs_type, result|
-                    typing.add_error(Errors::IncompatibleAssignment.new(node: node,
-                                                                        lhs_type: type,
-                                                                        rhs_type: rhs_type,
-                                                                        result: result))
+                    typing.add_error(
+                      Diagnostic::Ruby::IncompatibleAssignment.new(
+                        node: node,
+                        lhs_type: type,
+                        rhs_type: rhs_type,
+                        result: result
+                      )
+                    )
                   end
                 end
               end
 
               add_typing(node, type: block_type.type.return_type)
             else
-              typing.add_error(Errors::UnexpectedYield.new(node: node))
+              typing.add_error(Diagnostic::Ruby::UnexpectedYield.new(node: node))
               fallback_to_any node
             end
           else
@@ -1407,7 +1546,7 @@ module Steep
                 }
                 add_typing(node, type: union_type(*types))
               else
-                typing.add_error(Errors::UnexpectedSuper.new(node: node, method: method_context.name))
+                typing.add_error(Diagnostic::Ruby::UnexpectedSuper.new(node: node, method: method_context.name))
                 fallback_to_any node
               end
             else
@@ -1426,7 +1565,7 @@ module Steep
                   add_typing node, type: array
                 end
               else
-                typing.add_error Errors::FallbackAny.new(node: node)
+                typing.add_error Diagnostic::Ruby::FallbackAny.new(node: node)
                 add_typing node, type: AST::Builtin::Array.instance_type(AST::Builtin.any_type)
               end
             else
@@ -1464,18 +1603,22 @@ module Steep
           yield_self do
             left, right = node.children
 
-            left_type, constr = synthesize(left)
+            left_type, constr = synthesize(left, hint: hint, condition: true)
 
             interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
             truthy_env, falsey_env = interpreter.eval(env: constr.context.lvar_env, type: left_type, node: left)
 
+            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)
+                                   .synthesize(right, hint: hint, condition: true)
 
-            truthy_env, _ = interpreter.eval(env: truthy_env, type: right_type, node: right)
+            truthy_env, _ = interpreter.eval(env: constr.context.lvar_env, type: right_type, node: right)
 
             env = if right_type.is_a?(AST::Types::Bot)
                     falsey_env
@@ -1484,14 +1627,14 @@ module Steep
                   end
 
             type = case
-                   when left_type.is_a?(AST::Types::Logic::Base) && right_type.is_a?(AST::Types::Logic::Base)
-                     AST::Types::Logic::Env.new(truthy: truthy_env, falsy: env)
                    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
+
             add_typing(node,
                        type: type,
                        constr: constr.update_lvar_env { env })
@@ -1501,17 +1644,21 @@ module Steep
           yield_self do
             left, right = node.children
 
-            left_type, constr = synthesize(left, hint: hint)
+            left_type, constr = synthesize(left, hint: hint, condition: true)
 
             interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
             truthy_env, falsey_env = interpreter.eval(env: constr.context.lvar_env, type: left_type, node: left)
 
+            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)
+                                   .synthesize(right, hint: left_type, condition: true)
 
             _, falsey_env = interpreter.eval(env: falsey_env, type: right_type, node: right)
 
@@ -1522,12 +1669,14 @@ module Steep
                   end
 
             type = case
-                   when left_type.is_a?(AST::Types::Logic::Base) && right_type.is_a?(AST::Types::Logic::Base)
-                     AST::Types::Logic::Env.new(truthy: env, falsy: falsey_env)
+                   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
+
             add_typing(node,
                        type: type,
                        constr: constr.update_lvar_env { env })
@@ -1536,7 +1685,7 @@ module Steep
         when :if
           cond, true_clause, false_clause = node.children
 
-          cond_type, constr = synthesize(cond)
+          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)
 
@@ -1617,7 +1766,7 @@ module Steep
 
                 tests.each do |test|
                   test_node = test.updated(:send, [test, :===, var_node])
-                  test_type, test_constr = test_constr.synthesize(test_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])
@@ -1625,6 +1774,7 @@ module Steep
                   falsy_env = cond_vars.inject(falsy_env) do |env, var|
                     env.assign!(var, node: test_node, type: env[first_var])
                   end
+
                   test_envs << truthy_env
                   test_constr = test_constr.update_lvar_env { falsy_env }
                 end
@@ -1657,7 +1807,7 @@ module Steep
               if when_constr.context.lvar_env[cond_vars.first].is_a?(AST::Types::Bot)
                 # Exhaustive
                 if els
-                  typing.add_error Errors::ElseOnExhaustiveCase.new(node: els, type: cond_type)
+                  typing.add_error Diagnostic::Ruby::ElseOnExhaustiveCase.new(node: els, type: cond_type)
                 end
               else
                 unless els
@@ -1669,21 +1819,20 @@ module Steep
               branch_pairs = []
 
               when_constr = constr
+              clause_constr = constr
 
               whens.each do |clause|
                 *tests, body = clause.children
 
                 test_constr = when_constr
-                test_envs = []
 
                 tests.each do |test|
-                  test_type, test_constr = test_constr.synthesize(test)
+                  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)
-                  test_envs << truthy_env
+                  clause_constr = clause_constr.update_lvar_env { truthy_env }
                   test_constr = test_constr.update_lvar_env { falsy_env }
                 end
 
-                clause_constr = when_constr.update_lvar_env {|env| env.join(*test_envs) }
                 when_constr = test_constr
 
                 if body
@@ -1822,7 +1971,7 @@ module Steep
                        when AST::Types::Any
                          AST::Types::Any.new
                        else
-                         each = checker.factory.interface(collection_type, private: true).methods[:each]
+                         each = calculate_interface(collection_type, private: true).methods[:each]
                          method_type = (each&.method_types || []).find {|type| type.block && type.block.type.params.first_param }
                          method_type&.yield_self do |method_type|
                            method_type.block.type.params.first_param&.type
@@ -1846,7 +1995,7 @@ module Steep
               add_typing(node, type: collection_type, constr: constr)
             else
               fallback_to_any(node) do
-                Errors::NoMethod.new(
+                Diagnostic::Ruby::NoMethod.new(
                   node: node,
                   method: :each,
                   type: collection_type
@@ -1857,7 +2006,7 @@ module Steep
         when :while, :until
           yield_self do
             cond, body = node.children
-            cond_type, constr = synthesize(cond)
+            cond_type, constr = synthesize(cond, condition: true)
 
             interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
             truthy_env, falsy_env = interpreter.eval(env: constr.context.lvar_env, node: cond, type: cond_type)
@@ -1995,11 +2144,13 @@ module Steep
             end
 
             check(rhs, type) do |_, rhs_type, result|
-              typing.add_error(Errors::IncompatibleAssignment.new(
-                node: node,
-                lhs_type: type,
-                rhs_type: rhs_type,
-                result: result)
+              typing.add_error(
+                Diagnostic::Ruby::IncompatibleAssignment.new(
+                  node: node,
+                  lhs_type: type,
+                  rhs_type: rhs_type,
+                  result: result
+                )
               )
             end
           end
@@ -2008,7 +2159,7 @@ module Steep
           yield_self do
             name = node.children.first
             type = type_env.get(gvar: name) do
-              typing.add_error Errors::FallbackAny.new(node: node)
+              typing.add_error Diagnostic::Ruby::FallbackAny.new(node: node)
             end
 
             add_typing(node, type: type)
@@ -2022,24 +2173,29 @@ module Steep
               if hint.one_arg?
                 # Assumes Symbol#to_proc implementation
                 param_type = hint.type.params.required[0]
-                interface = checker.factory.interface(param_type, private: true)
-                method = interface.methods[value.children[0]]
-                if method
-                  return_types = method.method_types.select {|method_type|
-                    method_type.type.params.empty?
-                  }.map {|method_type|
-                    method_type.type.return_type
-                  }
-
-                  unless return_types.empty?
-                    type = AST::Types::Proc.new(
-                      type: Interface::Function.new(
-                        params: Interface::Function::Params.empty.update(required: [param_type]),
-                        return_type: AST::Types::Union.build(types: return_types),
-                        location: nil
-                      ),
-                      block: nil
-                    )
+                case param_type
+                when AST::Types::Any
+                  type = AST::Types::Any.new
+                else
+                  interface = calculate_interface(param_type, private: true)
+                  method = interface.methods[value.children[0]]
+                  if method
+                    return_types = method.method_types.select {|method_type|
+                      method_type.type.params.empty?
+                    }.map {|method_type|
+                      method_type.type.return_type
+                    }
+
+                    unless return_types.empty?
+                      type = AST::Types::Proc.new(
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.empty.update(required: [param_type]),
+                          return_type: AST::Types::Union.build(types: return_types),
+                          location: nil
+                        ),
+                        block: nil
+                      )
+                    end
                   end
                 end
               else
@@ -2077,10 +2233,12 @@ module Steep
               add_typing node, type: type, constr: constr
             else
               fallback_to_any node do
-                Errors::IncompatibleAssignment.new(node: node,
-                                                   lhs_type: var_type,
-                                                   rhs_type: type,
-                                                   result: result)
+                Diagnostic::Ruby::IncompatibleAssignment.new(
+                  node: node,
+                  lhs_type: var_type,
+                  rhs_type: type,
+                  result: result
+                )
               end
             end
           else
@@ -2104,7 +2262,12 @@ module Steep
 
         when :splat
           yield_self do
-            Steep.logger.warn { "Unsupported node #{node.type} (#{node.location.expression.source_buffer.name}:#{node.location.expression.line})" }
+            typing.add_error(
+              Diagnostic::Ruby::UnsupportedSyntax.new(
+                node: node,
+                message: "Unsupported splat node occurrence"
+              )
+            )
 
             each_child_node node do |child|
               synthesize(child)
@@ -2123,7 +2286,7 @@ module Steep
           add_typing node, type: AST::Builtin.any_type, constr: constr
 
         else
-          raise "Unexpected node: #{node.inspect}, #{node.location.expression}"
+          typing.add_error(Diagnostic::Ruby::UnsupportedSyntax.new(node: node))
 
         end.tap do |pair|
           unless pair.is_a?(Pair) && !pair.type.is_a?(Pair)
@@ -2132,6 +2295,10 @@ module Steep
             raise "#synthesize should return an instance of Pair: #{pair.class}, node=#{node.inspect}"
           end
         end
+      rescue StandardError => exn
+        Steep.log_error exn
+        typing.add_error(Diagnostic::Ruby::UnexpectedError.new(node: node, error: exn))
+        type_any_rec(node)
       end
     end
 
@@ -2149,14 +2316,24 @@ module Steep
 
     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) do |error|
+      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|
         case error
         when Subtyping::Result::Failure
           type = type_env.get(ivar: name)
-          typing.add_error(Errors::IncompatibleAssignment.new(node: node,
-                                                              lhs_type: type,
-                                                              rhs_type: rhs_type,
-                                                              result: error))
+          typing.add_error(
+            Diagnostic::Ruby::IncompatibleAssignment.new(
+              node: node,
+              lhs_type: type,
+              rhs_type: rhs_type,
+              result: error
+            )
+          )
         when nil
           fallback_to_any node
         end
@@ -2179,10 +2356,12 @@ module Steep
       name = node.children[0].name
       env = context.lvar_env.assign(name, node: node, type: type) do |declared_type, type, result|
         typing.add_error(
-          Errors::IncompatibleAssignment.new(node: node,
-                                             lhs_type: declared_type,
-                                             rhs_type: type,
-                                             result: result)
+          Diagnostic::Ruby::IncompatibleAssignment.new(
+            node: node,
+            lhs_type: declared_type,
+            rhs_type: type,
+            result: result
+          )
         )
       end
 
@@ -2192,14 +2371,24 @@ module Steep
     def ivasgn(node, type)
       ivar = node.children[0]
 
-      type_env.assign(ivar: ivar, type: type, self_type: self_type) do |error|
+      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|
         case error
         when Subtyping::Result::Failure
           var_type = type_env.get(ivar: ivar)
-          typing.add_error(Errors::IncompatibleAssignment.new(node: node,
-                                                              lhs_type: var_type,
-                                                              rhs_type: type,
-                                                              result: error))
+          typing.add_error(
+            Diagnostic::Ruby::IncompatibleAssignment.new(
+              node: node,
+              lhs_type: var_type,
+              rhs_type: type,
+              result: error
+            )
+          )
         when nil
           fallback_to_any node
         end
@@ -2376,6 +2565,7 @@ module Steep
       block_constr = for_block(
         block_params: params,
         block_param_hint: params_hint,
+        block_type_hint: return_hint,
         block_annotations: block_annotations,
         node_type_hint: nil
       )
@@ -2390,10 +2580,22 @@ module Steep
         return_type = block_constr.synthesize_block(
           node: node,
           block_body: block_body,
-          topdown_hint: true,
           block_type_hint: return_hint
-        ) do |error|
-          typing.add_error(error)
+        )
+
+        if expected_block_type = block_constr.block_context.body_type
+          check_relation(sub_type: return_type, super_type: expected_block_type).else do |result|
+            block_constr.typing.add_error(
+              Diagnostic::Ruby::BlockBodyTypeMismatch.new(
+                node: node,
+                expected: expected_block_type,
+                actual: return_type,
+                result: result
+              )
+            )
+
+            return_type = expected_block_type
+          end
         end
       else
         return_type = AST::Builtin.any_type
@@ -2447,7 +2649,7 @@ module Steep
             end
           end
         else
-          error = Errors::UnresolvedOverloading.new(
+          error = Diagnostic::Ruby::UnresolvedOverloading.new(
             node: node,
             receiver_type: receiver_type,
             method_name: method_name,
@@ -2473,21 +2675,37 @@ module Steep
               block_params: TypeInference::BlockParams.from_node(block_params, annotations: block_annotations),
               block_annotations: block_annotations,
               block_body: block_body
-            ) do |error|
-              constr.typing.add_error(error)
-            end
+            )
           end
         end
 
         constr.add_call(call)
       else
-        add_call(
+        skips = []
+        skips << receiver if receiver
+        skips << node.children[0] if node.type == :block
+        skips << block_params if block_params
+        skips << block_body if block_body
+
+        constr = synthesize_children(node, skips: skips)
+        if block_params
+          block_annotations = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
+
+          constr.type_block_without_hint(
+            node: node,
+            block_params: TypeInference::BlockParams.from_node(block_params, annotations: block_annotations),
+            block_annotations: block_annotations,
+            block_body: block_body
+          )
+        end
+
+        constr.add_call(
           TypeInference::MethodCall::NoMethodError.new(
             node: node,
             context: context.method_context,
             method_name: method_name,
             receiver_type: receiver_type,
-            error: Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
+            error: Diagnostic::Ruby::NoMethod.new(node: node, method: method_name, type: receiver_type)
           )
         )
       end
@@ -2525,7 +2743,7 @@ module Steep
                            context: context.method_context,
                            method_name: method_name,
                            receiver_type: receiver_type,
-                           error: Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
+                           error: Diagnostic::Ruby::NoMethod.new(node: node, method: method_name, type: receiver_type)
                          )
                        )
 
@@ -2542,13 +2760,13 @@ module Steep
                              context: context.method_context,
                              method_name: method_name,
                              receiver_type: receiver_type,
-                             error: Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
+                             error: Diagnostic::Ruby::NoMethod.new(node: node, method: method_name, type: receiver_type)
                            )
                          )
                        else
-                         interface = checker.factory.interface(expanded_self,
-                                                               private: !receiver,
-                                                               self_type: AST::Types::Self.new)
+                         interface = calculate_interface(expanded_self,
+                                                         private: !receiver,
+                                                         self_type: AST::Types::Self.new)
 
                          constr.type_send_interface(node,
                                                     interface: interface,
@@ -2560,9 +2778,7 @@ module Steep
                                                     block_body: block_body)
                        end
                      else
-                       interface = checker.factory.interface(receiver_type,
-                                                             private: !receiver,
-                                                             self_type: receiver_type)
+                       interface = calculate_interface(receiver_type, private: !receiver, self_type: receiver_type)
 
                        constr.type_send_interface(node,
                                                   interface: interface,
@@ -2575,27 +2791,19 @@ module Steep
                      end
 
       Pair.new(type: type, constr: constr)
-    rescue => exn
-      case exn
-      when RBS::NoTypeFoundError, RBS::NoMixinFoundError, RBS::NoSuperclassFoundError, RBS::InvalidTypeApplicationError
-        # ignore known RBS errors.
-      else
-        Steep.log_error(exn, message: "Unexpected error in #type_send: #{exn.message} (#{exn.class})")
-      end
-
-      error = Errors::UnexpectedError.new(node: node, error: exn)
+    end
 
-      type_any_rec(node)
+    def calculate_interface(type, private:, self_type: type)
+      case type
+      when AST::Types::Self
+        type = self_type
+      when AST::Types::Instance
+        type = module_context.instance_type
+      when AST::Types::Class
+        type = module_context.module_type
+      end
 
-      add_call(
-        TypeInference::MethodCall::Error.new(
-          node: node,
-          context: context.method_context,
-          method_name: method_name,
-          receiver_type: receiver_type,
-          errors: [error]
-        )
-      )
+      checker.factory.interface(type, private: private, self_type: self_type)
     end
 
     def expand_self(type)
@@ -2637,7 +2845,8 @@ module Steep
         all_decls = method.method_types.each.with_object(Set[]) do |method_type, set|
           set.merge(method_type.method_decls)
         end
-        error = Errors::IncompatibleArguments.new(node: node, receiver_type: receiver_type, method_type: method_type)
+
+        error = Diagnostic::Ruby::IncompatibleArguments.new(node: node, method_name: method_name, receiver_type: receiver_type, method_types: method.method_types)
         call = TypeInference::MethodCall::Error.new(
           node: node,
           context: context.method_context,
@@ -2702,7 +2911,7 @@ module Steep
 
               if keyword_type
                 check(value_node, keyword_type, constraints: constraints) do |expected, actual, result|
-                  return Errors::IncompatibleAssignment.new(
+                  return Diagnostic::Ruby::IncompatibleAssignment.new(
                     node: value_node,
                     lhs_type: expected,
                     rhs_type: actual,
@@ -2715,7 +2924,7 @@ module Steep
 
             else
               check(key_node, AST::Builtin::Symbol.instance_type, constraints: constraints) do |expected, actual, result|
-                return Errors::IncompatibleAssignment.new(
+                return Diagnostic::Ruby::IncompatibleAssignment.new(
                   node: key_node,
                   lhs_type: expected,
                   rhs_type: actual,
@@ -2728,7 +2937,7 @@ module Steep
             Steep.logger.warn("Keyword arg with kwsplat(**) node are not supported.")
 
             check(element.children[0], keyword_hash_type, constraints: constraints) do |expected, actual, result|
-              return Errors::IncompatibleAssignment.new(
+              return Diagnostic::Ruby::IncompatibleAssignment.new(
                 node: node,
                 lhs_type: expected,
                 rhs_type: actual,
@@ -2744,14 +2953,18 @@ module Steep
         when Set
           missing_keywords = Set.new(params.required_keywords.keys) - given_keys
           unless missing_keywords.empty?
-            return Errors::MissingKeyword.new(node: node,
-                                              missing_keywords: missing_keywords)
+            return Diagnostic::Ruby::MissingKeyword.new(
+              node: node,
+              missing_keywords: missing_keywords
+            )
           end
 
           extra_keywords = given_keys - Set.new(params.required_keywords.keys) - Set.new(params.optional_keywords.keys)
           if extra_keywords.any? && !params.rest_keywords
-            return Errors::UnexpectedKeyword.new(node: node,
-                                                 unexpected_keywords: extra_keywords)
+            return Diagnostic::Ruby::UnexpectedKeyword.new(
+              node: node,
+              unexpected_keywords: extra_keywords
+            )
           end
         end
       else
@@ -2778,12 +2991,13 @@ module Steep
 
         node_type = synthesize(node, hint: hash_type).type
 
-        check_relation(sub_type: node_type, super_type: hash_type).else do
-          return Errors::ArgumentTypeMismatch.new(
+        check_relation(sub_type: node_type, super_type: hash_type).else do |result|
+          return Diagnostic::Ruby::ArgumentTypeMismatch.new(
             node: node,
             receiver_type: receiver_type,
             expected: hash_type,
-            actual: node_type
+            actual: node_type,
+            result: result
           )
         end
       end
@@ -2818,11 +3032,12 @@ module Steep
                                constr.synthesize(arg_node, hint: topdown_hint ? param_type : nil)
                              end
 
-          check_relation(sub_type: arg_type, super_type: param_type, constraints: constraints).else do
-            errors << Errors::ArgumentTypeMismatch.new(node: arg_node,
-                                                       receiver_type: receiver_type,
-                                                       expected: param_type,
-                                                       actual: arg_type)
+          check_relation(sub_type: arg_type, super_type: param_type, constraints: constraints).else do |result|
+            errors << Diagnostic::Ruby::ArgumentTypeMismatch.new(node: arg_node,
+                                                                 receiver_type: receiver_type,
+                                                                 expected: param_type,
+                                                                 actual: arg_type,
+                                                                 result: result)
           end
         else
           # keyword
@@ -2831,7 +3046,7 @@ module Steep
                                             method_type: method_type,
                                             constraints: constraints)
 
-          if result.is_a?(Errors::Base)
+          if result.is_a?(Diagnostic::Ruby::Base)
             errors << result
           end
         end
@@ -2850,6 +3065,7 @@ module Steep
               block_constr = constr.for_block(
                 block_params: block_params_,
                 block_param_hint: method_type.block.type.params,
+                block_type_hint: method_type.block.type.return_type,
                 block_annotations: block_annotations,
                 node_type_hint: method_type.type.return_type
               )
@@ -2866,7 +3082,7 @@ module Steep
 
                 if param.type
                   check_relation(sub_type: type, super_type: param.type, constraints: constraints).else do |result|
-                    error = Errors::IncompatibleAssignment.new(
+                    error = Diagnostic::Ruby::IncompatibleAssignment.new(
                       node: param.node,
                       lhs_type: param.type,
                       rhs_type: type,
@@ -2880,6 +3096,8 @@ module Steep
               s = constraints.solution(
                 checker,
                 self_type: self_type,
+                instance_type: module_context.instance_type,
+                class_type: module_context.module_type,
                 variance: variance,
                 variables: method_type.type.params.free_variables + method_type.block.type.params.free_variables
               )
@@ -2888,12 +3106,9 @@ module Steep
               if block_body
                 block_body_type = block_constr.synthesize_block(
                   node: node,
-                  block_type_hint: method_type.block.type.return_type,
                   block_body: block_body,
-                  topdown_hint: topdown_hint
-                ) do |error|
-                  errors << error
-                end
+                  block_type_hint: method_type.block.type.return_type
+                )
               else
                 block_body_type = AST::Builtin.nil_type
               end
@@ -2904,7 +3119,14 @@ module Steep
 
               case result
               when Subtyping::Result::Success
-                s = constraints.solution(checker, self_type: self_type, variance: variance, variables: fresh_vars)
+                s = constraints.solution(
+                  checker,
+                  self_type: self_type,
+                  instance_type: module_context.instance_type,
+                  class_type: module_context.module_type,
+                  variance: variance,
+                  variables: fresh_vars
+                )
                 method_type = method_type.subst(s)
 
                 return_type = method_type.type.return_type
@@ -2913,35 +3135,20 @@ module Steep
                 end
 
               when Subtyping::Result::Failure
-                given_block_type = AST::Types::Proc.new(
-                  type: Interface::Function.new(
-                    params: method_type.block.type.params || block_params.params_type,
-                    return_type: block_body_type,
-                    location: nil
-                  ),
-                  block: nil
-                )
-
-                method_block_type = AST::Types::Proc.new(
-                  type: Interface::Function.new(
-                    params: method_type.block.type.params,
-                    return_type: method_type.block.type.return_type,
-                    location: nil
-                  ),
-                  block: nil
+                errors << Diagnostic::Ruby::BlockBodyTypeMismatch.new(
+                  node: node,
+                  expected: method_type.block.type.return_type,
+                  actual: block_body_type,
+                  result: result
                 )
 
-                errors << Errors::BlockTypeMismatch.new(node: node,
-                                                        expected: method_block_type,
-                                                        actual: given_block_type,
-                                                        result: result)
-
                 return_type = method_type.type.return_type
               end
 
               block_constr.typing.save!
+
             rescue Subtyping::Constraints::UnsatisfiableConstraint => exn
-              errors << Errors::UnsatisfiableConstraint.new(
+              errors << Diagnostic::Ruby::UnsatisfiableConstraint.new(
                 node: node,
                 method_type: method_type,
                 var: exn.var,
@@ -2959,12 +3166,19 @@ module Steep
               method_type = method_type.subst(s)
             end
           else
-            errors << Errors::UnsupportedSyntax.new(
+            errors << Diagnostic::Ruby::UnsupportedSyntax.new(
               node: block_params,
               message: "Unsupported block params pattern, probably masgn?"
             )
 
-            s = constraints.solution(checker, variance: variance, variables: fresh_vars, self_type: self_type)
+            s = constraints.solution(
+              checker,
+              variance: variance,
+              variables: fresh_vars,
+              self_type: self_type,
+              instance_type: module_context.instance_type,
+              class_type: module_context.module_type
+            )
             method_type = method_type.subst(s)
           end
         else
@@ -2974,7 +3188,7 @@ module Steep
             errors << error
           end
 
-          errors << Errors::UnexpectedBlockGiven.new(
+          errors << Diagnostic::Ruby::UnexpectedBlockGiven.new(
             node: node,
             method_type: method_type
           )
@@ -2985,14 +3199,28 @@ module Steep
           # Method call without block is allowed
           unless args.block_pass_arg
             # OK, without block
-            s = constraints.solution(checker, variance: variance, variables: fresh_vars, self_type: self_type)
+            s = constraints.solution(
+              checker,
+              variance: variance,
+              variables: fresh_vars,
+              self_type: self_type,
+              instance_type: module_context.instance_type,
+              class_type: module_context.module_type
+            )
             method_type = method_type.subst(s)
           else
             # &block arg is given
-            s = constraints.solution(checker, variance: variance, variables: fresh_vars, self_type: self_type)
+            s = constraints.solution(
+              checker,
+              variance: variance,
+              variables: fresh_vars,
+              self_type: self_type,
+              instance_type: module_context.instance_type,
+              class_type: module_context.module_type
+            )
             method_type = method_type.subst(s)
 
-            errors << Errors::UnexpectedBlockGiven.new(
+            errors << Diagnostic::Ruby::UnexpectedBlockGiven.new(
               node: node,
               method_type: method_type
             )
@@ -3000,16 +3228,32 @@ module Steep
         else
           unless args.block_pass_arg
             # Required block is missing
-            errors << Errors::RequiredBlockMissing.new(
+            errors << Diagnostic::Ruby::RequiredBlockMissing.new(
               node: node,
               method_type: method_type
             )
 
-            s = constraints.solution(checker, variance: variance, variables: fresh_vars, self_type: self_type)
+            s = constraints.solution(
+              checker,
+              variance: variance,
+              variables: fresh_vars,
+              self_type: self_type,
+              instance_type: module_context.instance_type,
+              class_type: module_context.module_type
+            )
             method_type = method_type.subst(s)
           else
             begin
-              method_type = method_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: occurence.params))
+              method_type = method_type.subst(
+                constraints.solution(
+                  checker,
+                  self_type: self_type,
+                  instance_type: module_context.instance_type,
+                  class_type: module_context.module_type,
+                  variance: variance,
+                  variables: occurence.params
+                )
+              )
               hint_type = if topdown_hint
                             AST::Types::Proc.new(type: method_type.block.type, block: nil)
                           end
@@ -3025,13 +3269,24 @@ module Steep
 
               result = check_relation(sub_type: given_block_type, super_type: method_block_type, constraints: constraints)
               result.else do |result|
-                errors << Errors::BlockTypeMismatch.new(node: node,
-                                                        expected: method_block_type,
-                                                        actual: given_block_type,
-                                                        result: result)
+                errors << Diagnostic::Ruby::BlockTypeMismatch.new(
+                  node: args.block_pass_arg,
+                  expected: method_block_type,
+                  actual: given_block_type,
+                  result: result
+                )
               end
 
-              method_type = method_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: method_type.free_variables))
+              method_type = method_type.subst(
+                constraints.solution(
+                  checker,
+                  self_type: self_type,
+                  instance_type: module_context.instance_type,
+                  class_type: module_context.module_type,
+                  variance: variance,
+                  variables: method_type.free_variables
+                )
+              )
             end
           end
         end
@@ -3069,8 +3324,9 @@ module Steep
       block_constr = for_block(
         block_params: block_params,
         block_param_hint: nil,
+        block_type_hint: AST::Builtin.any_type,
         block_annotations: block_annotations,
-        node_type_hint: nil
+        node_type_hint: AST::Builtin.any_type
       )
 
       block_constr.typing.add_context_for_body(node, context: block_constr.context)
@@ -3079,10 +3335,23 @@ module Steep
         _, block_constr = block_constr.synthesize(param.node, hint: param.type)
       end
 
-      block_constr.synthesize_block(node: node, block_type_hint: nil, block_body: block_body, topdown_hint: false, &block)
+      block_type = block_constr.synthesize_block(node: node, block_type_hint: nil, block_body: block_body)
+
+      if expected_block_type = block_constr.block_context.body_type
+        block_constr.check_relation(sub_type: block_type, super_type: expected_block_type).else do |result|
+          block_constr.typing.add_error(
+            Diagnostic::Ruby::BlockBodyTypeMismatch.new(
+              node: node,
+              expected: expected_block_type,
+              actual: block_type,
+              result: result
+            )
+          )
+        end
+      end
     end
 
-    def for_block(block_params:, block_param_hint:, block_annotations:, node_type_hint:)
+    def for_block(block_params:, block_param_hint:, block_type_hint:, block_annotations:, node_type_hint:)
       block_param_pairs = block_param_hint && block_params.zip(block_param_hint)
 
       param_types_hash = {}
@@ -3114,7 +3383,7 @@ module Steep
                    end
 
       block_context = TypeInference::Context::BlockContext.new(
-        body_type: block_annotations.block_type
+        body_type: block_annotations.block_type || block_type_hint || AST::Builtin.any_type
       )
       break_context = TypeInference::Context::BreakContext.new(
         break_type: break_type,
@@ -3139,20 +3408,9 @@ module Steep
       )
     end
 
-    def synthesize_block(node:, block_type_hint:, block_body:, topdown_hint:)
+    def synthesize_block(node:, block_type_hint:, block_body:)
       if block_body
-        body_type, _, context =
-          if (body_type = block_context.body_type)
-            check(block_body, body_type) do |expected, actual, result|
-              error = Errors::BlockTypeMismatch.new(node: block_body,
-                                                    expected: expected,
-                                                    actual: actual,
-                                                    result: result)
-              yield(error) if block_given?
-            end
-          else
-            synthesize(block_body, hint: topdown_hint ? block_type_hint : nil)
-          end
+        body_type, _, context = synthesize(block_body, hint: block_context.body_type || block_type_hint)
 
         range = block_body.loc.expression.end_pos..node.loc.end.begin_pos
         typing.add_context(range, context: context)
@@ -3245,7 +3503,7 @@ module Steep
       if module_name.namespace.relative?
         (current_namespace + module_name.namespace).append(module_name.name)
       else
-        module_name
+        module_name.to_namespace
       end
     end
 
@@ -3295,10 +3553,14 @@ module Steep
           # ok
         else
           if module_name.name == module_context&.class_name
-            typing.add_error Errors::MethodDefinitionMissing.new(node: node,
-                                                                 module_name: module_name.name,
-                                                                 kind: :instance,
-                                                                 missing_method: method_name)
+            typing.add_error(
+              Diagnostic::Ruby::MethodDefinitionMissing.new(
+                node: node,
+                module_name: module_name.name,
+                kind: :instance,
+                missing_method: method_name
+              )
+            )
           end
         end
       end
@@ -3310,26 +3572,32 @@ module Steep
           # ok
         else
           if module_name.name == module_context&.class_name
-            typing.add_error Errors::MethodDefinitionMissing.new(node: node,
-                                                                 module_name: module_name.name,
-                                                                 kind: :module,
-                                                                 missing_method: method_name)
+            typing.add_error(
+              Diagnostic::Ruby::MethodDefinitionMissing.new(node: node,
+                                                            module_name: module_name.name,
+                                                            kind: :module,
+                                                            missing_method: method_name)
+            )
           end
         end
       end
 
       annotations.instance_dynamics.each do |method_name|
         unless expected_instance_method_names.member?(method_name)
-          typing.add_error Errors::UnexpectedDynamicMethod.new(node: node,
-                                                               module_name: module_name.name,
-                                                               method_name: method_name)
+          typing.add_error(
+            Diagnostic::Ruby::UnexpectedDynamicMethod.new(node: node,
+                                                          module_name: module_name.name,
+                                                          method_name: method_name)
+          )
         end
       end
       annotations.module_dynamics.each do |method_name|
         unless expected_module_method_names.member?(method_name)
-          typing.add_error Errors::UnexpectedDynamicMethod.new(node: node,
-                                                               module_name: module_name.name,
-                                                               method_name: method_name)
+          typing.add_error(
+            Diagnostic::Ruby::UnexpectedDynamicMethod.new(node: node,
+                                                          module_name: module_name.name,
+                                                          method_name: method_name)
+          )
         end
       end
     end
@@ -3357,7 +3625,7 @@ module Steep
       if block_given?
         typing.add_error yield
       else
-        typing.add_error Errors::FallbackAny.new(node: node)
+        typing.add_error Diagnostic::Ruby::FallbackAny.new(node: node)
       end
 
       add_typing node, type: AST::Builtin.any_type
@@ -3390,6 +3658,8 @@ module Steep
       each_child_node(node) do |child|
         type_any_rec(child)
       end
+
+      Pair.new(type: AST::Builtin.any_type, constr: self)
     end
 
     def fallback_any_rec(node)