python · tyralla · Dec 29, 2023 · Dec 29, 2023 · Dec 29, 2023 · Dec 29, 2023
diff --git a/mypy/checker.py b/mypy/checker.py
@@ -1336,7 +1336,7 @@ def check_func_def(
                         if (
                             arg_type.variance == COVARIANT
                             and defn.name not in ("__init__", "__new__", "__post_init__")
-                            and not is_private(defn.name)  # private methods are not inherited
+                            and "mypy-" not in defn.name  # skip internally added methods
                         ):
                             ctx: Context = arg_type
                             if ctx.line < 0:
@@ -1979,7 +1979,6 @@ def check_explicit_override_decorator(
             and found_method_base_classes
             and not defn.is_explicit_override
             and defn.name not in ("__init__", "__new__")
-            and not is_private(defn.name)
         ):
             self.msg.explicit_override_decorator_missing(
                 defn.name, found_method_base_classes[0].fullname, context or defn
@@ -2036,7 +2035,7 @@ def check_method_or_accessor_override_for_base(
             base_attr = base.names.get(name)
             if base_attr:
                 # First, check if we override a final (always an error, even with Any types).
-                if is_final_node(base_attr.node) and not is_private(name):
+                if is_final_node(base_attr.node):
                     self.msg.cant_override_final(name, base.name, defn)
                 # Second, final can't override anything writeable independently of types.
                 if defn.is_final:
@@ -2393,9 +2392,6 @@ def check_override(
                 if original.type_is is not None and override.type_is is None:
                     fail = True
 
-        if is_private(name):
-            fail = False
-
         if fail:
             emitted_msg = False
 
@@ -2698,25 +2694,26 @@ def check_enum(self, defn: ClassDef) -> None:
 
     def check_final_enum(self, defn: ClassDef, base: TypeInfo) -> None:
         for sym in base.names.values():
-            if self.is_final_enum_value(sym):
+            if self.is_final_enum_value(sym, base):
                 self.fail(f'Cannot extend enum with existing members: "{base.name}"', defn)
                 break
 
-    def is_final_enum_value(self, sym: SymbolTableNode) -> bool:
+    def is_final_enum_value(self, sym: SymbolTableNode, base: TypeInfo) -> bool:
         if isinstance(sym.node, (FuncBase, Decorator)):
             return False  # A method is fine
         if not isinstance(sym.node, Var):
             return True  # Can be a class or anything else
 
         # Now, only `Var` is left, we need to check:
-        # 1. Private name like in `__prop = 1`
+        # 1. Mangled name like in `_class__prop = 1`
         # 2. Dunder name like `__hash__ = some_hasher`
         # 3. Sunder name like `_order_ = 'a, b, c'`
         # 4. If it is a method / descriptor like in `method = classmethod(func)`
+        name = sym.node.name
         if (
-            is_private(sym.node.name)
-            or is_dunder(sym.node.name)
-            or is_sunder(sym.node.name)
+            (name.startswith(f"_{base.name}__") and not name.endswith("__"))
+            or is_dunder(name)
+            or is_sunder(name)
             # TODO: make sure that `x = @class/staticmethod(func)`
             # and `x = property(prop)` both work correctly.
             # Now they are incorrectly counted as enum members.
@@ -2827,12 +2824,8 @@ def check_multiple_inheritance(self, typ: TypeInfo) -> None:
         # Verify that inherited attributes are compatible.
         mro = typ.mro[1:]
         all_names = {name for base in mro for name in base.names}
+        # Sort for reproducible message order.
         for name in sorted(all_names - typ.names.keys()):
-            # Sort for reproducible message order.
-            # Attributes defined in both the type and base are skipped.
-            # Normal checks for attribute compatibility should catch any problems elsewhere.
-            if is_private(name):
-                continue
             # Compare the first base defining a name with the rest.
             # Remaining bases may not be pairwise compatible as the first base provides
             # the used definition.
@@ -2944,7 +2937,7 @@ class C(B, A[int]): ...  # this is unsafe because...
             ok = True
         # Final attributes can never be overridden, but can override
         # non-final read-only attributes.
-        if is_final_node(second.node) and not is_private(name):
+        if is_final_node(second.node):
             self.msg.cant_override_final(name, base2.name, ctx)
         if is_final_node(first.node):
             self.check_if_final_var_override_writable(name, second.node, ctx)
@@ -3414,9 +3407,6 @@ def check_compatibility_all_supers(
                 ):
                     continue
 
-                if is_private(lvalue_node.name):
-                    continue
-
                 base_type, base_node = self.lvalue_type_from_base(lvalue_node, base)
                 custom_setter = is_custom_settable_property(base_node)
                 if isinstance(base_type, PartialType):
@@ -3620,8 +3610,6 @@ def check_compatibility_final_super(
         """
         if not isinstance(base_node, (Var, FuncBase, Decorator)):
             return True
-        if is_private(node.name):
-            return True
         if base_node.is_final and (node.is_final or not isinstance(base_node, Var)):
             # Give this error only for explicit override attempt with `Final`, or
             # if we are overriding a final method with variable.
@@ -8907,11 +8895,6 @@ def is_overlapping_types_for_overload(left: Type, right: Type) -> bool:
     )
 
 
-def is_private(node_name: str) -> bool:
-    """Check if node is private to class definition."""
-    return node_name.startswith("__") and not node_name.endswith("__")
-
-
 def is_string_literal(typ: Type) -> bool:
     strs = try_getting_str_literals_from_type(typ)
     return strs is not None and len(strs) == 1

diff --git a/mypy/fastparse.py b/mypy/fastparse.py
@@ -3,7 +3,7 @@
 import re
 import sys
 import warnings
-from collections.abc import Sequence
+from collections.abc import Iterable, Sequence
 from typing import Any, Callable, Final, Literal, Optional, TypeVar, Union, cast, overload
 
 from mypy import defaults, errorcodes as codes, message_registry
@@ -353,6 +353,105 @@ def find_disallowed_expression_in_annotation_scope(expr: ast3.expr | None) -> as
     return None
 
 
+_T_FuncDef = TypeVar("_T_FuncDef", ast3.FunctionDef, ast3.AsyncFunctionDef)
+
+
+class NameMangler(ast3.NodeTransformer):
+    """Mangle (nearly) all private identifiers within a class body (including nested classes)."""
+
+    _classname_complete: str
+    _classname_trimmed: str
+    _mangle_annotations: bool
+    _unmangled_args: set[str]
+
+    _MANGLE_ARGS: bool = False  # ToDo: remove it or make it an option?
+
+    def __init__(self, classname: str, mangle_annotations: bool) -> None:
+        self._classname_complete = classname
+        self._classname_trimmed = classname.lstrip("_")
+        self._mangle_annotations = mangle_annotations
+        self._unmangled_args = set()
+
+    def _mangle_name(self, name: str) -> str:
+        if name.startswith("__") and not name.endswith("__"):
+            return f"_{self._classname_trimmed}{name}"
+        return name
+
+    def _mangle_slots(self, node: ast3.ClassDef) -> None:
+        for assign in node.body:
+            if isinstance(assign, ast3.Assign):
+                for target in assign.targets:
+                    if isinstance(target, ast3.Name) and (target.id == "__slots__"):
+                        constants: Iterable[ast3.expr] = ()
+                        if isinstance(values := assign.value, ast3.Constant):
+                            constants = (values,)
+                        elif isinstance(values, (ast3.Tuple, ast3.List)):
+                            constants = values.elts
+                        elif isinstance(values, ast3.Dict):
+                            constants = (key for key in values.keys if key is not None)
+                        for value in constants:
+                            if isinstance(value, ast3.Constant) and isinstance(value.value, str):
+                                value.value = self._mangle_name(value.value)
+
+    def visit_ClassDef(self, node: ast3.ClassDef) -> ast3.ClassDef:
+        if self._classname_complete == node.name:
+            for stmt in node.body:
+                self.visit(stmt)
+            self._mangle_slots(node)
+        else:
+            for dec in node.decorator_list:
+                self.visit(dec)
+            NameMangler(node.name, self._mangle_annotations).visit(node)
+            node.name = self._mangle_name(node.name)
+        return node
+
+    def _visit_funcdef(self, node: _T_FuncDef) -> _T_FuncDef:
+        node.name = self._mangle_name(node.name)
+        if not self._MANGLE_ARGS:
+            self = NameMangler(self._classname_complete, self._mangle_annotations)
+        self.visit(node.args)
+        for dec in node.decorator_list:
+            self.visit(dec)
+        if self._mangle_annotations and (node.returns is not None):
+            self.visit(node.returns)
+        for stmt in node.body:
+            self.visit(stmt)
+        return node
+
+    def visit_FunctionDef(self, node: ast3.FunctionDef) -> ast3.FunctionDef:
+        return self._visit_funcdef(node)
+
+    def visit_AsyncFunctionDef(self, node: ast3.AsyncFunctionDef) -> ast3.AsyncFunctionDef:
+        return self._visit_funcdef(node)
+
+    def visit_arg(self, node: ast3.arg) -> ast3.arg:
+        if self._MANGLE_ARGS:
+            node.arg = self._mangle_name(node.arg)
+        else:
+            self._unmangled_args.add(node.arg)
+        if self._mangle_annotations and (node.annotation is not None):
+            self.visit(node.annotation)
+        return node
+
+    def visit_AnnAssign(self, node: ast3.AnnAssign) -> ast3.AnnAssign:
+        self.visit(node.target)
+        if node.value is not None:
+            self.visit(node.value)
+        if self._mangle_annotations:
+            self.visit(node.annotation)
+        return node
+
+    def visit_Attribute(self, node: ast3.Attribute) -> ast3.Attribute:
+        node.attr = self._mangle_name(node.attr)
+        self.generic_visit(node)
+        return node
+
+    def visit_Name(self, node: Name) -> Name:
+        if self._MANGLE_ARGS or (node.id not in self._unmangled_args):
+            node.id = self._mangle_name(node.id)
+        return node
+
+
 class ASTConverter:
     def __init__(
         self,
@@ -1133,6 +1232,14 @@ def visit_ClassDef(self, n: ast3.ClassDef) -> ClassDef:
         if sys.version_info >= (3, 12) and n.type_params:
             explicit_type_params = self.translate_type_params(n.type_params)
 
+        mangle_annotations = not self.is_stub and not any(
+            isinstance(i, ImportFrom)
+            and (i.id == "__future__")
+            and any(j[0] == "annotations" for j in i.names)
+            for i in self.imports
+        )
+        NameMangler(n.name, mangle_annotations).visit(n)
+
         cdef = ClassDef(
             n.name,
             self.as_required_block(n.body),

diff --git a/mypy/messages.py b/mypy/messages.py
@@ -490,7 +490,9 @@ def has_no_attr(
                         )
                         failed = True
                     else:
-                        alternatives = set(original_type.type.names.keys())
+                        alternatives: set[str] = set()
+                        for type_ in original_type.type.mro:
+                            alternatives.update(type_.names.keys())
                         if module_symbol_table is not None:
                             alternatives |= {
                                 k for k, v in module_symbol_table.items() if v.module_public

diff --git a/mypy/plugins/dataclasses.py b/mypy/plugins/dataclasses.py
@@ -422,20 +422,22 @@ def _add_internal_replace_method(self, attributes: list[DataclassAttribute]) ->
         Stashes the signature of 'dataclasses.replace(...)' for this specific dataclass
         to be used later whenever 'dataclasses.replace' is called for this dataclass.
         """
+        mangled_name = f"_{self._cls.name.lstrip('_')}{_INTERNAL_REPLACE_SYM_NAME}"
         add_method_to_class(
             self._api,
             self._cls,
-            _INTERNAL_REPLACE_SYM_NAME,
+            mangled_name,
             args=[attr.to_argument(self._cls.info, of="replace") for attr in attributes],
             return_type=NoneType(),
             is_staticmethod=True,
         )
 
     def _add_internal_post_init_method(self, attributes: list[DataclassAttribute]) -> None:
+        mangled_name = f"_{self._cls.name.lstrip('_')}{_INTERNAL_POST_INIT_SYM_NAME}"
         add_method_to_class(
             self._api,
             self._cls,
-            _INTERNAL_POST_INIT_SYM_NAME,
+            mangled_name,
             args=[
                 attr.to_argument(self._cls.info, of="__post_init__")
                 for attr in attributes
@@ -1027,7 +1029,8 @@ def _get_expanded_dataclasses_fields(
             ctx, get_proper_type(typ.upper_bound), display_typ, parent_typ
         )
     elif isinstance(typ, Instance):
-        replace_sym = typ.type.get_method(_INTERNAL_REPLACE_SYM_NAME)
+        mangled_name = f"_{typ.type.name.lstrip('_')}{_INTERNAL_REPLACE_SYM_NAME}"
+        replace_sym = typ.type.get_method(mangled_name)
         if replace_sym is None:
             return None
         replace_sig = replace_sym.type
@@ -1111,7 +1114,8 @@ def check_post_init(api: TypeChecker, defn: FuncItem, info: TypeInfo) -> None:
         return
     assert isinstance(defn.type, FunctionLike)
 
-    ideal_sig_method = info.get_method(_INTERNAL_POST_INIT_SYM_NAME)
+    mangled_name = f"_{info.name.lstrip('_')}{_INTERNAL_POST_INIT_SYM_NAME}"
+    ideal_sig_method = info.get_method(mangled_name)
     assert ideal_sig_method is not None and ideal_sig_method.type is not None
     ideal_sig = ideal_sig_method.type
     assert isinstance(ideal_sig, ProperType)  # we set it ourselves

diff --git a/mypy/subtypes.py b/mypy/subtypes.py
@@ -2056,9 +2056,10 @@ def infer_variance(info: TypeInfo, i: int) -> bool:
         tvar = info.defn.type_vars[i]
         self_type = fill_typevars(info)
         for member in all_non_object_members(info):
-            # __mypy-replace is an implementation detail of the dataclass plugin
-            if member in ("__init__", "__new__", "__mypy-replace"):
+            if member in ("__init__", "__new__"):
                 continue
+            if "mypy-" in member:
-            if "mypy-" in member:
+            if member.startswith("__mypy-"):
-            if "mypy-" in member:
+            if member.startswith("__mypy-"):
+                continue  # skip internally added methods
 
             if isinstance(self_type, TupleType):
                 self_type = mypy.typeops.tuple_fallback(self_type)

diff --git a/mypy/test/teststubtest.py b/mypy/test/teststubtest.py
@@ -1833,7 +1833,7 @@ class X:
                 def __mangle_good(self, text): pass
                 def __mangle_bad(self, text): pass
             """,
-            error="X.__mangle_bad",
+            error="X._X__mangle_bad",
         )
         yield Case(
             stub="""
@@ -1850,7 +1850,7 @@ class __Mangled2:
                         def __mangle_good(self, text): pass
                         def __mangle_bad(self, text): pass
             """,
-            error="Klass.__Mangled1.__Mangled2.__mangle_bad",
+            error="Klass._Klass__Mangled1._Mangled1__Mangled2._Mangled2__mangle_bad",
         )
         yield Case(
             stub="""
@@ -1863,7 +1863,7 @@ class __Dunder__:
                 def __mangle_good(self, text): pass
                 def __mangle_bad(self, text): pass
             """,
-            error="__Dunder__.__mangle_bad",
+            error="__Dunder__._Dunder____mangle_bad",
         )
         yield Case(
             stub="""
@@ -1876,7 +1876,7 @@ class _Private:
                 def __mangle_good(self, text): pass
                 def __mangle_bad(self, text): pass
             """,
-            error="_Private.__mangle_bad",
+            error="_Private._Private__mangle_bad",
         )
 
     @collect_cases

diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -2016,7 +2016,7 @@ def tuple_type(self, items: list[Type], line: int, column: int) -> TupleType:
 
 
 class MsgCallback(Protocol):
-    def __call__(self, __msg: str, __ctx: Context, *, code: ErrorCode | None = None) -> None: ...
+    def __call__(self, msg: str, ctx: Context, /, *, code: ErrorCode | None = None) -> None: ...
 
 
 def get_omitted_any(

diff --git a/test-data/unit/check-async-await.test b/test-data/unit/check-async-await.test
@@ -177,7 +177,7 @@ async def f() -> None:
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-async.pyi]
 [out]
-main:7: error: "Coroutine[Any, Any, AsyncGenerator[str, None]]" has no attribute "__aiter__" (not async iterable)
+main:7: error: "Coroutine[Any, Any, AsyncGenerator[str, None]]" has no attribute "__aiter__"; maybe "__await__"? (not async iterable)
 main:7: note: Maybe you forgot to use "await"?
 
 [case testAsyncForErrorCanBeIgnored]