Treat converter=None on a dataclass field as no converter

Summary:
attrs treats `converter=None` exactly like leaving the converter out, and its stubs declare `converter: None` as the no-converter form. Pyrefly treated it as a real converter: the synthesized `__init__` parameter became `Unknown`, so `A("asd")` was accepted for an `int` field. Pyright, basedpyright and ty treat it as no converter.

Following Rebecca's direction, `None` is handled where the field's converter is stored: a `converter=` argument whose type is `None` is never stored, so everything that reads the stored converter treats the field as having none. That fixes the `__init__` parameter and also turns on the checks that only run without a converter: the `x.default` return type against the field type, an assignment to the attribute, and the `x.converter` decorator now applies. This covers every `dataclass_transform` field specifier, not only attrs, and because it checks the argument's type, a variable set to `None` counts too.

The attrs check of `default=` and `factory=` against the field type gets the same rule separately. It runs for every call to an attrs field specifier, including in classes pyrefly doesn't treat as attrs classes, where nothing is stored, so it reads the call's own `converter=` argument. A test from the previous diff fails if it reads the stored converter instead.

A converter whose type is a union with `None` still makes the `__init__` parameter partly `Unknown`; its `bug` test is unchanged.

Not mypy_primer: on 17 vendored libraries (the 8 standard ones plus 9 that use attrs), the base and patched builds reported the same diagnostics. None of them pass `converter=None`, so this only shows that real converters are unaffected.

Fixes #5283

Reviewed By: rchen152

Differential Revision: D130289218

fbshipit-source-id: a25dca184a213c156172b34f9d3425f150232650

Author: shahhamdihassan

pyrefly/lib/alt/class/dataclass.rs

@@ -902,8 +902,10 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
         let converter_param = self
             .attrs_converters_combinator_param(args, annotated_field_ty, errors)
             .or_else(|| {
+                // attrs treats `converter=None` as no converter.
                 map.0
                     .get(&DataclassFieldKeywords::CONVERTER)
+                    .filter(|converter| !converter.is_none())
                     .map(|converter| self.get_converter_param(converter, annotated_field_ty))
             });
         // Note that we intentionally don't try to fill in `default`, since we can't distinguish

pyrefly/lib/alt/solve.rs

@@ -4664,7 +4664,11 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
                 {
                     let got = self.expr_infer(expr, errors);
                     if let Some(annot_ty) = &annot_ty
-                        && call.arguments.find_keyword("converter").is_none()
+                        // attrs treats `converter=None` as no converter.
+                        && call.arguments.find_keyword("converter").is_none_or(|converter| {
+                            self.expr_infer(&converter.value, &self.error_swallower())
+                                .is_none()
+                        })
                         && self
                             .bindings()
                             .get_class_fields(spec.class_def_index)

pyrefly/lib/test/attrs/fields.rs

@@ -545,7 +545,6 @@ class C:
 
 // attrs treats `converter=None` as no converter: https://github.com/facebook/pyrefly/issues/5283
 attrs_testcase!(
-    bug = "A `None`-typed converter makes the `__init__` param `Unknown`",
     test_attrs_field_converter_none_init_param,
     r#"
 from typing import reveal_type
@@ -565,13 +564,12 @@ class C:
     d: int = field()
     e: int = field(converter=to_int)
 
-reveal_type(C.__init__)  # E: revealed type: (self: C, a: Unknown, b: Unknown, c: Unknown, d: int, e: str) -> None
+reveal_type(C.__init__)  # E: revealed type: (self: C, a: int, b: int, c: int, d: int, e: str) -> None
 "#,
 );
 
 // attrs treats `converter=None` as no converter: https://github.com/facebook/pyrefly/issues/5283
 attrs_testcase!(
-    bug = "A `None`-typed converter skips the check of the default against the field type",
     test_attrs_field_converter_none_default_type_check,
     r#"
 import attr
@@ -583,11 +581,11 @@ def make_str() -> str: ...
 
 @define
 class C:
-    a: int = field(default="nope", converter=None)
-    b: int = attr.ib(default="nope", converter=None)
-    c: int = field(default="nope", converter=NO_CONVERTER)
+    a: int = field(default="nope", converter=None)  # E: `Literal['nope']` is not assignable to `int`
+    b: int = attr.ib(default="nope", converter=None)  # E: `Literal['nope']` is not assignable to `int`
+    c: int = field(default="nope", converter=NO_CONVERTER)  # E: `Literal['nope']` is not assignable to `int`
     d: int = field(default="nope")  # E: `Literal['nope']` is not assignable to `int`
-    f: int = field(factory=make_str, converter=None)
+    f: int = field(factory=make_str, converter=None)  # E: `str` is not assignable to `int`
 "#,
 );
 
@@ -612,7 +610,6 @@ reveal_type(C.__init__)  # E: revealed type: (self: C, x: str | Unknown) -> None
 
 // attrs treats `converter=None` as no converter: https://github.com/facebook/pyrefly/issues/5283
 attrs_testcase!(
-    bug = "`converter=None` skips the `@x.default` return check and the `@x.converter` decorator",
     test_attrs_field_converter_none_decorators,
     r#"
 from typing import reveal_type
@@ -621,7 +618,7 @@ from attrs import define, field
 @define
 class C:
     a: int = field(converter=None)
-    b: int = field(converter=None)
+    b: int = field(converter=None)  # E: Return type `str` of the `@b.default` method is not assignable to field `b` of type `int`
 
     @a.converter
     def _a(self, attribute, value: str) -> int:
@@ -631,13 +628,12 @@ class C:
     def _b(self) -> str:
         return "nope"
 
-reveal_type(C.__init__)  # E: revealed type: (self: C, a: Unknown, b: Unknown = ...) -> None
+reveal_type(C.__init__)  # E: revealed type: (self: C, a: str, b: int = ...) -> None
 "#,
 );
 
 // attrs treats `converter=None` as no converter: https://github.com/facebook/pyrefly/issues/5283
 attrs_testcase!(
-    bug = "`converter=None` skips the check of an assignment to the attribute",
     test_attrs_field_converter_none_attribute_assignment,
     r#"
 from attrs import define, field
@@ -646,7 +642,7 @@ from attrs import define, field
 class C:
     a: int = field(converter=None)
 
-C(1).a = "nope"
+C(1).a = "nope"  # E: `Literal['nope']` is not assignable to attribute `a` with type `int`
 "#,
 );
 

pyrefly/lib/test/dataclass_transform.rs

@@ -673,7 +673,6 @@ Data(x=NotConvertibleToInt())  # E: `NotConvertibleToInt` is not assignable to p
 
 // `converter=None` means no converter, as in attrs: https://github.com/facebook/pyrefly/issues/5283
 testcase!(
-    bug = "`converter=None` makes the `__init__` param `Unknown`",
     test_converter_none_init_param,
     r#"
 from typing import dataclass_transform, Any, reveal_type
@@ -686,7 +685,7 @@ class C:
     x: str = my_field(converter=None)
     y: str = my_field()
     z: str = my_field(converter=to_str)
-reveal_type(C.__init__)  # E: revealed type: (self: C, x: Unknown, y: str, z: int) -> None
+reveal_type(C.__init__)  # E: revealed type: (self: C, x: str, y: str, z: int) -> None
     "#,
 );