steep 0.34.0 → 0.39.0

data/lib/steep/subtyping/variable_occurrence.rb

@@ -10,12 +10,12 @@ module Steep
       end
 
       def add_method_type(method_type)
-        method_type.params.each_type do |type|
+        method_type.type.params.each_type do |type|
           each_var(type) do |var|
             params << var
           end
         end
-        each_var(method_type.return_type) do |var|
+        each_var(method_type.type.return_type) do |var|
           returns << var
         end
 

data/lib/steep/subtyping/variable_variance.rb

@@ -25,8 +25,8 @@ module Steep
         covariants = Set.new
         contravariants = Set.new
 
-        add_params(method_type.params, block: false, contravariants: contravariants, covariants: covariants)
-        add_type(method_type.return_type, variance: :covariant, covariants: covariants, contravariants: contravariants)
+        add_params(method_type.type.params, block: false, contravariants: contravariants, covariants: covariants)
+        add_type(method_type.type.return_type, variance: :covariant, covariants: covariants, contravariants: contravariants)
 
         method_type.block&.type&.yield_self do |proc|
           add_params(proc.params, block: true, contravariants: contravariants, covariants: covariants)

data/lib/steep/type_construction.rb

@@ -140,10 +140,10 @@ module Steep
 
       method_type = annotation_method_type || definition_method_type
 
-      if annots&.return_type && method_type&.return_type
-        check_relation(sub_type: annots.return_type, super_type: method_type.return_type).else do |result|
+      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.return_type,
+                                                                          method_type: method_type.type.return_type,
                                                                           annotation_type: annots.return_type,
                                                                           result: result)
         end
@@ -152,19 +152,18 @@ module Steep
       # constructor_method = method&.attributes&.include?(:constructor)
 
       if method_type
-        var_types = TypeConstruction.parameter_types(args, method_type)
-        unless TypeConstruction.valid_parameter_env?(var_types, args.reject {|arg| arg.type == :blockarg}, method_type.params)
+        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)
         end
       end
 
       if (block_arg = args.find {|arg| arg.type == :blockarg})
         if method_type&.block
-          block_type = if method_type.block.optional?
-                         AST::Types::Union.build(types: [method_type.block.type, AST::Builtin.nil_type])
-                       else
-                         method_type.block.type
-                       end
+          block_type = AST::Types::Proc.new(type: method_type.block.type, block: nil)
+          if method_type.block.optional?
+            block_type = AST::Types::Union.build(types: [block_type, AST::Builtin.nil_type])
+          end
           var_types[block_arg.children[0]] = block_type
         end
       end
@@ -183,7 +182,7 @@ module Steep
         name: method_name,
         method: definition && definition.methods[method_name],
         method_type: method_type,
-        return_type: annots.return_type || method_type&.return_type || AST::Builtin.any_type,
+        return_type: annots.return_type || method_type&.type&.return_type || AST::Builtin.any_type,
         constructor: false,
         super_method: super_method
       )
@@ -400,6 +399,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
@@ -643,7 +645,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
@@ -880,9 +882,7 @@ 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)
@@ -937,14 +937,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
@@ -1013,22 +1016,30 @@ 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 Errors::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 Errors::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 Errors::UnexpectedJumpValue.new(node: node)
+              end
             end
           else
-            synthesize(value)
+            synthesize(value) if value
             typing.add_error Errors::UnexpectedJump.new(node: node)
           end
 
@@ -1038,22 +1049,32 @@ 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 Errors::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 Errors::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 Errors::UnexpectedJumpValue.new(node: node)
+              end
             end
           else
-            synthesize(value)
+            synthesize(value) if value
             typing.add_error Errors::UnexpectedJump.new(node: node)
           end
 
@@ -1074,10 +1095,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
@@ -1251,13 +1268,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)
@@ -1276,6 +1312,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)
 
@@ -1336,6 +1377,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
@@ -1353,6 +1398,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_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|
@@ -1404,7 +1453,7 @@ module Steep
             if method_context&.method
               if method_context.super_method
                 types = method_context.super_method.method_types.map {|method_type|
-                  checker.factory.method_type(method_type, self_type: self_type, method_decls: Set[]).return_type
+                  checker.factory.method_type(method_type, self_type: self_type, method_decls: Set[]).type.return_type
                 }
                 add_typing(node, type: union_type(*types))
               else
@@ -1465,67 +1514,89 @@ 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)
 
-            type = if left_type.is_a?(AST::Types::Boolean)
+            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
+                  else
+                    context.lvar_env.join(falsey_env, constr.context.lvar_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 = AST::Types::Logic::Env.new(truthy: truthy_env, falsy: env, type: type) if condition
+
             add_typing(node,
                        type: type,
-                       constr: constr.update_lvar_env do
-                         if right_type.is_a?(AST::Types::Bot)
-                           falsey_env
-                         else
-                           context.lvar_env.join(falsey_env, constr.context.lvar_env)
-                         end
-                       end)
+                       constr: constr.update_lvar_env { env })
           end
 
         when :or
           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)
 
-            left_type_t, _ = checker.factory.unwrap_optional(left_type)
+            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_t)
+                                   .synthesize(right, hint: left_type, condition: true)
 
-            type = union_type(left_type_t, right_type)
+            _, falsey_env = interpreter.eval(env: falsey_env, type: right_type, node: right)
+
+            env = if right_type.is_a?(AST::Types::Bot)
+                    truthy_env
+                  else
+                    context.lvar_env.join(truthy_env, constr.context.lvar_env)
+                  end
+
+            type = case
+                   when check_relation(sub_type: left_type, super_type: AST::Builtin.bool_type).success?
+                     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 do
-                         if right_type.is_a?(AST::Types::Bot)
-                           truthy_env
-                         else
-                           context.lvar_env.join(truthy_env, constr.context.lvar_env)
-                         end
-                       end)
+                       constr: constr.update_lvar_env { env })
           end
 
         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)
 
@@ -1584,6 +1655,18 @@ module Steep
 
               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,
+                  [
+                    ASTUtils::Labeling::LabeledName.new(name: first_var, label: 0)
+                  ]
+                )
+              else
+                first_var = nil
+                var_node = cond
+              end
 
               when_constr = constr
               whens.each do |clause|
@@ -1593,9 +1676,16 @@ module Steep
                 test_envs = []
 
                 tests.each do |test|
-                  test_node = test.updated(:send, [test, :===, cond.dup])
-                  test_type, test_constr = test_constr.synthesize(test_node)
+                  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_envs << truthy_env
                   test_constr = test_constr.update_lvar_env { falsy_env }
                 end
@@ -1625,10 +1715,6 @@ module Steep
               types = branch_pairs.map(&:type)
               constrs = branch_pairs.map(&:constr)
 
-              unless els
-                constrs << when_constr
-              end
-
               if when_constr.context.lvar_env[cond_vars.first].is_a?(AST::Types::Bot)
                 # Exhaustive
                 if els
@@ -1636,6 +1722,7 @@ module Steep
                 end
               else
                 unless els
+                  constrs << when_constr
                   types << AST::Builtin.nil_type
                 end
               end
@@ -1643,21 +1730,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
@@ -1831,7 +1917,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,17 +2081,25 @@ module Steep
             if hint.is_a?(AST::Types::Proc) && value.type == :sym
               if hint.one_arg?
                 # Assumes Symbol#to_proc implementation
-                param_type = hint.params.required[0]
+                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.params.each_type.count == 0
-                  }.map(&:return_type)
+                    method_type.type.params.empty?
+                  }.map {|method_type|
+                    method_type.type.return_type
+                  }
 
                   unless return_types.empty?
-                    type = AST::Types::Proc.new(params: Interface::Params.empty.update(required: [param_type]),
-                                                return_type: AST::Types::Union.build(types: return_types))
+                    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
               else
@@ -2070,7 +2164,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(
+              Errors::UnsupportedSyntax.new(
+                node: node,
+                message: "Unsupported splat node occurrence"
+              )
+            )
 
             each_child_node node do |child|
               synthesize(child)
@@ -2089,7 +2188,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(Errors::UnsupportedSyntax.new(node: node))
 
         end.tap do |pair|
           unless pair.is_a?(Pair) && !pair.type.is_a?(Pair)
@@ -2335,13 +2434,14 @@ module Steep
 
       case type_hint
       when AST::Types::Proc
-        params_hint = type_hint.params
-        return_hint = type_hint.return_type
+        params_hint = type_hint.type.params
+        return_hint = type_hint.type.return_type
       end
 
       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
       )
@@ -2356,18 +2456,34 @@ 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(
+              Errors::BlockBodyTypeMismatch.new(
+                node: block_body,
+                expected: expected_block_type,
+                actual: return_type,
+                result: result
+              )
+            )
+
+            return_type = expected_block_type
+          end
         end
       else
         return_type = AST::Builtin.any_type
       end
 
       block_type = AST::Types::Proc.new(
-        params: params_hint || params.params_type,
-        return_type: return_type
+        type: Interface::Function.new(
+          params: params_hint || params.params_type,
+          return_type: return_type,
+          location: nil
+        ),
+        block: nil
       )
 
       add_typing node, type: block_type
@@ -2423,7 +2539,10 @@ module Steep
             errors: [error]
           )
 
-          constr = synthesize_children(node, skips: [receiver])
+          skips = [receiver]
+          skips << node.children[0] if node.type == :block
+
+          constr = synthesize_children(node, skips: skips)
           if block_params
             block_annotations = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
 
@@ -2432,15 +2551,31 @@ module Steep
               block_params: TypeInference::BlockParams.from_node(block_params, annotations: block_annotations),
               block_annotations: block_annotations,
               block_body: block_body
-            ) do |error|
-              errors << 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,
@@ -2570,7 +2705,7 @@ module Steep
 
       results = method.method_types.flat_map do |method_type|
         Steep.logger.tagged method_type.to_s do
-          zips = args.zips(method_type.params, method_type.block&.type)
+          zips = args.zips(method_type.type.params, method_type.block&.type)
 
           zips.map do |arg_pairs|
             typing.new_child(node_range) do |child_typing|
@@ -2602,7 +2737,7 @@ module Steep
           context: context.method_context,
           method_name: method_name,
           receiver_type: receiver_type,
-          return_type: method_type.return_type,
+          return_type: method_type.type.return_type,
           errors: [error],
           method_decls: all_decls
         )
@@ -2625,7 +2760,7 @@ module Steep
     end
 
     def check_keyword_arg(receiver_type:, node:, method_type:, constraints:)
-      params = method_type.params
+      params = method_type.type.params
 
       case node.type
       when :hash
@@ -2727,7 +2862,7 @@ module Steep
           )
         else
           hash_elements = params.required_keywords.merge(
-            method_type.params.optional_keywords.transform_values do |type|
+            params.optional_keywords.transform_values do |type|
               AST::Types::Union.build(types: [type, AST::Builtin.nil_type])
             end
           )
@@ -2809,8 +2944,9 @@ 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.return_type
+                node_type_hint: method_type.type.return_type
               )
               block_constr = block_constr.with_new_typing(
                 block_constr.typing.new_child(
@@ -2840,19 +2976,16 @@ module Steep
                 checker,
                 self_type: self_type,
                 variance: variance,
-                variables: method_type.params.free_variables + method_type.block.type.params.free_variables
+                variables: method_type.type.params.free_variables + method_type.block.type.params.free_variables
               )
               method_type = method_type.subst(s)
               block_constr = block_constr.update_lvar_env {|env| env.subst(s) }
               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
@@ -2866,25 +2999,40 @@ module Steep
                 s = constraints.solution(checker, self_type: self_type, variance: variance, variables: fresh_vars)
                 method_type = method_type.subst(s)
 
-                return_type = method_type.return_type
+                return_type = method_type.type.return_type
                 if break_type = block_annotations.break_type
                   return_type = union_type(break_type, return_type)
                 end
 
               when Subtyping::Result::Failure
-                block_type = AST::Types::Proc.new(
-                  params: method_type.block.type.params || block_params.params_type,
-                  return_type: block_body_type
+                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 << Errors::BlockTypeMismatch.new(node: node,
-                                                        expected: method_type.block.type,
-                                                        actual: block_type,
+                                                        expected: method_block_type,
+                                                        actual: given_block_type,
                                                         result: result)
 
-                return_type = method_type.return_type
+                return_type = method_type.type.return_type
               end
 
               block_constr.typing.save!
+
             rescue Subtyping::Constraints::UnsatisfiableConstraint => exn
               errors << Errors::UnsatisfiableConstraint.new(
                 node: node,
@@ -2955,23 +3103,24 @@ module Steep
           else
             begin
               method_type = method_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: occurence.params))
-              block_type, constr = constr.synthesize(args.block_pass_arg, hint: topdown_hint ? method_type.block.type : nil)
-              result = check_relation(
-                sub_type: block_type,
-                super_type: method_type.block.yield_self {|expected_block|
-                  if expected_block.optional?
-                    AST::Builtin.optional(expected_block.type)
-                  else
-                    expected_block.type
-                  end
-                },
-                constraints: constraints
-              )
+              hint_type = if topdown_hint
+                            AST::Types::Proc.new(type: method_type.block.type, block: nil)
+                          end
+              given_block_type, constr = constr.synthesize(args.block_pass_arg, hint: hint_type)
+              method_block_type = method_type.block.yield_self {|expected_block|
+                proc_type = AST::Types::Proc.new(type: expected_block.type, block: nil)
+                if expected_block.optional?
+                  AST::Builtin.optional(proc_type)
+                else
+                  proc_type
+                end
+              }
 
+              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_type.block.type,
-                                                        actual: block_type,
+                                                        expected: method_block_type,
+                                                        actual: given_block_type,
                                                         result: result)
               end
 
@@ -2988,7 +3137,7 @@ module Steep
                  receiver_type: receiver_type,
                  method_name: method_name,
                  actual_method_type: method_type,
-                 return_type: return_type || method_type.return_type,
+                 return_type: return_type || method_type.type.return_type,
                  method_decls: method_type.method_decls
                )
              else
@@ -2997,7 +3146,7 @@ module Steep
                  context: context.method_context,
                  receiver_type: receiver_type,
                  method_name: method_name,
-                 return_type: return_type || method_type.return_type,
+                 return_type: return_type || method_type.type.return_type,
                  method_decls: method_type.method_decls,
                  errors: errors
                )
@@ -3013,8 +3162,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)
@@ -3023,10 +3173,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(
+            Errors::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 = {}
@@ -3058,7 +3221,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,
@@ -3083,20 +3246,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)
@@ -3189,7 +3341,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
 
@@ -3224,8 +3376,10 @@ module Steep
         end
       end
       expected_module_method_names = (module_context.module_definition&.methods || {}).each.with_object(Set[]) do |(name, method), set|
-        if method.implemented_in == module_context.module_definition.type_name
-          set << name
+        if name != :new
+          if method.implemented_in == module_context.module_definition.type_name
+            set << name
+          end
         end
       end
 
@@ -3486,6 +3640,8 @@ module Steep
     end
 
     def try_hash_type(node, hint)
+      hint = expand_alias(hint)
+
       case hint
       when AST::Types::Record
         typing.new_child(node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }) do |child_typing|