Today if you enter a `contextlib.suppress()` context and specify no exceptions there is no error or warning (I didn't check pywarnings to be fair). Isn't this a useless context then? If not, please explain why and close.

If it is, I'd love to discuss possibly raising a new NoSupressionError or at least a warning to let people know they executing an unneeded context.

Example code that 3.11 does not error on:

```python
cooper@home1:~$ python3.11
Python 3.11.0a5+ (main, Feb 21 2022, 08:52:10) [GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import contextlib
>>> with contextlib.suppress():
...   print("Foo")
...
Foo
```

This was reported to `flake8-bugbear` and if this is not accepted I may accept adding this to the linter. But feel this could be fixable in cpython itself.

I'm -1 on this suggestion; consider the following:

```
exceptions_to_suppress = []
if some_condition:
    exceptions_to_suppress.append(ValueError)

with contextlib.suppress(*exceptions_to_suppress):
    do_a_thing()
```

This seems a reasonable case to support and would require quite some gymnastics to continue supporting while also warning on an empty set.

Totally agree with your example use case. There you have a chance for it being useful under certain conditions. In that example there is a passed argument.  In my example there is no passed argument. Thus, I believe that this will generally always be developer error, again, unless I'm missing something here.

My main suggestion here is to just error/warn when no argument at all is passed to `contextlib.suppress` and this this context is *never* a chance of it being useful. If someone passes None or an empty `Sequence` (or anything non truthy) I propose we stay behaving the same as today.

Please feel free to edit the title if that's not clear enough etc.

But `suppress` takes varargs; from `suppress`'s perspective, there is no difference between `suppress()` and `l=[];suppress(*l)`.  There would be a difference at the AST level, but trying to find it within `suppress` to issue a warning seems unfeasible.  Certainly possible for a linter, though :)

I concur with Zachary.

Note that suppress without arguments corresponds to "except" and isinstance() with empty tuple.

Ok thanks. Looks like the warning in flake8-bugbear is the right place then, unfortunately.

And just to be sure:

> Note that suppress without arguments corresponds to "except" and isinstance() with empty tuple.

Are you saying that `contextlib.suppress()` should effectively `except BaseException` (cause this is not the behavior from my tests) and suppress all or suppress nothing? I believe the empty tuple makes it except nothing?

```python
cooper@home1:~$ python3.11
Python 3.11.0a5+ (main, Feb 22 2022, 08:51:50) [GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import contextlib
>>> with contextlib.suppress():
...   raise ValueError("I raise ...")
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
ValueError: I raise ...
>>>
```

>>> try:
...     raise ValueError("I raise...")
... except ():
...     pass
... 
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
ValueError: I raise...

No, I say that

    with suppress():
        ...

is equivalent to

    try:
        ...
    except ():
        pass

or

    try:
        ...
    except BaseException as err:
        if not isinstance(err, ()):
            raise

If you want to suppress all exceptions (it is not very clever idea), use suppress(BaseException).

I would never want to do that ... I understand it's bad. Just questioning things before adding lints so we put things in the right places and more importantly making sure I understand.

Thanks for the discussion all.

FWIW - Will be looking to add to flake8-bugbear here: https://github.com/PyCQA/flake8-bugbear/issues/222