Handle init=False with defaults in dataclasses (#1898)

(cherry picked from commit a178353)

Author: DanielNoord

ChangeLog

@@ -17,6 +17,10 @@ Release date: TBA
 
   Closes PyCQA/pylint#5225
 
+* Handle the effect of ``init=False`` in dataclass fields correctly.
+
+  Closes PyCQA/pylint#7291
+
 * Fix crash if ``numpy`` module doesn't have ``version`` attribute.
 
   Refs PyCQA/pylint#7868

astroid/brain/brain_dataclasses.py

@@ -115,33 +115,23 @@ def _get_dataclass_attributes(
 ) -> Iterator[nodes.AnnAssign]:
     """Yield the AnnAssign nodes of dataclass attributes for the node.
 
-    If init is True, also include InitVars, but exclude attributes from calls to
-    field where init=False.
+    If init is True, also include InitVars.
     """
     for assign_node in node.body:
         if not isinstance(assign_node, nodes.AnnAssign) or not isinstance(
             assign_node.target, nodes.AssignName
         ):
             continue
 
-        if _is_class_var(assign_node.annotation):  # type: ignore[arg-type] # annotation is never None
+        # Annotation is never None
+        if _is_class_var(assign_node.annotation):  # type: ignore[arg-type]
             continue
 
         if _is_keyword_only_sentinel(assign_node.annotation):
             continue
 
-        if init:
-            value = assign_node.value
-            if (
-                isinstance(value, nodes.Call)
-                and _looks_like_dataclass_field_call(value, check_scope=False)
-                and any(
-                    keyword.arg == "init" and not keyword.value.bool_value()
-                    for keyword in value.keywords
-                )
-            ):
-                continue
-        elif _is_init_var(assign_node.annotation):  # type: ignore[arg-type] # annotation is never None
+        # Annotation is never None
+        if not init and _is_init_var(assign_node.annotation):  # type: ignore[arg-type]
             continue
 
         yield assign_node
@@ -231,6 +221,25 @@ def _find_arguments_from_base_classes(
     return pos_only, kw_only
 
 
+def _get_previous_field_default(node: nodes.ClassDef, name: str) -> nodes.NodeNG | None:
+    """Get the default value of a previously defined field."""
+    for base in reversed(node.mro()):
+        if not base.is_dataclass:
+            continue
+        if name in base.locals:
+            for assign in base.locals[name]:
+                if (
+                    isinstance(assign.parent, nodes.AnnAssign)
+                    and assign.parent.value
+                    and isinstance(assign.parent.value, nodes.Call)
+                    and _looks_like_dataclass_field_call(assign.parent.value)
+                ):
+                    default = _get_field_default(assign.parent.value)
+                    if default:
+                        return default[1]
+    return None
+
+
 def _generate_dataclass_init(
     node: nodes.ClassDef, assigns: list[nodes.AnnAssign], kw_only_decorated: bool
 ) -> str:
@@ -254,6 +263,18 @@ def _generate_dataclass_init(
                 property_node = additional_assign
                 break
 
+        is_field = isinstance(value, nodes.Call) and _looks_like_dataclass_field_call(
+            value, check_scope=False
+        )
+
+        if is_field:
+            # Skip any fields that have `init=False`
+            if any(
+                keyword.arg == "init" and not keyword.value.bool_value()
+                for keyword in value.keywords  # type: ignore[union-attr] # value is never None
+            ):
+                continue
+
         if _is_init_var(annotation):  # type: ignore[arg-type] # annotation is never None
             init_var = True
             if isinstance(annotation, nodes.Subscript):
@@ -272,10 +293,8 @@ def _generate_dataclass_init(
             param_str = name
 
         if value:
-            if isinstance(value, nodes.Call) and _looks_like_dataclass_field_call(
-                value, check_scope=False
-            ):
-                result = _get_field_default(value)
+            if is_field:
+                result = _get_field_default(value)  # type: ignore[arg-type]
                 if result:
                     default_type, default_node = result
                     if default_type == "default":
@@ -296,6 +315,13 @@ def _generate_dataclass_init(
                 param_str += f" = {next(property_node.infer_call_result()).as_string()}"
             except (InferenceError, StopIteration):
                 pass
+        else:
+            # Even with `init=False` the default value still can be propogated to
+            # later assignments. Creating weird signatures like:
+            # (self, a: str = 1) -> None
+            previous_default = _get_previous_field_default(node, name)
+            if previous_default:
+                param_str += f" = {previous_default.as_string()}"
 
         params.append(param_str)
         if not init_var:

tests/unittest_brain_dataclasses.py

@@ -1062,6 +1062,62 @@ class ImpossibleGrandChild(FirstChild, SecondChild, ThirdChild):
     assert next(impossible.infer()) is Uninferable
 
 
+def test_dataclass_with_field_init_is_false() -> None:
+    """When init=False it shouldn't end up in the __init__."""
+    first, second, second_child, third_child, third = astroid.extract_node(
+        """
+    from dataclasses import dataclass, field
+
+
+    @dataclass
+    class First:
+        a: int
+
+    @dataclass
+    class Second(First):
+        a: int = field(init=False, default=1)
+
+    @dataclass
+    class SecondChild(Second):
+        a: float
+
+    @dataclass
+    class ThirdChild(SecondChild):
+        a: str
+
+    @dataclass
+    class Third(First):
+        a: str
+
+    First.__init__  #@
+    Second.__init__  #@
+    SecondChild.__init__  #@
+    ThirdChild.__init__  #@
+    Third.__init__  #@
+    """
+    )
+
+    first_init: bases.UnboundMethod = next(first.infer())
+    assert [a.name for a in first_init.args.args] == ["self", "a"]
+    assert [a.value for a in first_init.args.defaults] == []
+
+    second_init: bases.UnboundMethod = next(second.infer())
+    assert [a.name for a in second_init.args.args] == ["self"]
+    assert [a.value for a in second_init.args.defaults] == []
+
+    second_child_init: bases.UnboundMethod = next(second_child.infer())
+    assert [a.name for a in second_child_init.args.args] == ["self", "a"]
+    assert [a.value for a in second_child_init.args.defaults] == [1]
+
+    third_child_init: bases.UnboundMethod = next(third_child.infer())
+    assert [a.name for a in third_child_init.args.args] == ["self", "a"]
+    assert [a.value for a in third_child_init.args.defaults] == [1]
+
+    third_init: bases.UnboundMethod = next(third.infer())
+    assert [a.name for a in third_init.args.args] == ["self", "a"]
+    assert [a.value for a in third_init.args.defaults] == []
+
+
 def test_dataclass_inits_of_non_dataclasses() -> None:
     """Regression test for __init__ mangling for non dataclasses.