From a5b051632b3f81db97f3d1eef295a3cf9dc3fccb Mon Sep 17 00:00:00 2001
From: zedzhen <59135268+zedzhen@users.noreply.github.com>
Date: Fri, 23 Oct 2026 00:07:33 +0300
Subject: [PATCH 1/2] if mypy.types.CallableType.instance_type is not None,
 mark as type

---
 mypy/types.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/mypy/types.py b/mypy/types.py
index a6df7bf2e452..c994f1fecb70 100644
--- a/mypy/types.py
+++ b/mypy/types.py
@@ -2424,8 +2424,9 @@ def is_kw_arg(self) -> bool:
         return ARG_STAR2 in self.arg_kinds
 
     def is_type_obj(self) -> bool:
-        return self.fallback.type.is_metaclass() and not isinstance(
-            get_proper_type(self.ret_type), UninhabitedType
+        return self.fallback.type.is_metaclass() and (
+            self.instance_type is not None
+            or not isinstance(get_proper_type(self.ret_type), UninhabitedType)
         )
 
     def get_instance_type(self, *, force_fallback: bool = False) -> ProperType:

From 3964117d2a6dd5e6029315575501268f6510caa5 Mon Sep 17 00:00:00 2001
From: zedzhen <59135268+zedzhen@users.noreply.github.com>
Date: Fri, 23 Oct 2026 00:08:07 +0300
Subject: [PATCH 2/2] add tests

---
 test-data/unit/check-classes.test | 182 ++++++++++++++++++++++++++++++
 1 file changed, 182 insertions(+)

diff --git a/test-data/unit/check-classes.test b/test-data/unit/check-classes.test
index b6eee21c50af..639a4b77eae3 100644
--- a/test-data/unit/check-classes.test
+++ b/test-data/unit/check-classes.test
@@ -8886,6 +8886,188 @@ if object():
     reveal_type(D())  # N: Revealed type is "Never"
 reveal_type(D(1))  # N: Revealed type is "__main__.D"
 
+[case testNewAndInitNoReturnWithAttributeClassmethodStaticMethod]
+from typing import NoReturn, ClassVar, Final
+
+class A:
+    x: ClassVar[str] = ""
+    y: Final[int] = 0
+
+    def __new__(cls) -> NoReturn: ...
+
+    @classmethod
+    def f(cls) -> "A": ...
+    @staticmethod
+    def g() -> "A": ...
+
+class B:
+    x: ClassVar[str] = ""
+    y: Final[int] = 0
+
+    def __init__(self) -> NoReturn: ...
+
+    @classmethod
+    def f(cls) -> "B": ...
+    @staticmethod
+    def g() -> "B": ...
+
+class C:
+    x: ClassVar[str] = ""
+    y: Final[int] = 0
+
+    def __new__(cls) -> "C": ...
+    def __init__(self) -> NoReturn: ...
+
+    @classmethod
+    def f(cls) -> "C": ...
+    @staticmethod
+    def g() -> "C": ...
+
+class D:
+    x: ClassVar[str] = ""
+    y: Final[int] = 0
+
+    def __new__(cls) -> NoReturn: ...
+    def __init__(self) -> NoReturn: ...
+
+    @classmethod
+    def f(cls) -> "D": ...
+    @staticmethod
+    def g() -> "D": ...
+
+if object():
+    reveal_type(A())  # N: Revealed type is "Never"
+reveal_type(A.x)  # N: Revealed type is "builtins.str"
+reveal_type(A.y)  # N: Revealed type is "builtins.int"
+reveal_type(A.f())  # N: Revealed type is "__main__.A"
+reveal_type(A.g())  # N: Revealed type is "__main__.A"
+
+if object():
+    reveal_type(B())  # N: Revealed type is "Never"
+reveal_type(B.x)  # N: Revealed type is "builtins.str"
+reveal_type(B.y)  # N: Revealed type is "builtins.int"
+reveal_type(B.f())  # N: Revealed type is "__main__.B"
+reveal_type(B.g())  # N: Revealed type is "__main__.B"
+
+if object():
+    reveal_type(C())  # N: Revealed type is "Never"
+reveal_type(C.x)  # N: Revealed type is "builtins.str"
+reveal_type(C.y)  # N: Revealed type is "builtins.int"
+reveal_type(C.f())  # N: Revealed type is "__main__.C"
+reveal_type(C.g())  # N: Revealed type is "__main__.C"
+
+if object():
+    reveal_type(D())  # N: Revealed type is "Never"
+reveal_type(D.x)  # N: Revealed type is "builtins.str"
+reveal_type(D.y)  # N: Revealed type is "builtins.int"
+reveal_type(D.f())  # N: Revealed type is "__main__.D"
+reveal_type(D.g())  # N: Revealed type is "__main__.D"
+
+[builtins fixtures/classmethod.pyi]
+
+[case testOverloadedNewAndInitNoReturnWithAttributeClassmethodStaticMethod]
+from typing import NoReturn, overload, ClassVar, Final
+
+class A:
+    x: ClassVar[str] = ""
+    y: Final[int] = 0
+
+    @overload
+    def __new__(cls) -> NoReturn: ...
+    @overload
+    def __new__(cls, a: int) -> "A": ...
+    def __new__(cls, a: int = ...) -> "A": ...
+
+    @classmethod
+    def f(cls) -> "A": ...
+    @staticmethod
+    def g() -> "A": ...
+
+class B:
+    x: ClassVar[str] = ""
+    y: Final[int] = 0
+
+    @overload
+    def __init__(self) -> NoReturn: ...
+    @overload
+    def __init__(self, a: int) -> None: ...
+    def __init__(self, a: int = ...) -> None: ...
+
+    @classmethod
+    def f(cls) -> "B": ...
+    @staticmethod
+    def g() -> "B": ...
+
+class C:
+    x: ClassVar[str] = ""
+    y: Final[int] = 0
+
+    def __new__(cls, a: int = ...) -> "C": ...
+    @overload
+    def __init__(self) -> NoReturn: ...
+    @overload
+    def __init__(self, a: int) -> None: ...
+    def __init__(self, a: int = ...) -> None: ...
+
+    @classmethod
+    def f(cls) -> "C": ...
+    @staticmethod
+    def g() -> "C": ...
+
+class D:
+    x: ClassVar[str] = ""
+    y: Final[int] = 0
+
+    @overload
+    def __new__(cls) -> NoReturn: ...
+    @overload
+    def __new__(cls, a: int) -> "D": ...
+    def __new__(cls, a: int = ...) -> "D": ...
+    @overload
+    def __init__(self) -> NoReturn: ...
+    @overload
+    def __init__(self, a: int) -> None: ...
+    def __init__(self, a: int = ...) -> None: ...
+
+    @classmethod
+    def f(cls) -> "D": ...
+    @staticmethod
+    def g() -> "D": ...
+
+if object():
+    reveal_type(A())  # N: Revealed type is "Never"
+reveal_type(A(1))  # N: Revealed type is "__main__.A"
+reveal_type(A.x)  # N: Revealed type is "builtins.str"
+reveal_type(A.y)  # N: Revealed type is "builtins.int"
+reveal_type(A.f())  # N: Revealed type is "__main__.A"
+reveal_type(A.g())  # N: Revealed type is "__main__.A"
+
+if object():
+    reveal_type(B())  # N: Revealed type is "Never"
+reveal_type(B(1))  # N: Revealed type is "__main__.B"
+reveal_type(B.x)  # N: Revealed type is "builtins.str"
+reveal_type(B.y)  # N: Revealed type is "builtins.int"
+reveal_type(B.f())  # N: Revealed type is "__main__.B"
+reveal_type(B.g())  # N: Revealed type is "__main__.B"
+
+if object():
+    reveal_type(C())  # N: Revealed type is "Never"
+reveal_type(C(1))  # N: Revealed type is "__main__.C"
+reveal_type(C.x)  # N: Revealed type is "builtins.str"
+reveal_type(C.y)  # N: Revealed type is "builtins.int"
+reveal_type(C.f())  # N: Revealed type is "__main__.C"
+reveal_type(C.g())  # N: Revealed type is "__main__.C"
+
+if object():
+    reveal_type(D())  # N: Revealed type is "Never"
+reveal_type(D(1))  # N: Revealed type is "__main__.D"
+reveal_type(D.x)  # N: Revealed type is "builtins.str"
+reveal_type(D.y)  # N: Revealed type is "builtins.int"
+reveal_type(D.f())  # N: Revealed type is "__main__.D"
+reveal_type(D.g())  # N: Revealed type is "__main__.D"
+
+[builtins fixtures/classmethod.pyi]
+
 [case testClassScopeImportWithWrapperAndError]
 class Foo:
     from mod import foo # E: Unsupported class scoped import