Respect registered classvar strategy leaves

Author: trissim

nominal_refactor_advisor/detectors/_helpers.py

@@ -5313,16 +5313,82 @@ def _nominal_class_name_suffixes(class_name: str) -> tuple[str, ...]:
     return tuple(("".join(tokens[index:]) for index in range(len(tokens) - 1)))
 
 
+_REGISTERED_NOMINAL_AUTHORITY_ASSIGNMENTS = frozenset(
+    {
+        "__registry_key__",
+        "__enum_member_attr__",
+        "__enum_label_attr__",
+    }
+)
+
+
+def _module_class_nodes(module: ParsedModule) -> dict[str, ast.ClassDef]:
+    return {
+        node.name: node
+        for node in _walk_nodes(module.module)
+        if isinstance(node, ast.ClassDef)
+    }
+
+
+def _class_family_nodes_in_module(
+    class_nodes: Mapping[str, ast.ClassDef],
+    node: ast.ClassDef,
+) -> tuple[ast.ClassDef, ...]:
+    """Return the class and same-module ancestors known to static analysis."""
+    family_nodes: list[ast.ClassDef] = []
+    seen: set[str] = set()
+    stack = [node]
+    while stack:
+        current = stack.pop()
+        if current.name in seen:
+            continue
+        seen.add(current.name)
+        family_nodes.append(current)
+        stack.extend(
+            (
+                class_nodes[base_name]
+                for base_name in CLASS_NODE_AUTHORITY.declared_base_names(current)
+                if base_name in class_nodes and base_name not in seen
+            )
+        )
+    return tuple(family_nodes)
+
+
+def _is_registered_nominal_authority_node(node: ast.ClassDef) -> bool:
+    assignments = CLASS_NODE_AUTHORITY.direct_assignments(node)
+    return (
+        HELPER_SUPPORT_PROJECTION_AUTHORITY.declares_autoregister_meta(node)
+        or bool(_REGISTERED_NOMINAL_AUTHORITY_ASSIGNMENTS & set(assignments))
+    )
+
+
+def _has_registered_nominal_authority_ancestor(
+    class_nodes: Mapping[str, ast.ClassDef],
+    node: ast.ClassDef,
+) -> bool:
+    """Return True when classvar leaves are backed by a real registry family."""
+    return any(
+        (
+            family_node is not node
+            and _is_registered_nominal_authority_node(family_node)
+        )
+        for family_node in _class_family_nodes_in_module(class_nodes, node)
+    )
+
+
 def _metadata_only_class_family_candidates(
     module: ParsedModule,
 ) -> tuple[MetadataOnlyClassFamilyCandidate, ...]:
+    class_nodes = _module_class_nodes(module)
     grouped: dict[
         str,
         list[tuple[ast.ClassDef, tuple[str, ...], tuple[str, ...], int]],
     ] = defaultdict(list)
     for node in _walk_nodes(module.module):
         if not isinstance(node, ast.ClassDef) or node.decorator_list:
             continue
+        if _has_registered_nominal_authority_ancestor(class_nodes, node):
+            continue
         assigned_names = (
             HELPER_SYNTAX_PROJECTION_AUTHORITY.metadata_only_class_assignment_names(
                 node
@@ -5602,11 +5668,14 @@ def _classvar_only_sibling_leaf_candidates_for_class(
 def _classvar_only_sibling_leaf_candidates(
     module: ParsedModule,
 ) -> tuple[DeclarativeFamilyLeafCandidate, ...]:
+    class_nodes = _module_class_nodes(module)
     return CANDIDATE_COLLECTION_AUTHORITY.ast_node_candidates(
         module,
         module.module,
         ast.ClassDef,
-        _classvar_only_sibling_leaf_candidates_for_class,
+        lambda parsed_module, node: ()
+        if _has_registered_nominal_authority_ancestor(class_nodes, node)
+        else _classvar_only_sibling_leaf_candidates_for_class(parsed_module, node),
     )
 
 

tests/test_refactor_advisor.py

@@ -7804,6 +7804,20 @@ def test_detects_classvar_only_sibling_leaf(tmp_path: Path) -> None:
     assert "declarative family-definition table" in (finding.codemod_patch or "")
 
 
+def test_ignores_registered_classvar_only_strategy_leaves(
+    tmp_path: Path,
+) -> None:
+    _write_module(
+        tmp_path,
+        "pkg/mod.py",
+        '\nfrom abc import ABC, abstractmethod\nfrom enum import Enum\nfrom typing import ClassVar\n\nfrom metaclass_registry import AutoRegisterMeta\n\n\nclass Scheme(Enum):\n    RGB = "RGB"\n    CMYK = "CMYK"\n    STACK = "Stack"\n\n\nclass EnumKeyedStrategyMixin:\n    pass\n\n\nclass SchemeBindingStrategy(EnumKeyedStrategyMixin, ABC, metaclass=AutoRegisterMeta):\n    __registry_key__ = "scheme_literal"\n    __skip_if_no_key__ = True\n    scheme_literal: ClassVar[str | None] = None\n    __enum_member_attr__ = "scheme"\n    __enum_label_attr__ = "scheme_literal"\n\n    @abstractmethod\n    def bind(self, module):\n        raise NotImplementedError\n\n\nclass IndexedSchemeBindingStrategy(SchemeBindingStrategy):\n    image_settings: ClassVar[tuple[str, ...]] = ()\n    weight_settings: ClassVar[tuple[str, ...]] = ()\n\n    def bind(self, module):\n        return tuple(type(self).image_settings), tuple(type(self).weight_settings)\n\n\nclass RgbBindingStrategy(IndexedSchemeBindingStrategy):\n    scheme = Scheme.RGB\n    image_settings = ("red", "green", "blue")\n    weight_settings = ("red_weight", "green_weight", "blue_weight")\n\n\nclass CmykBindingStrategy(IndexedSchemeBindingStrategy):\n    scheme = Scheme.CMYK\n    image_settings = ("cyan", "magenta", "yellow", "gray")\n    weight_settings = ("cyan_weight", "magenta_weight", "yellow_weight", "gray_weight")\n\n\nclass StackBindingStrategy(SchemeBindingStrategy):\n    scheme = Scheme.STACK\n',
+    )
+    findings = analyze_path(tmp_path)
+    detector_ids = {finding.detector_id for finding in findings}
+    assert "metadata_only_class_family" not in detector_ids
+    assert "classvar_only_sibling_leaf" not in detector_ids
+
+
 def test_detects_metadata_only_class_family_with_varying_bases(
     tmp_path: Path,
 ) -> None: