steep 0.40.0 → 0.44.0

data/lib/steep/subtyping/constraints.rb

@@ -190,7 +190,7 @@ module Steep
         when 1
           upper_bound.first
         else
-          AST::Types::Union.build(types: upper_bound.to_a)
+          AST::Types::Intersection.build(types: upper_bound.to_a)
         end
       end
 
@@ -203,11 +203,11 @@ module Steep
         when 1
           lower_bound.first
         else
-          AST::Types::Intersection.build(types: lower_bound.to_a)
+          AST::Types::Union.build(types: lower_bound.to_a)
         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:)
@@ -200,19 +207,23 @@ 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
         lvar_env = lvar_env.update(
           assigned_types: var_types.each.with_object({}) {|(var, type), hash|
             arg_node = args.find {|arg| arg.children[0] == var }
-            hash[var.name] = TypeInference::LocalVariableTypeEnv::Entry.new(type: type, nodes: [arg_node].compact)
+            hash[var] = TypeInference::LocalVariableTypeEnv::Entry.new(type: type, nodes: [arg_node].compact)
           }
         )
       end
@@ -285,6 +296,41 @@ module Steep
       end
     end
 
+    def default_module_context(implement_module_name, const_env:, current_namespace:)
+      if implement_module_name
+        module_name = checker.factory.absolute_type_name(implement_module_name.name, namespace: current_namespace)
+        module_args = implement_module_name.args.map {|name| AST::Types::Var.new(name: name) }
+
+        instance_def = checker.factory.definition_builder.build_instance(module_name)
+        module_def = checker.factory.definition_builder.build_singleton(module_name)
+
+        instance_type = AST::Types::Name::Instance.new(name: module_name, args: module_args)
+        module_type = AST::Types::Name::Singleton.new(name: module_name)
+
+        TypeInference::Context::ModuleContext.new(
+          instance_type: instance_type,
+          module_type: module_type,
+          implement_name: implement_module_name,
+          current_namespace: current_namespace,
+          const_env: const_env,
+          class_name: module_name,
+          instance_definition: instance_def,
+          module_definition: module_def
+        )
+      else
+        TypeInference::Context::ModuleContext.new(
+          instance_type: nil,
+          module_type: nil,
+          implement_name: nil,
+          current_namespace: current_namespace,
+          const_env: self.module_context.const_env,
+          class_name: self.module_context.class_name,
+          module_definition: nil,
+          instance_definition: nil
+        )
+      end
+    end
+
     def for_module(node)
       new_module_name = module_name_from_node(node.children.first) or raise "Unexpected module name: #{node.children.first}"
       new_namespace = nested_namespace_for_module(new_module_name)
@@ -293,64 +339,55 @@ module Steep
       module_const_env = TypeInference::ConstantEnv.new(factory: checker.factory, context: const_context)
 
       annots = source.annotations(block: node, factory: checker.factory, current_module: new_namespace)
-      module_type = AST::Builtin::Module.instance_type
 
       implement_module_name = implement_module(module_name: new_module_name, annotations: annots)
+      module_context = default_module_context(implement_module_name, const_env: module_const_env, current_namespace: new_namespace)
+
+      unless implement_module_name
+        module_context = module_context.update(module_type: AST::Builtin::Module.instance_type)
+      end
 
       if implement_module_name
-        module_name = implement_module_name.name
-        module_args = implement_module_name.args.map {|x| AST::Types::Var.new(name: x)}
-
-        type_name_ = implement_module_name.name
-        module_entry = checker.factory.definition_builder.env.class_decls[type_name_]
-        instance_def = checker.factory.definition_builder.build_instance(type_name_)
-        module_def = checker.factory.definition_builder.build_singleton(type_name_)
-
-        instance_type = AST::Types::Intersection.build(
-          types: [
-            AST::Builtin::Object.instance_type,
-            *module_entry.self_types.map {|module_self|
-              type = case
-                     when module_self.name.interface?
-                       RBS::Types::Interface.new(
-                         name: module_self.name,
-                         args: module_self.args,
-                         location: module_self.location
-                       )
-                     when module_self.name.class?
-                       RBS::Types::ClassInstance.new(
-                         name: module_self.name,
-                         args: module_self.args,
-                         location: module_self.location
-                       )
-                     end
-              checker.factory.type(type)
-            },
-            AST::Types::Name::Instance.new(name: module_name, args: module_args)
-          ].compact
+        module_entry = checker.factory.definition_builder.env.class_decls[implement_module_name.name]
+
+        module_context = module_context.update(
+          instance_type: AST::Types::Intersection.build(
+            types: [
+              AST::Builtin::Object.instance_type,
+              *module_entry.self_types.map {|module_self|
+                type = case
+                       when module_self.name.interface?
+                         RBS::Types::Interface.new(
+                           name: module_self.name,
+                           args: module_self.args,
+                           location: module_self.location
+                         )
+                       when module_self.name.class?
+                         RBS::Types::ClassInstance.new(
+                           name: module_self.name,
+                           args: module_self.args,
+                           location: module_self.location
+                         )
+                       end
+                checker.factory.type(type)
+              },
+              module_context.instance_type
+            ].compact
+          )
         )
-
-        module_type = AST::Types::Name::Singleton.new(name: module_name)
       end
 
       if annots.instance_type
-        instance_type = annots.instance_type
+        module_context = module_context.update(instance_type: annots.instance_type)
       end
 
       if annots.module_type
-        module_type = annots.module_type
-      end
-
-      module_context_ = TypeInference::Context::ModuleContext.new(
-        instance_type: instance_type,
-        module_type: annots.self_type || module_type,
-        implement_name: implement_module_name,
-        current_namespace: new_namespace,
-        const_env: module_const_env,
-        class_name: absolute_name(new_module_name),
-        instance_definition: instance_def,
-        module_definition: module_def
-      )
+        module_context = module_context.update(module_type: annots.module_type)
+      end
+
+      if annots.self_type
+        module_context = module_context.update(module_type: annots.self_type)
+      end
 
       module_type_env = TypeInference::TypeEnv.build(annotations: annots,
                                                      subtyping: checker,
@@ -359,7 +396,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(
@@ -371,11 +410,11 @@ module Steep
           method_context: nil,
           block_context: nil,
           break_context: nil,
-          module_context: module_context_,
-          self_type: module_context_.module_type,
+          module_context: module_context,
+          self_type: module_context.module_type,
           type_env: module_type_env,
           lvar_env: lvar_env,
-          call_context: TypeInference::MethodCall::ModuleContext.new(type_name: module_context_.class_name)
+          call_context: TypeInference::MethodCall::ModuleContext.new(type_name: module_context.class_name)
         )
       )
     end
@@ -387,48 +426,37 @@ module Steep
 
       annots = source.annotations(block: node, factory: checker.factory, current_module: new_namespace)
 
-      implement_module_name = implement_module(module_name: new_class_name, super_name: super_class_name, annotations: annots)
+      const_context = [new_namespace] + self.module_context.const_env.context
+      class_const_env = TypeInference::ConstantEnv.new(factory: checker.factory, context: const_context)
 
-      if annots.implement_module_annotation
-        new_class_name = implement_module_name.name
-      end
+      implement_module_name = implement_module(module_name: new_class_name, super_name: super_class_name, annotations: annots)
+      module_context = default_module_context(implement_module_name, const_env: class_const_env, current_namespace: new_namespace)
 
       if implement_module_name
-        class_name = implement_module_name.name
-        class_args = implement_module_name.args.map {|x| AST::Types::Var.new(name: x)}
-
-        type_name_ = implement_module_name.name
-        instance_def = checker.factory.definition_builder.build_instance(type_name_)
-        module_def = checker.factory.definition_builder.build_singleton(type_name_)
-
-        instance_type = AST::Types::Name::Instance.new(name: class_name, args: class_args)
-        module_type = AST::Types::Name::Singleton.new(name: class_name)
+        if super_class_name && implement_module_name.name == absolute_name(super_class_name)
+          module_context = module_context.update(
+            instance_definition: nil,
+            module_definition: nil
+          )
+        end
       else
-        instance_type = AST::Builtin::Object.instance_type
-        module_type = AST::Builtin::Object.module_type
+        module_context = module_context.update(
+          instance_type: AST::Builtin::Object.instance_type,
+          module_type: AST::Builtin::Object.module_type
+        )
       end
 
       if annots.instance_type
-        instance_type = annots.instance_type
+        module_context = module_context.update(instance_type: annots.instance_type)
       end
 
       if annots.module_type
-        module_type = annots.module_type
+        module_context = module_context.update(module_type: annots.module_type)
       end
 
-      const_context = [new_namespace] + self.module_context.const_env.context
-      class_const_env = TypeInference::ConstantEnv.new(factory: checker.factory, context: const_context)
-
-      module_context = TypeInference::Context::ModuleContext.new(
-        instance_type: annots.instance_type || instance_type,
-        module_type: annots.self_type || annots.module_type || module_type,
-        implement_name: implement_module_name,
-        current_namespace: new_namespace,
-        const_env: class_const_env,
-        class_name: absolute_name(new_class_name),
-        module_definition: module_def,
-        instance_definition: instance_def
-      )
+      if annots.self_type
+        module_context = module_context.update(module_type: annots.self_type)
+      end
 
       class_type_env = TypeInference::TypeEnv.build(annotations: annots,
                                                     subtyping: checker,
@@ -437,7 +465,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(
@@ -523,7 +553,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(
@@ -604,14 +636,20 @@ module Steep
       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(
           Diagnostic::Ruby::IncompatibleAnnotation.new(
@@ -684,7 +722,7 @@ module Steep
         when :lvasgn
           yield_self do
             var, rhs = node.children
-            name = var.name
+            name = var
 
             case name
             when :_, :__any__
@@ -720,7 +758,7 @@ module Steep
         when :lvar
           yield_self do
             var = node.children[0]
-            if (type = context.lvar_env[var.name])
+            if (type = context.lvar_env[var])
               add_typing node, type: type
             else
               fallback_to_any(node)
@@ -861,7 +899,27 @@ module Steep
                                                 block_body: nil,
                                                 topdown_hint: true)
 
-                constr.add_call(call)
+                if call && constr
+                  constr.add_call(call)
+                else
+                  error = Diagnostic::Ruby::UnresolvedOverloading.new(
+                    node: node,
+                    receiver_type: self_type,
+                    method_name: method_context.name,
+                    method_types: super_method.method_types
+                  )
+                  call = TypeInference::MethodCall::Error.new(
+                    node: node,
+                    context: context.method_context,
+                    method_name: method_context.name,
+                    receiver_type: self_type,
+                    errors: [error]
+                  )
+
+                  constr = synthesize_children(node)
+
+                  fallback_to_any(node) { error }
+                end
               else
                 fallback_to_any node do
                   Diagnostic::Ruby::UnexpectedSuper.new(node: node, method: method_context.name)
@@ -886,14 +944,23 @@ module Steep
           yield_self do
             name, args_node, body_node = node.children
 
-            new = for_new_method(name,
-                                 node,
-                                 args: args_node.children,
-                                 self_type: module_context&.instance_type,
-                                 definition: module_context&.instance_definition)
+            new = for_new_method(
+              name,
+              node,
+              args: args_node.children,
+              self_type: module_context&.instance_type,
+              definition: module_context&.instance_definition
+            )
             new.typing.add_context_for_node(node, context: new.context)
             new.typing.add_context_for_body(node, context: new.context)
 
+            new.method_context.tap do |method_context|
+              if method_context.method
+                method_name = InstanceMethodName.new(type_name: method_context.method.implemented_in, method_name: name)
+                new.typing.source_index.add_definition(method: method_name, definition: node)
+              end
+            end
+
             new = new.synthesize_children(args_node)
 
             body_pair = if body_node
@@ -948,24 +1015,43 @@ module Steep
         when :defs
           synthesize(node.children[0]).type.tap do |self_type|
             self_type = expand_self(self_type)
-            definition = case self_type
-                         when AST::Types::Name::Instance
-                           name = self_type.name
-                           checker.factory.definition_builder.build_singleton(name)
-                         when AST::Types::Name::Singleton
-                           name = self_type.name
-                           checker.factory.definition_builder.build_singleton(name)
-                         end
+            definition =
+              case self_type
+              when AST::Types::Name::Instance
+                name = self_type.name
+                checker.factory.definition_builder.build_instance(name)
+              when AST::Types::Name::Singleton
+                name = self_type.name
+                checker.factory.definition_builder.build_singleton(name)
+              end
 
             args_node = node.children[2]
-            new = for_new_method(node.children[1],
-                                 node,
-                                 args: args_node.children,
-                                 self_type: self_type,
-                                 definition: definition)
+            new = for_new_method(
+              node.children[1],
+              node,
+              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.method_context.tap do |method_context|
+              if method_context.method
+                name_ = node.children[1]
+
+                method_name =
+                  case self_type
+                  when AST::Types::Name::Instance
+                    InstanceMethodName.new(type_name: method_context.method.implemented_in, method_name: name_)
+                  when AST::Types::Name::Singleton
+                    SingletonMethodName.new(type_name: method_context.method.implemented_in, method_name: name_)
+                  end
+
+                new.typing.source_index.add_definition(method: method_name, definition: node)
+              end
+            end
+
             new = new.synthesize_children(args_node)
 
             each_child_node(node.children[2]) do |arg|
@@ -1125,15 +1211,45 @@ module Steep
           add_typing(node, type: AST::Builtin.bottom_type)
 
         when :retry
-          unless break_context
-            typing.add_error Diagnostic::Ruby::UnexpectedJump.new(node: node)
-          end
           add_typing(node, type: AST::Builtin.bottom_type)
 
-        when :arg, :kwarg, :procarg0
+        when :procarg0
+          yield_self do
+            constr = self
+
+            node.children.each do |arg|
+              if arg.is_a?(Symbol)
+                type = context.lvar_env[arg]
+
+                if type
+                  _, constr = add_typing(node, type: type)
+                else
+                  type = AST::Builtin.any_type
+                  _, constr = lvasgn(node, type)
+                end
+              else
+                _, constr = constr.synthesize(arg)
+              end
+            end
+
+            Pair.new(constr: constr, type: AST::Builtin.any_type)
+          end
+
+        when :mlhs
+          yield_self do
+            constr = self
+
+            node.children.each do |arg|
+              _, constr = constr.synthesize(arg)
+            end
+
+            Pair.new(constr: constr, type: AST::Builtin.any_type)
+          end
+
+        when :arg, :kwarg
           yield_self do
             var = node.children[0]
-            type = context.lvar_env[var.name]
+            type = context.lvar_env[var]
 
             if type
               add_typing(node, type: type)
@@ -1148,13 +1264,13 @@ module Steep
             var = node.children[0]
             rhs = node.children[1]
 
-            var_type = context.lvar_env[var.name]
+            var_type = context.lvar_env[var]
             node_type, constr = synthesize(rhs, hint: var_type)
 
             type = AST::Types::Union.build(types: [var_type, node_type])
 
             constr_ = constr.update_lvar_env do |env|
-              env.assign(var.name, node: node, type: type) do |declared_type, type, result|
+              env.assign(var, node: node, type: type) do |declared_type, type, result|
                 typing.add_error(
                   Diagnostic::Ruby::IncompatibleAssignment.new(
                     node: node,
@@ -1172,7 +1288,7 @@ module Steep
         when :restarg
           yield_self do
             var = node.children[0]
-            type = context.lvar_env[var.name]
+            type = context.lvar_env[var]
             unless type
               if context&.method_context&.method_type
                 Steep.logger.error { "Unknown variable: #{node}" }
@@ -1187,7 +1303,7 @@ module Steep
         when :kwrestarg
           yield_self do
             var = node.children[0]
-            type = context.lvar_env[var.name]
+            type = context.lvar_env[var]
             unless type
               if context&.method_context&.method_type
                 Steep.logger.error { "Unknown variable: #{node}" }
@@ -1355,9 +1471,22 @@ module Steep
             constr = self
 
             name, _ = 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
 
             for_module(node).yield_self 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
@@ -1450,7 +1579,13 @@ module Steep
 
               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)
@@ -1517,8 +1652,10 @@ module Steep
                 }
                 add_typing(node, type: union_type(*types))
               else
-                typing.add_error(Diagnostic::Ruby::UnexpectedSuper.new(node: node, method: method_context.name))
-                fallback_to_any node
+
+                fallback_to_any(node) do
+                  Diagnostic::Ruby::UnexpectedSuper.new(node: node, method: method_context.name)
+                end
               end
             else
               fallback_to_any node
@@ -1545,8 +1682,7 @@ module Steep
               if hint && !(tuples = select_flatten_types(hint) {|type| type.is_a?(AST::Types::Tuple) }).empty?
                 tuples.each do |tuple|
                   typing.new_child(node_range) do |child_typing|
-                    pair = with_new_typing(child_typing).try_tuple_type(node, tuple)
-                    if pair && pair.constr.check_relation(sub_type: pair.type, super_type: hint).success?
+                    if pair = with_new_typing(child_typing).try_tuple_type(node, tuple)
                       child_typing.save!
                       return pair.with(constr: pair.constr.with_new_typing(typing))
                     end
@@ -1717,12 +1853,7 @@ module Steep
               _, 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)
-                  ]
-                )
+                var_node = cond.updated(:lvar, [first_var])
               else
                 first_var = nil
                 var_node = cond
@@ -1863,7 +1994,7 @@ module Steep
               if assignment
                 case assignment.type
                 when :lvasgn
-                  var_name = assignment.children[0].name
+                  var_name = assignment.children[0]
                 else
                   Steep.logger.error "Unexpected rescue variable assignment: #{assignment.type}"
                 end
@@ -1942,7 +2073,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
@@ -1952,7 +2083,7 @@ module Steep
             if var_type
               if body
                 body_constr = constr.with_updated_context(
-                  lvar_env: constr.context.lvar_env.assign(asgn.children[0].name, node: asgn, type: var_type)
+                  lvar_env: constr.context.lvar_env.assign(asgn.children[0], node: asgn, type: var_type)
                 )
 
                 typing.add_context_for_body(node, context: body_constr.context)
@@ -2148,7 +2279,7 @@ module Steep
                 when AST::Types::Any
                   type = AST::Types::Any.new
                 else
-                  interface = checker.factory.interface(param_type, private: true)
+                  interface = calculate_interface(param_type, private: true)
                   method = interface.methods[value.children[0]]
                   if method
                     return_types = method.method_types.select {|method_type|
@@ -2266,6 +2397,15 @@ module Steep
             raise "#synthesize should return an instance of Pair: #{pair.class}, node=#{node.inspect}"
           end
         end
+      rescue RBS::ErrorBase => exn
+        Steep.logger.warn { "Unexpected RBS error: #{exn.message}" }
+        exn.backtrace.each {|loc| Steep.logger.warn "  #{loc}" }
+        typing.add_error(Diagnostic::Ruby::UnexpectedError.new(node: node, error: exn))
+        type_any_rec(node)
+      rescue StandardError => exn
+        Steep.log_error exn
+        typing.add_error(Diagnostic::Ruby::UnexpectedError.new(node: node, error: exn))
+        type_any_rec(node)
       end
     end
 
@@ -2283,7 +2423,13 @@ 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)
@@ -2305,16 +2451,16 @@ module Steep
     def masgn_lhs?(lhs)
       lhs.children.all? do |a|
         asgn_type = if a.type == :splat
-                      a.children[0].type
+                      a.children[0]&.type
                     else
                       a.type
                     end
-        asgn_type == :lvasgn || asgn_type == :ivasgn
+        asgn_type.nil? || asgn_type == :lvasgn || asgn_type == :ivasgn
       end
     end
 
     def lvasgn(node, type)
-      name = node.children[0].name
+      name = node.children[0]
       env = context.lvar_env.assign(name, node: node, type: type) do |declared_type, type, result|
         typing.add_error(
           Diagnostic::Ruby::IncompatibleAssignment.new(
@@ -2332,7 +2478,13 @@ 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)
@@ -2449,7 +2601,7 @@ module Steep
         assignment_nodes.each do |asgn|
           case asgn.type
           when :splat
-            case asgn.children[0].type
+            case asgn.children[0]&.type
             when :lvasgn
               _, constr = constr.lvasgn(asgn.children[0], array_type)
             when :ivasgn
@@ -2675,6 +2827,7 @@ module Steep
       end
 
       receiver_type = checker.factory.deep_expand_alias(recv_type)
+      private = receiver.nil? || receiver.type == :self
 
       type, constr = case receiver_type
                      when nil
@@ -2719,9 +2872,9 @@ module Steep
                            )
                          )
                        else
-                         interface = checker.factory.interface(expanded_self,
-                                                               private: !receiver,
-                                                               self_type: AST::Types::Self.new)
+                         interface = calculate_interface(expanded_self,
+                                                         private: private,
+                                                         self_type: AST::Types::Self.new)
 
                          constr.type_send_interface(node,
                                                     interface: interface,
@@ -2733,9 +2886,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: private, self_type: receiver_type)
 
                        constr.type_send_interface(node,
                                                   interface: interface,
@@ -2748,27 +2899,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 = Diagnostic::Ruby::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)
@@ -3061,6 +3204,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
               )
@@ -3082,7 +3227,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
@@ -3127,7 +3279,14 @@ module Steep
               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
@@ -3144,35 +3303,73 @@ module Steep
         end
       else
         # block is not given
-        if (!method_type.block || method_type.block.optional?)
-          # Method call without block is allowed
+        if !method_type.block
+          # Method doesn't accept blocks
           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 << Diagnostic::Ruby::UnexpectedBlockGiven.new(
-              node: node,
-              method_type: method_type
-            )
+            type, constr = constr.synthesize(args.block_pass_arg, hint: AST::Builtin.nil_type)
+            type = expand_alias(type)
+            unless type.is_a?(AST::Types::Nil)
+              errors << Diagnostic::Ruby::UnexpectedBlockGiven.new(
+                node: node,
+                method_type: method_type
+              )
+            end
           end
         else
-          unless args.block_pass_arg
-            # Required block is missing
-            errors << Diagnostic::Ruby::RequiredBlockMissing.new(
-              node: node,
-              method_type: method_type
-            )
+          # Method accepts block
+          if !args.block_pass_arg
+            # Block pass is not given
+            if method_type.block.required?
+              # Required block is missing
+              errors << Diagnostic::Ruby::RequiredBlockMissing.new(
+                node: node,
+                method_type: method_type
+              )
+            end
 
-            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
@@ -3196,7 +3393,16 @@ module Steep
                 )
               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
@@ -3231,6 +3437,16 @@ module Steep
     end
 
     def type_block_without_hint(node:, block_annotations:, block_params:, block_body:, &block)
+      unless block_params
+        typing.add_error(
+          Diagnostic::Ruby::UnsupportedSyntax.new(
+            node: node.children[1],
+            message: "Unsupported block params pattern, probably masgn?"
+          )
+        )
+        block_params = TypeInference::BlockParams.new(leading_params: [], optional_params: [], rest_param: nil, trailing_params: [])
+      end
+
       block_constr = for_block(
         block_params: block_params,
         block_param_hint: nil,
@@ -3267,12 +3483,12 @@ module Steep
       param_types_hash = {}
       if block_param_pairs
         block_param_pairs.each do |param, type|
-          var_name = param.var.name
+          var_name = param.var
           param_types_hash[var_name] = type
         end
       else
         block_params.each do |param|
-          var_name = param.var.name
+          var_name = param.var
           param_types_hash[var_name] = param.type || AST::Builtin.any_type
         end
       end
@@ -3300,6 +3516,23 @@ module Steep
         next_type: block_context.body_type
       )
 
+      self_type = self.self_type
+      module_context = self.module_context
+
+      if implements = block_annotations.implement_module_annotation
+        module_context = default_module_context(
+          implements.name,
+          const_env: self.module_context.const_env,
+          current_namespace: current_namespace
+        )
+
+        self_type = module_context.module_type
+      end
+
+      if annotation_self_type = block_annotations.self_type
+        self_type = annotation_self_type
+      end
+
       self.class.new(
         checker: checker,
         source: source,
@@ -3310,7 +3543,7 @@ module Steep
           method_context: method_context,
           module_context: module_context,
           break_context: break_context,
-          self_type: block_annotations.self_type || self_type,
+          self_type: self_type,
           type_env: type_env.dup,
           lvar_env: lvar_env,
           call_context: self.context.call_context
@@ -3380,13 +3613,13 @@ module Steep
       nodes.each do |node|
         if node.type == :kwarg
           name = node.children[0]
-          ty = type.params.required_keywords[name.name]
+          ty = type.params.required_keywords[name]
           env[name] = ty if ty
         end
 
         if node.type == :kwoptarg
           name = node.children[0]
-          ty = type.params.optional_keywords[name.name]
+          ty = type.params.optional_keywords[name]
           env[name] = ty if ty
         end
 
@@ -3568,6 +3801,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)
@@ -3595,9 +3830,9 @@ module Steep
     def self.value_variables(node)
       case node&.type
       when :lvar
-        Set.new([node.children.first.name])
+        Set.new([node.children.first])
       when :lvasgn
-        Set.new([node.children.first.name]) + value_variables(node.children[1])
+        Set.new([node.children.first]) + value_variables(node.children[1])
       when :begin
         value_variables(node.children.last)
       else