Automatically detect decorator argument default.

Instead of relying only on hardcoded default value, first try to find
out the actuall default value of a bool argument to a the
class/attrib-maker decorators, and only if the value could not be
extracted from the code, fall back to the default value defined in mypy.

This enables the correct handling of decorators which wrap attrs
decorators but set different defaults, for example to kw_only.

This commit also adds to test cases. testAttrsWrappedDecorators tests
the existing support for wrapping attrs decorators, via a "fake plugin"
and testAttrsWrappedDecoratorsWithDifferentDefaults tests the new
support for decorators that have different default values than the attrs
decorators.

Author: t4lz

mypy/plugins/attrs.py

@@ -17,7 +17,7 @@
 from mypy.plugin import SemanticAnalyzerPluginInterface
 from mypy.plugins.common import (
     _get_argument, _get_bool_argument, _get_decorator_bool_argument, add_method,
-    deserialize_and_fixup_type, add_attribute_to_class,
+    deserialize_and_fixup_type, add_attribute_to_class, _get_default_bool_value,
 )
 from mypy.types import (
     TupleType, Type, AnyType, TypeOfAny, CallableType, NoneType, TypeVarType,
@@ -205,6 +205,9 @@ def _get_decorator_optional_bool_argument(
 ) -> Optional[bool]:
     """Return the Optional[bool] argument for the decorator.
 
+    If the argument was not passed, try to find out the default value of the argument and return
+    that. If a default value cannot be automatically determined, return the value of the `default`
+    argument of this function.
     This handles both @decorator(...) and @decorator.
     """
     if isinstance(ctx.reason, CallExpr):
@@ -219,9 +222,7 @@ def _get_decorator_optional_bool_argument(
                     return None
             ctx.api.fail(f'"{name}" argument must be True or False.', ctx.reason)
             return default
-        return default
-    else:
-        return default
+    return _get_default_bool_value(ctx.reason, name, default)
 
 
 def attr_tag_callback(ctx: 'mypy.plugin.ClassDefContext') -> None:

mypy/plugins/common.py

@@ -2,7 +2,7 @@
 
 from mypy.nodes import (
     ARG_POS, MDEF, Argument, Block, CallExpr, ClassDef, Expression, SYMBOL_FUNCBASE_TYPES,
-    FuncDef, PassStmt, RefExpr, SymbolTableNode, Var, JsonDict,
+    FuncDef, PassStmt, RefExpr, SymbolTableNode, Var, JsonDict, NameExpr,
 )
 from mypy.plugin import CheckerPluginInterface, ClassDefContext, SemanticAnalyzerPluginInterface
 from mypy.semanal import set_callable_name, ALLOW_INCOMPATIBLE_OVERRIDE
@@ -24,25 +24,36 @@ def _get_decorator_bool_argument(
 
     This handles both @decorator(...) and @decorator.
     """
-    if isinstance(ctx.reason, CallExpr):
+    if isinstance(ctx.reason, CallExpr):  # @decorator(...)
         return _get_bool_argument(ctx, ctx.reason, name, default)
-    else:
-        return default
+    # @decorator - no call. Try to get default value from decorator definition.
+    if isinstance(ctx.reason, NameExpr) and isinstance(ctx.reason.node, FuncDef):
+        default_value = _get_default_bool_value(ctx.reason.node, name, default)
+        if default_value is not None:
+            return default_value
+        # If we are here, no value was passed in call, default was found in def and it is None.
+        # Should we ctx.api.fail here?
+    return default
 
 
 def _get_bool_argument(ctx: ClassDefContext, expr: CallExpr,
                        name: str, default: bool) -> bool:
-    """Return the boolean value for an argument to a call or the
-    default if it's not found.
+    """Return the boolean value for an argument to a call.
+
+    If the argument was not passed, try to find out the default value of the argument and return
+    that. If a default value cannot be automatically determined, return the value of the `default`
+    argument of this function.
     """
     attr_value = _get_argument(expr, name)
     if attr_value:
         ret = ctx.api.parse_bool(attr_value)
-        if ret is None:
-            ctx.api.fail(f'"{name}" argument must be True or False.', expr)
-            return default
-        return ret
-    return default
+    else:
+        # This argument was not passed in the call. Try to extract default from function def.
+        ret = _get_default_bool_value(expr, name, default)
+    if ret is None:
+        ctx.api.fail(f'"{name}" argument must be True or False.', expr)
+        return default
+    return ret
 
 
 def _get_argument(call: CallExpr, name: str) -> Optional[Expression]:
@@ -82,6 +93,36 @@ def _get_argument(call: CallExpr, name: str) -> Optional[Expression]:
     return None
 
 
+def _get_default_bool_value(
+    expr: Union[CallExpr, FuncDef, Expression], name: str, default: Optional[bool] = None
+) -> Optional[bool]:
+    """Return the default value for the argument with this name from an expression.
+
+    Try to extract the default optional bool value from the definition. If cannot extract
+    default value from the code, return the analyzer-defined default instead.
+    """
+    if isinstance(expr, CallExpr):  # We have a @decorator(...) situation.
+        if isinstance(expr.callee, RefExpr):
+            callee_node = expr.callee.node
+            if isinstance(callee_node, FuncDef):
+                expr = callee_node  # Will enter next if clause.
+    if isinstance(expr, FuncDef):
+        try:
+            initializer = expr.arguments[expr.arg_names.index(name)].initializer
+        except ValueError:  # name not in func_def.arg_names
+            return default
+        if initializer is None or not isinstance(initializer, NameExpr):
+            # No default was defined in the code or it is a complex expression.
+            return default  # Return analyzer-defined default.
+        if initializer.fullname == 'builtins.True':
+            return True
+        if initializer.fullname == 'builtins.False':
+            return False
+        if initializer.fullname == 'builtins.None':
+            return None
+    return default  # Cannot extract default from code, return analyzer-defined default.
+
+
 def add_method(
         ctx: ClassDefContext,
         name: str,

test-data/unit/check-attr.test

@@ -1778,3 +1778,74 @@ class C:
 c = C(x=[C.D()])
 reveal_type(c.x)  # N: Revealed type is "builtins.list[__main__.C.D]"
 [builtins fixtures/list.pyi]
+
+[case testAttrsWrappedDecorators]
+# flags: --config-file tmp/mypy-fake-plugin-conf.ini
+import attr
+from typing import Any
+
+# Test that no errors are raised when the custom decorators are added to the maker lists.
+def my_attr_dataclass(cls) -> Any:
+    return attr.dataclass()(cls)
+
+def my_attr_s(cls) -> Any:
+    return attr.s()(cls)
+
+def my_attr_ib() -> Any:
+    return attr.ib()
+
+@my_attr_dataclass
+class A:
+    num: int = my_attr_ib()
+
+@my_attr_s
+class B:
+    string: str = my_attr_ib()
+
+a = A(42)
+b = B("Forty two")
+[builtins fixtures/attr.pyi]
+
+[file mypy-fake-plugin-conf.ini]
+\[mypy]
+plugins=<ROOT>/test-data/unit/plugins/fake_attrs_plugin.py
+
+
+[case testAttrsWrappedDecoratorsWithDifferentDefaults]
+# flags: --config-file tmp/mypy-fake-plugin-conf.ini
+import attr
+from typing import Any
+
+# Test that the attrs plugin detects the custom default values, and no false positives are raised.
+def my_attr_dataclass(cls, auto_attribs: bool = True) -> Any:
+    return attr.dataclass(auto_attribs=auto_attribs)(cls)
+
+def my_attr_s(cls, kw_only: bool = True) -> Any:
+    return attr.s(kw_only=kw_only)(cls)
+
+def my_attr_ib(**kwargs) -> Any:
+    return attr.ib(**kwargs)
+
+@my_attr_dataclass
+class A:
+    num: int = 42
+
+@my_attr_s
+class B:
+    optional: str = my_attr_ib(default="This attrib is not required now.")
+
+@my_attr_s
+class C(B):
+    # It is ok to have a required "after" an optional attrib, since kw_only is True.
+    required: str = my_attr_ib()
+
+a = A(num=42)
+b = B()
+b.optional
+c = C(required="Forty Two")
+[builtins fixtures/attr.pyi]
+[builtins fixtures/dict.pyi]
+
+[file mypy-fake-plugin-conf.ini]
+\[mypy]
+plugins=<ROOT>/test-data/unit/plugins/fake_attrs_plugin.py

test-data/unit/plugins/fake_attrs_plugin.py

@@ -0,0 +1,20 @@
+from mypy.plugin import Plugin
+from mypy.plugins.attrs import (
+    attr_attrib_makers,
+    attr_class_makers,
+    attr_dataclass_makers,
+)
+
+# See https://www.attrs.org/en/stable/extending.html#mypy for background.
+attr_dataclass_makers.add("__main__.my_attr_dataclass")
+attr_class_makers.add("__main__.my_attr_s")
+attr_attrib_makers.add("__main__.my_attr_ib")
+
+
+class MyPlugin(Plugin):
+    # Our plugin does nothing but it has to exist so this file gets loaded.
+    pass
+
+
+def plugin(version):
+    return MyPlugin