add function maybe_mangled mainly for fixing the handling of "private" enum members

Author: tyralla

mypy/checker.py

@@ -210,7 +210,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 maybe_mangled, is_dunder, is_sunder
 from mypy.visitor import NodeVisitor
 
 T = TypeVar("T")
@@ -2711,7 +2711,7 @@ def is_final_enum_value(self, sym: SymbolTableNode, base: TypeInfo) -> bool:
         # 4. If it is a method / descriptor like in `method = classmethod(func)`
         name = sym.node.name
         if (
-            (name.startswith(f"_{base.name}__") and not name.endswith("__"))
+            maybe_mangled(name, base.name)
             or is_dunder(name)
             or is_sunder(name)
             # TODO: make sure that `x = @class/staticmethod(func)`

mypy/checkmember.py

@@ -73,6 +73,7 @@
     get_proper_type,
 )
 from mypy.typetraverser import TypeTraverserVisitor
+from mypy.util import maybe_mangled, is_dunder
 
 if TYPE_CHECKING:  # import for forward declaration only
     import mypy.checker
@@ -1197,7 +1198,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/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 maybe_mangled, is_dunder, is_typeshed_file, short_type
 from mypy.visitor import ExpressionVisitor, NodeVisitor, StatementVisitor
 
 if TYPE_CHECKING:
@@ -3237,7 +3237,7 @@ def enum_members(self) -> list[str]:
             if (
                 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
             )
         ]

mypy/semanal.py

@@ -303,7 +303,7 @@
 )
 from mypy.types_utils import is_invalid_recursive_alias, store_argument_type
 from mypy.typevars import fill_typevars
-from mypy.util import correct_relative_import, is_dunder, module_prefix, unmangle, unnamed_function
+from mypy.util import correct_relative_import, maybe_mangled, is_dunder, module_prefix, unmangle, unnamed_function
 from mypy.visitor import NodeVisitor
 
 T = TypeVar("T")
@@ -4292,7 +4292,7 @@ def analyze_name_lvalue(
             kind == MDEF
             and isinstance(self.type, TypeInfo)
             and self.type.is_enum
-            and not name.startswith("__")
+            and not (is_dunder(name) or maybe_mangled(name, self.type.name))
         ):
             # Special case: we need to be sure that `Enum` keys are unique.
             if existing is not None and not isinstance(existing.node, PlaceholderNode):

mypy/typeanal.py

@@ -114,6 +114,7 @@
 )
 from mypy.types_utils import get_bad_type_type_item
 from mypy.typevars import fill_typevars
+from mypy.util import maybe_mangled
 
 T = TypeVar("T")
 
@@ -980,7 +981,7 @@ def analyze_unbound_type_without_type_info(
             isinstance(sym.node, Var)
             and sym.node.info
             and sym.node.info.is_enum
-            and not sym.node.name.startswith("__")
+            and not maybe_mangled(sym.node.name, sym.node.info.name)
         ):
             value = sym.node.name
             base_enum_short_name = sym.node.info.name

mypy/util.py

@@ -62,13 +62,17 @@ def is_dunder(name: str, exclude_special: bool = False) -> bool:
     """
     if exclude_special and name in SPECIAL_DUNDERS:
         return False
-    return name.startswith("__") and name.endswith("__")
+    return name.startswith("__") and name.endswith("__") and name.replace("_", "")
 
 
 def is_sunder(name: str) -> bool:
     return not is_dunder(name) and name.startswith("_") and name.endswith("_")
 
 
+def maybe_mangled(member_name: str, type_name: str) -> bool:
+    return member_name.startswith(f"_{type_name}__") and not member_name.endswith("__")
+
+
 def split_module_names(mod_name: str) -> list[str]:
     """Return the module and all parent module names.
 

test-data/unit/check-enum.test

@@ -2260,8 +2260,7 @@ class MyEnum(Enum):
     B = 2
     __my_dict = {A: "ham", B: "spam"}
 
-# TODO: change the next line to use MyEnum._MyEnum__my_dict when mypy implements name mangling
-x: MyEnum = MyEnum.__my_dict  # E: Incompatible types in assignment (expression has type "Dict[int, str]", variable has type "MyEnum")
+x: MyEnum = MyEnum._MyEnum__my_dict  # E: Incompatible types in assignment (expression has type "Dict[int, str]", variable has type "MyEnum")
 [builtins fixtures/enum.pyi]
 
 [case testEnumWithPrivateAttributeReachability]

test-data/unit/check-literal.test

@@ -2506,8 +2506,7 @@ b: Literal[Color.BLUE]
 bad1: Literal[Color]         # E: Parameter 1 of Literal[...] is invalid
 bad2: Literal[Color.func]    # E: Parameter 1 of Literal[...] is invalid
 bad3: Literal[Color.func()]  # E: Invalid type: Literal[...] cannot contain arbitrary expressions
-# TODO: change the next line to use Color._Color__ROUGE when mypy implements name mangling
-bad4: Literal[Color.__ROUGE]  # E: Parameter 1 of Literal[...] is invalid
+bad4: Literal[Color._Color__ROUGE]  # E: Parameter 1 of Literal[...] is invalid
 
 def expects_color(x: Color) -> None: pass
 def expects_red(x: Literal[Color.RED]) -> None: pass