Support name mangling

mypy/checker.py

@@ -211,7 +211,7 @@
 from mypy.types_utils import is_overlapping_none, remove_optional, store_argument_type, strip_type
 from mypy.typetraverser import TypeTraverserVisitor
 from mypy.typevars import fill_typevars, fill_typevars_with_any, has_no_typevars
-from mypy.util import is_dunder, is_sunder
+from mypy.util import is_dunder, is_sunder, maybe_mangled
 from mypy.visitor import NodeVisitor
 
 T = TypeVar("T")
@@ -1350,7 +1350,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:
@@ -1993,7 +1993,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
@@ -2050,7 +2049,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:
@@ -2415,9 +2414,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
 
@@ -2720,25 +2716,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)
+            maybe_mangled(name, base.name)
+            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.
@@ -2849,12 +2846,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.
@@ -2966,7 +2959,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)
@@ -3436,9 +3429,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):
@@ -3642,8 +3632,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.
@@ -8942,11 +8930,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

mypy/checkmember.py

@@ -74,6 +74,7 @@
     get_proper_type,
 )
 from mypy.typetraverser import TypeTraverserVisitor
+from mypy.util import is_dunder, maybe_mangled
 
 if TYPE_CHECKING:  # import for forward declaration only
     import mypy.checker
@@ -1177,7 +1178,7 @@ def analyze_enum_class_attribute_access(
     if name in EXCLUDED_ENUM_ATTRIBUTES:
         return report_missing_attribute(mx.original_type, itype, name, mx)
     # Dunders and private names are not Enum members
-    if name.startswith("__") and name.replace("_", "") != "":
+    if is_dunder(name) or maybe_mangled(name, itype.type.name):
         return None
 
     node = itype.type.get(name)

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,103 @@ 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)."""
+
+    mangled2unmangled: dict[str, str]
+    _classname_complete: str
+    _classname_trimmed: str
+    _mangle_annotations: bool
+    _unmangled_args: set[str]
+
+    def __init__(self, classname: str, mangle_annotations: bool) -> None:
+        self.mangled2unmangled = {}
+        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("__"):
+            mangled = f"_{self._classname_trimmed}{name}"
+            self.mangled2unmangled[mangled] = name
+            return mangled
+        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)
+        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:
+        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 node.id not in self._unmangled_args:
+            node.id = self._mangle_name(node.id)
+        return node
+
+
 class ASTConverter:
     def __init__(
         self,
@@ -1135,6 +1232,15 @@ 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
+        )
+        mangler = NameMangler(n.name, mangle_annotations)
+        mangler.visit(n)
+
         cdef = ClassDef(
             n.name,
             self.as_required_block(n.body),
@@ -1143,6 +1249,7 @@ def visit_ClassDef(self, n: ast3.ClassDef) -> ClassDef:
             metaclass=dict(keywords).get("metaclass"),
             keywords=keywords,
             type_args=explicit_type_params,
+            mangled2unmangled=mangler.mangled2unmangled,
         )
         cdef.decorators = self.translate_expr_list(n.decorator_list)
         self.set_line(cdef, n)

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

mypy/nodes.py

@@ -14,7 +14,7 @@
 
 import mypy.strconv
 from mypy.options import Options
-from mypy.util import is_typeshed_file, short_type
+from mypy.util import is_dunder, is_typeshed_file, maybe_mangled, short_type
 from mypy.visitor import ExpressionVisitor, NodeVisitor, StatementVisitor
 
 if TYPE_CHECKING:
@@ -1136,6 +1136,7 @@ class ClassDef(Statement):
         "has_incompatible_baseclass",
         "docstring",
         "removed_statements",
+        "mangled2unmangled",
     )
 
     __match_args__ = ("name", "defs")
@@ -1159,6 +1160,7 @@ class ClassDef(Statement):
     has_incompatible_baseclass: bool
     # Used by special forms like NamedTuple and TypedDict to store invalid statements
     removed_statements: list[Statement]
+    mangled2unmangled: Final[dict[str, str]]
 
     def __init__(
         self,
@@ -1169,6 +1171,7 @@ def __init__(
         metaclass: Expression | None = None,
         keywords: list[tuple[str, Expression]] | None = None,
         type_args: list[TypeParam] | None = None,
+        mangled2unmangled: dict[str, str] | None = None,
     ) -> None:
         super().__init__()
         self.name = name
@@ -1186,6 +1189,7 @@ def __init__(
         self.has_incompatible_baseclass = False
         self.docstring: str | None = None
         self.removed_statements = []
+        self.mangled2unmangled = mangled2unmangled or {}
 
     @property
     def fullname(self) -> str:
@@ -3250,7 +3254,7 @@ def enum_members(self) -> list[str]:
                 (
                     isinstance(sym.node, Var)
                     and name not in EXCLUDED_ENUM_ATTRIBUTES
-                    and not name.startswith("__")
+                    and not (is_dunder(name) or maybe_mangled(name, self.name))
                     and sym.node.has_explicit_value
                     and not (
                         isinstance(