make_class: accept Attribute instances in 'these' (#1424)

When a class is rebuilt from attrs.fields() via attrs.make_class, the
'these' mapping contains Attribute instances rather than _CountingAttr
objects. from_counting_attr was only reading the private _default,
_validator, and _converter attributes, which Attribute does not expose,
so the rebuild crashed with "'Attribute' object has no attribute
'_default'".

Detect an Attribute argument and read the public default/validator/
converter attributes directly. Add a regression test and a changelog
entry.

Author: Zo Bot

changelog.d/1424.change.md

@@ -0,0 +1 @@
+`attrs.make_class()` now works when its `attrs` argument is a dict of existing `attrs.Attribute` instances (e.g. from `attrs.fields(cls)`), not just fresh `attr.ib()` / `attrs.field()` call

src/attr/_make.py

@@ -2570,6 +2570,36 @@ def from_counting_attr(
         elif ca.type is not None:
             msg = f"Type annotation and type argument cannot both be present for '{name}'."
             raise ValueError(msg)
+
+        # `from_counting_attr` is also called with already-built `Attribute`
+        # instances (e.g. when a class is reconstructed from
+        # `attrs.fields(cls)` via `attrs.make_class`, see #1424). In that case
+        # `ca` is an `Attribute` and exposes the public `default`/`validator`/
+        # `converter` attributes rather than the `_default`/`_validator`/
+        # `_converter` internals of `_CountingAttr`.
+        if isinstance(ca, Attribute):
+            return cls(
+                name,
+                ca.default,
+                ca.validator,
+                ca.repr,
+                None,
+                ca.hash,
+                ca.init,
+                False,
+                ca.metadata,
+                type,
+                ca.converter,
+                kw_only if ca.kw_only is None else ca.kw_only,
+                ca.eq,
+                ca.eq_key,
+                ca.order,
+                ca.order_key,
+                ca.on_setattr,
+                ca.alias,
+                ca.alias_is_default,
+            )
+
         return cls(
             name,
             ca._default,

tests/test_make.py

@@ -1535,6 +1535,50 @@ def test_make_class_ordered(self):
 
         assert "C(a=1, b=2)" == repr(C())
 
+    def test_make_class_from_attrs_fields(self):
+        """
+        make_class can rebuild a class from attrs.fields() output, not only
+        fresh _CountingAttr / attr.ib() values.
+
+        https://github.com/python-attrs/attrs/issues/1424
+        """
+
+        @attr.s
+        class Source:
+            a = attr.ib(type=int)
+            b = attr.ib(
+                default="x", validator=attr.validators.instance_of(str)
+            )
+            c = attr.ib(
+                default=0,
+                converter=attr.converters.optional(int),
+            )
+
+        # Convert the source's _CountingAttr-derived fields into proper
+        # Attribute instances via make_class, then re-run make_class on those
+        # Attribute instances. The second pass previously failed with
+        # "'Attribute' object has no attribute '_default'".
+        rebuilt = attr.make_class(
+            "Rebuilt",
+            {f.name: f for f in attr.fields(Source)},
+        )
+
+        # Order is preserved end-to-end.
+        assert ["a", "b", "c"] == [a.name for a in attr.fields(rebuilt)]
+
+        # `a` has no default and the rest do, so call with positional a and
+        # rely on defaults to fill b/c. `7` for c is converted via int.
+        ri = rebuilt(5)
+        assert 5 == ri.a
+        assert "x" == ri.b
+        assert 0 == ri.c
+
+        ri = rebuilt(5, "hello")
+        assert "hello" == ri.b
+
+        ri = rebuilt(5, "hello", "7")
+        assert 7 == ri.c
+
     def test_generic_dynamic_class(self):
         """
         make_class can create generic dynamic classes.