Method check_partial

mypy/checker.py:679–711

(
        self, node: DeferredNodeType | FineGrainedDeferredNodeType, impl_only: bool
    )

            return True

    def check_partial(
        self, node: DeferredNodeType | FineGrainedDeferredNodeType, impl_only: bool
    ) -> None:
        self.widened_vars = []
        if isinstance(node, MypyFile):
            self.check_top_level(node)
        else:
            with self.binder.top_frame_context():
                # TODO: use impl_only in the daemon as well.
                if not impl_only:
                    self.accept(node)
                    return
                if node.line in self.globals_unreachable:
                    return
                if isinstance(node, (FuncDef, Decorator)):
                    self.check_partial_impl(node)
                else:
                    # Overloads need some special logic, since settable
                    # properties are stored as overloads.
                    for i, item in enumerate(node.items):
                        # Setter and/or deleter can technically be empty.
                        allow_empty = not node.is_property or i > 0
                        assert isinstance(item, Decorator)
                        # Although the actual bodies of overload items are empty, we
                        # still need to execute some logic that doesn't affect signature.
                        with self.tscope.function_scope(item.func):
                            self.check_func_item(
                                item.func, name=node.name, allow_empty=allow_empty
                            )
                    if node.impl is not None:
                        # Handle the implementation as a regular function.
                        with self.enter_overload_impl(node.impl):
                            self.check_partial_impl(node.impl)

    def check_partial_impl(self, impl: FuncDef | Decorator) -> None:
        """Check only the body (not the signature) of a non-overloaded function."""