Merge branch 'main' into 91x_autofix

Author: Zac-HD

.pre-commit-config.yaml

@@ -48,7 +48,7 @@ repos:
     rev: 6.0.0
     hooks:
     -   id: flake8
-        args: ["--exclude", ".*,tests/eval_files/*,tests/autofix_files/*"]
+        types: ["python", "pyi"]
         language_version: python3
         additional_dependencies:
           - flake8-builtins
@@ -67,12 +67,15 @@ repos:
           - flake8-return
           - flake8-simplify
           - flake8-type-checking
+          - flake8-pyi
 
+# Pinned to flake8 5.0.4 since flake8-eradicate is not updated to work with flake8 6
+# https://github.com/wemake-services/flake8-eradicate/pull/271
 -   repo: https://github.com/PyCQA/flake8
     rev: 5.0.4
     hooks:
     -   id: flake8
-        args: ["--exclude", ".*,tests/eval_files/*", "--select=E800"]
+        args: ["--select=E800"]
         language_version: python3
         additional_dependencies:
           - flake8-eradicate

README.md

@@ -20,23 +20,23 @@ pip install flake8-trio
 
 ## List of warnings
 
-- **TRIO100**: a `with trio.fail_after(...):` or `with trio.move_on_after(...):`
+- **TRIO100**: A `with trio.fail_after(...):` or `with trio.move_on_after(...):`
   context does not contain any `await` statements.  This makes it pointless, as
   the timeout can only be triggered by a checkpoint.
 - **TRIO101**: `yield` inside a nursery or cancel scope is only safe when implementing a context manager - otherwise, it breaks exception handling.
-- **TRIO102**: it's unsafe to await inside `finally:` or `except BaseException/trio.Cancelled` unless you use a shielded
+- **TRIO102**: It's unsafe to await inside `finally:` or `except BaseException/trio.Cancelled` unless you use a shielded
   cancel scope with a timeout.
 - **TRIO103**: `except BaseException`, `except trio.Cancelled` or a bare `except:` with a code path that doesn't re-raise. If you don't want to re-raise `BaseException`, add a separate handler for `trio.Cancelled` before.
 - **TRIO104**: `Cancelled` and `BaseException` must be re-raised - when a user tries to `return` or `raise` a different exception.
 - **TRIO105**: Calling a trio async function without immediately `await`ing it.
-- **TRIO106**: trio must be imported with `import trio` for the linter to work.
+- **TRIO106**: `trio` must be imported with `import trio` for the linter to work.
 - **TRIO107**: Renamed to TRIO910
 - **TRIO108**: Renamed to TRIO911
 - **TRIO109**: Async function definition with a `timeout` parameter - use `trio.[fail/move_on]_[after/at]` instead
 - **TRIO110**: `while <condition>: await trio.sleep()` should be replaced by a `trio.Event`.
 - **TRIO111**: Variable, from context manager opened inside nursery, passed to `start[_soon]` might be invalidly accessed while in use, due to context manager closing before the nursery. This is usually a bug, and nurseries should generally be the inner-most context manager.
-- **TRIO112**: nursery body with only a call to `nursery.start[_soon]` and not passing itself as a parameter can be replaced with a regular function call.
-- **TRIO113**: using `nursery.start_soon` in `__aenter__` doesn't wait for the task to begin. Consider replacing with `nursery.start`.
+- **TRIO112**: Nursery body with only a call to `nursery.start[_soon]` and not passing itself as a parameter can be replaced with a regular function call.
+- **TRIO113**: Using `nursery.start_soon` in `__aenter__` doesn't wait for the task to begin. Consider replacing with `nursery.start`.
 - **TRIO114**: Startable function (i.e. has a `task_status` keyword parameter) not in `--startable-in-context-manager` parameter list, please add it so TRIO113 can catch errors when using it.
 - **TRIO115**: Replace `trio.sleep(0)` with the more suggestive `trio.lowlevel.checkpoint()`.
 - **TRIO116**: `trio.sleep()` with >24 hour interval should usually be`trio.sleep_forever()`.
@@ -59,8 +59,8 @@ pip install flake8-trio
 
 ### Warnings disabled by default
 - **TRIO900**: Async generator without `@asynccontextmanager` not allowed.
-- **TRIO910**: exit or `return` from async function with no guaranteed checkpoint or exception since function definition.
-- **TRIO911**: exit, yield or return from async iterable with no guaranteed checkpoint since possible function entry (yield or function definition)
+- **TRIO910**: Exit or `return` from async function with no guaranteed checkpoint or exception since function definition.
+- **TRIO911**: Exit, `yield` or `return` from async iterable with no guaranteed checkpoint since possible function entry (yield or function definition)
   Checkpoints are `await`, `async for`, and `async with` (on one of enter/exit).
 
 ## Configuration

flake8_trio/visitors/helpers.py

@@ -137,9 +137,24 @@ def iter_guaranteed_once(iterable: ast.expr) -> bool:
         and iterable.func.id == "range"
     ):
         try:
-            return len(range(*[ast.literal_eval(a) for a in iterable.args])) > 0
+            values = [ast.literal_eval(a) for a in iterable.args]
         except Exception:  # noqa: PIE786
+            # parameters aren't literal
             return False
+
+        try:
+            evaluated_range = range(*values)
+        except (ValueError, TypeError):
+            str_values = ", ".join(map(str, values))
+            raise RuntimeError(
+                f"Invalid literal values to range function: `range({str_values})`"
+            )
+
+        try:
+            return len(evaluated_range) > 0
+        # if the length is > sys.maxsize
+        except OverflowError:
+            return True
     return False
 
 
@@ -186,7 +201,10 @@ def iter_guaranteed_once_cst(iterable: cst.BaseExpression) -> bool:
         try:
             evaluated_range = range(*values)
         except (ValueError, TypeError):
-            return False
+            str_values = ", ".join(map(str, values))
+            raise RuntimeError(
+                f"Invalid literal values to range function: `range({str_values})`"
+            )
         try:
             return len(evaluated_range) > 0
         # if the length is > sys.maxsize

tests/eval_files/trio103.py

@@ -250,6 +250,12 @@ def foo() -> Any:
     for i in range(3):
         raise
 
+try:
+    ...
+except BaseException:
+    for i in range(27670116110564327421):
+        raise
+
 try:
     ...
 except BaseException:  # TRIO103_trio: 7, "BaseException"

tests/eval_files/trio911.py

@@ -821,16 +821,6 @@ async def foo_loop_static():
         await foo()
     yield
 
-    # malformed range calls
-    for i in range(5, 2, 3, 4):  # type: ignore
-        await foo()
-    yield  # error: 4, "yield", Stmt("yield", line-5)
-
-    # is not caught by type checkers
-    for i in range(1, 10, 0):
-        await foo()
-    yield  # error: 4, "yield", Stmt("yield", line-5)
-
     for i in range(1 + 1):  # not handled
         await foo()
     yield  # error: 4, "yield", Stmt("yield", line-4)

tests/test_config_and_args.py

@@ -110,14 +110,14 @@ def test_anyio_from_config(tmp_path: Path, capsys: pytest.CaptureFixture[str]):
     returnvalue = main(
         argv=[
             err_file,
-            "--append-config",
+            "--config",
             str(tmp_path / ".flake8"),
         ]
     )
-    assert returnvalue == 1
     out, err = capsys.readouterr()
     assert not err
     assert expected == out
+    assert returnvalue == 1
 
 
 def _test_trio200_from_config_common(tmp_path: Path) -> str:

tests/test_exception_on_invalid_code.py

@@ -0,0 +1,33 @@
+"""Checks for exceptions raised on invalid code."""
+
+import ast
+
+import libcst as cst
+import pytest
+
+from flake8_trio.visitors.helpers import iter_guaranteed_once, iter_guaranteed_once_cst
+
+
+def _raises_on_code_cst(source: str):
+    expression = cst.parse_expression(source)
+    with pytest.raises(RuntimeError, match="Invalid literal values.*"):
+        iter_guaranteed_once_cst(expression)
+
+
+def test_iter_guaranteed_once_cst():
+    _raises_on_code_cst("range(1, 10, 0)")
+    _raises_on_code_cst("range(5, 2, 3, 4)")
+
+
+def _raises_on_code_ast(source: str):
+    expression = ast.parse(source).body[0]
+    assert isinstance(expression, ast.Expr)
+    call = expression.value
+    assert isinstance(call, ast.Call)
+    with pytest.raises(RuntimeError, match="Invalid literal values.*"):
+        iter_guaranteed_once(call)
+
+
+def test_iter_guaranteed_once():
+    _raises_on_code_ast("range(1, 10, 0)")
+    _raises_on_code_ast("range(5, 2, 3, 4)")

tox.ini

@@ -38,7 +38,16 @@ source =
 [flake8]
 max-line-length = 90
 extend-ignore = S101, D101, D102, D103, D105, D106, D107, TC006
-per-file-ignores = flake8_trio/visitors/__init__.py: F401, E402
+extend-enable = TC10
+exclude = .*, tests/eval_files/*
+per-file-ignores =
+    flake8_trio/visitors/__init__.py: F401, E402
+# (TC002, TC003) We don't care about moving imports into type-checking blocks
+# see https://github.com/snok/flake8-type-checking/issues/152
+# (E301, E302) black formats stub files without excessive blank lines
+# (D) we don't care about docstrings in stub files
+# (Y021, Y048) pyright includes docstrings in generated files, so don't complain about them
+    *.pyi: TC002, TC003, D, E301, E302
 
 [coverage:report]
 exclude_lines =

typings/flake8/__init__.pyi

@@ -2,8 +2,6 @@
 This type stub file was generated by pyright.
 """
 
-from __future__ import annotations
-
 import logging
 
 """Top-level module for Flake8.

typings/flake8/options/manager.pyi

@@ -1,13 +1,12 @@
 """
 This type stub file was generated by pyright.
+
 Generated for flake8 5, so OptionManager signature is incorrect for flake8 6
 """
 
-from __future__ import annotations
-
 import argparse
-from collections.abc import Mapping, Sequence
-from typing import Any, Callable
+from collections.abc import Callable, Mapping, Sequence
+from typing import Any
 
 from flake8.plugins.finder import Plugins
 
@@ -44,12 +43,12 @@ class Option:
         long_option_name: str | _ARG = ...,
         action: str | type[argparse.Action] | _ARG = ...,
         default: Any | _ARG = ...,
-        type: str | Callable[..., Any] | _ARG = ...,
+        type: str | Callable[..., Any] | _ARG = ...,  # noqa: A002
         dest: str | _ARG = ...,
         nargs: int | str | _ARG = ...,
         const: Any | _ARG = ...,
         choices: Sequence[Any] | _ARG = ...,
-        help: str | _ARG = ...,
+        help: str | _ARG = ...,  # noqa: A002
         metavar: str | _ARG = ...,
         callback: Callable[..., Any] | _ARG = ...,
         callback_args: Sequence[Any] | _ARG = ...,
@@ -125,7 +124,6 @@ class Option:
     def filtered_option_kwargs(self) -> dict[str, Any]:
         """Return any actually-specified arguments."""
         ...
-    def __repr__(self) -> str: ...
     def normalize(self, value: Any, *normalize_args: str) -> Any:
         """Normalize the value based on the option configuration."""
         ...