Suggestion: Ignore B006 if the variable in question is immediately copied

I would argue that these two functions:

def foo(x=[]):
    x = list(x)
    x.reverse()
    return x

def bar(x={}):
    x = dict(x)
    x.pop('k', None)
    return x

are far more readable than the way B006 forces me to write them

def foo_bad(x=None):
    if x is None:
        x = []
    x.reverse()
    return x

def bar_bad(x=None):
    if x is None:
        x = {}
    x.pop('k', None)
    return x

Furthermore, the rewrite encouraged by B006 now actually leads to a bug - x = [1]; foo_bad(x) leads to x being mutated.

Would it be possible/sensible to add an exemption to B006 along the lines of “if the only use of the mutable default is to pass into a non-mutating function call, then emit no warning”?

[rupertnash]

1. The benefit here is that I only have to pass the optional mapping type when I need to. I agree this is tiny for this example, but with multiple “const qualified” optional args in the function signature, this becomes a major convenience to the caller and the implementor

Mypy will then check that callers pass only types that implement the (read only) mapping protocol (e.g. builtin dict) and that the function only uses that type in a read only way.

1. no comment

2. This is generally a good rule, I want to keep it on. Mypy will catch some of these errors but not e.g.:

def whatever(self, map: MutableMapping[str, str] = {}) -> None:
    map["key"] ="value"

I have just taken a fork and will see if I can create something…

[eric-wieser]

and then at some stage mutated

If I am missing something please explain what I am missing in how mypy makes this safe.

Mypy will detect any attempt to mutate the dict and emit an error

def evil(d : MutableMapping[str, str]):
   d[2] = True

def whatever(self, optional_map: Mapping[str, str] = {}) -> None:
    optional_map[1] = True  # mypy errors here, `Mapping` does not implement `__setitem__`.
    evil(optional_map)  # mypy errors here too, `Mapping` is not a `MutableMapping`