rename error codes to ASYNCxxx, introducing temp functions to pretend test files are renamed.

Author: jakkdl

README.md

@@ -24,47 +24,47 @@ pip install flake8-async
 
 ## List of warnings
 
-- **TRIO100**: A `with trio.fail_after(...):` or `with trio.move_on_after(...):`
+- **ASYNC100**: 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
+- **ASYNC101**: `yield` inside a nursery or cancel scope is only safe when implementing a context manager - otherwise, it breaks exception handling.
+- **ASYNC102**: 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`/`anyio` must be imported with `import trio`/`import anyio` 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`.
-- **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()`.
-- **TRIO117**: Don't raise or catch `trio.[NonBase]MultiError`, prefer `[exceptiongroup.]BaseExceptionGroup`. Even if Trio still raises `MultiError` for legacy code, it can be caught with `BaseExceptionGroup` so it's fully redundant.
-- **TRIO118**: Don't assign the value of `anyio.get_cancelled_exc_class()` to a variable, since that breaks linter checks and multi-backend programs.
+- **ASYNC103**: `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.
+- **ASYNC104**: `Cancelled` and `BaseException` must be re-raised - when a user tries to `return` or `raise` a different exception.
+- **ASYNC105**: Calling a trio async function without immediately `await`ing it.
+- **ASYNC106**: `trio`/`anyio` must be imported with `import trio`/`import anyio` for the linter to work.
+- **ASYNC107**: Renamed to ASYNC910
+- **ASYNC108**: Renamed to ASYNC911
+- **ASYNC109**: Async function definition with a `timeout` parameter - use `trio.[fail/move_on]_[after/at]` instead
+- **ASYNC110**: `while <condition>: await trio.sleep()` should be replaced by a `trio.Event`.
+- **ASYNC111**: 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.
+- **ASYNC112**: 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.
+- **ASYNC113**: Using `nursery.start_soon` in `__aenter__` doesn't wait for the task to begin. Consider replacing with `nursery.start`.
+- **ASYNC114**: Startable function (i.e. has a `task_status` keyword parameter) not in `--startable-in-context-manager` parameter list, please add it so ASYNC113 can catch errors when using it.
+- **ASYNC115**: Replace `trio.sleep(0)` with the more suggestive `trio.lowlevel.checkpoint()`.
+- **ASYNC116**: `trio.sleep()` with >24 hour interval should usually be `trio.sleep_forever()`.
+- **ASYNC117**: Don't raise or catch `trio.[NonBase]MultiError`, prefer `[exceptiongroup.]BaseExceptionGroup`. Even if Trio still raises `MultiError` for legacy code, it can be caught with `BaseExceptionGroup` so it's fully redundant.
+- **ASYNC118**: Don't assign the value of `anyio.get_cancelled_exc_class()` to a variable, since that breaks linter checks and multi-backend programs.
 
 ### Warnings for blocking sync calls in async functions
-- **TRIO200**: User-configured error for blocking sync calls in async functions. Does nothing by default, see [`trio200-blocking-calls`](#trio200-blocking-calls) for how to configure it.
-- **TRIO210**: Sync HTTP call in async function, use `httpx.AsyncClient`.
-- **TRIO211**: Likely sync HTTP call in async function, use `httpx.AsyncClient`. Looks for `urllib3` method calls on pool objects, but only matching on the method signature and not the object.
-- **TRIO212**: Blocking sync HTTP call on httpx object, use httpx.AsyncClient.
-- **TRIO220**: Sync process call in async function, use `await nursery.start(trio.run_process, ...)`.
-- **TRIO221**: Sync process call in async function, use `await trio.run_process(...)`.
-- **TRIO222**: Sync `os.*` call in async function, wrap in `await trio.to_thread.run_sync()`.
-- **TRIO230**: Sync IO call in async function, use `trio.open_file(...)`.
-- **TRIO231**: Sync IO call in async function, use `trio.wrap_file(...)`.
-- **TRIO232**: Blocking sync call on file object, wrap the file object in `trio.wrap_file()` to get an async file object.
-- **TRIO240**: Avoid using `os.path` in async functions, prefer using `trio.Path` objects.
+- **ASYNC200**: User-configured error for blocking sync calls in async functions. Does nothing by default, see [`trio200-blocking-calls`](#trio200-blocking-calls) for how to configure it.
+- **ASYNC210**: Sync HTTP call in async function, use `httpx.AsyncClient`.
+- **ASYNC211**: Likely sync HTTP call in async function, use `httpx.AsyncClient`. Looks for `urllib3` method calls on pool objects, but only matching on the method signature and not the object.
+- **ASYNC212**: Blocking sync HTTP call on httpx object, use httpx.AsyncClient.
+- **ASYNC220**: Sync process call in async function, use `await nursery.start(trio.run_process, ...)`.
+- **ASYNC221**: Sync process call in async function, use `await trio.run_process(...)`.
+- **ASYNC222**: Sync `os.*` call in async function, wrap in `await trio.to_thread.run_sync()`.
+- **ASYNC230**: Sync IO call in async function, use `trio.open_file(...)`.
+- **ASYNC231**: Sync IO call in async function, use `trio.wrap_file(...)`.
+- **ASYNC232**: Blocking sync call on file object, wrap the file object in `trio.wrap_file()` to get an async file object.
+- **ASYNC240**: Avoid using `os.path` in async functions, prefer using `trio.Path` objects.
 
 
 ### 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)
+- **ASYNC900**: Async generator without `@asynccontextmanager` not allowed.
+- **ASYNC910**: Exit or `return` from async function with no guaranteed checkpoint or exception since function definition.
+- **ASYNC911**: 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).
 
 ## Examples

flake8_trio/__init__.py

@@ -15,6 +15,7 @@
 import functools
 import keyword
 import os
+import re
 import subprocess
 import sys
 import tokenize
@@ -199,7 +200,7 @@ def add_options(option_manager: OptionManager | ArgumentParser):
             )
         else:  # if run as a flake8 plugin
             Plugin.standalone = False
-            # Disable TRIO9xx calls by default
+            # Disable ASYNC9xx calls by default
             option_manager.extend_default_ignore(default_disabled_error_codes)
             # add parameter to parse from flake8 config
             add_argument = functools.partial(  # type: ignore
@@ -209,7 +210,7 @@ def add_options(option_manager: OptionManager | ArgumentParser):
         add_argument(
             "--enable",
             type=comma_separated_list,
-            default="TRIO",
+            default="ASYNC",
             required=False,
             help=(
                 "Comma-separated list of error codes to enable, similar to flake8"
@@ -221,7 +222,7 @@ def add_options(option_manager: OptionManager | ArgumentParser):
         add_argument(
             "--disable",
             type=comma_separated_list,
-            default="TRIO9" if Plugin.standalone else "",
+            default="ASYNC9" if Plugin.standalone else "",
             required=False,
             help=(
                 "Comma-separated list of error codes to disable, similar to flake8"
@@ -253,7 +254,7 @@ def add_options(option_manager: OptionManager | ArgumentParser):
             required=False,
             type=comma_separated_list,
             help=(
-                "Comma-separated list of decorators to disable TRIO910 & TRIO911 "
+                "Comma-separated list of decorators to disable ASYNC910 & ASYNC911 "
                 "checkpoint warnings for. "
                 "Decorators can be dotted or not, as well as support * as a wildcard. "
                 "For example, ``--no-checkpoint-warning-decorators=app.route,"
@@ -266,7 +267,7 @@ def add_options(option_manager: OptionManager | ArgumentParser):
             default="",
             required=False,
             help=(
-                "Comma-separated list of method calls to additionally enable TRIO113 "
+                "Comma-separated list of method calls to additionally enable ASYNC113 "
                 "warnings for. Will also check for the pattern inside function calls. "
                 "Methods must be valid identifiers as per `str.isidientifier()` and "
                 "not reserved keywords. "
@@ -281,7 +282,7 @@ def add_options(option_manager: OptionManager | ArgumentParser):
             required=False,
             help=(
                 "Comma-separated list of key->value pairs, where key is a [dotted] "
-                "function that if found inside an async function will raise TRIO200, "
+                "function that if found inside an async function will raise ASYNC200, "
                 "suggesting it be replaced with {value}"
             ),
         )
@@ -313,8 +314,9 @@ def get_matching_codes(
             err_code
             for err_class in (*ERROR_CLASSES, *ERROR_CLASSES_CST)
             for err_code in err_class.error_codes  # type: ignore[attr-defined]
-            if len(err_code) == 7  # exclude e.g. TRIO103_anyio_trio
+            if re.match("ASYNC...", err_code)  # exclude e.g. ASYNC103_anyio_trio
         }
+        assert all_codes
 
         if options.autofix and not Plugin.standalone:
             print("Cannot autofix when run as a flake8 plugin.", file=sys.stderr)
@@ -328,8 +330,10 @@ def get_matching_codes(
         enabled_codes -= set(get_matching_codes(options.disable, enabled_codes))
 
         # if disable has default value, re-enable explicitly enabled codes
-        if options.disable == ["TRIO9"]:
-            enabled_codes.update(code for code in options.enable if len(code) == 7)
+        if options.disable == ["ASYNC9"]:
+            enabled_codes.update(
+                code for code in options.enable if re.match("ASYNC...", code)
+            )
 
         Plugin._options = Options(
             enabled_codes=enabled_codes,

flake8_trio/visitors/flake8triovisitor.py

@@ -20,6 +20,9 @@
         ast.expr, ast.stmt, ast.arg, ast.excepthandler, ast.alias, Statement
     ]
 
+# 8 == len('ASYNCxxx'), so alt messages raise the original code
+ERROR_CODE_LEN = 8
+
 
 class Flake8TrioVisitor(ast.NodeVisitor, ABC):
     # abstract attribute by not providing a value
@@ -98,13 +101,12 @@ def error(
             ), "No error code defined, but class has multiple codes"
             error_code = next(iter(self.error_codes))
         # don't emit an error if this code is disabled in a multi-code visitor
-        elif error_code[:7] not in self.options.enabled_codes:
+        elif error_code[:ERROR_CODE_LEN] not in self.options.enabled_codes:
             return
 
         self.__state.problems.append(
             Error(
-                # 7 == len('TRIO...'), so alt messages raise the original code
-                error_code[:7],
+                error_code[:ERROR_CODE_LEN],
                 node.lineno,
                 node.col_offset,
                 self.error_codes[error_code],
@@ -218,7 +220,7 @@ def error(
             error_code = next(iter(self.error_codes))
         # don't emit an error if this code is disabled in a multi-code visitor
         # TODO: write test for only one of 910/911 enabled/autofixed
-        elif error_code[:7] not in self.options.enabled_codes:
+        elif error_code[:ERROR_CODE_LEN] not in self.options.enabled_codes:
             return False  # pragma: no cover
 
         if self.is_noqa(node, error_code):
@@ -228,8 +230,7 @@ def error(
         pos = self.get_metadata(PositionProvider, node).start  # type: ignore
         self.__state.problems.append(
             Error(
-                # 7 == len('TRIO...'), so alt messages raise the original code
-                error_code[:7],
+                error_code[:ERROR_CODE_LEN],
                 pos.line,  # type: ignore
                 pos.column,  # type: ignore
                 self.error_codes[error_code],

flake8_trio/visitors/helpers.py

@@ -364,7 +364,7 @@ def get_comments(node: cst.CSTNode | Iterable[cst.CSTNode]) -> Iterator[cst.Empt
             yield from get_comments(n)
 
 
-# used in TRIO100
+# used in ASYNC100
 def flatten_preserving_comments(node: cst.BaseCompoundStatement):
     # add leading lines (comments and empty lines) for the node to be removed
     new_leading_lines = list(node.leading_lines)

flake8_trio/visitors/visitor100.py

@@ -1,4 +1,4 @@
-"""Contains visitor for TRIO100.
+"""Contains visitor for ASYNC100.
 
 A `with trio.fail_after(...):` or `with trio.move_on_after(...):`
 context does not contain any `await` statements.  This makes it pointless, as
@@ -28,7 +28,7 @@
 @error_class_cst
 class Visitor100_libcst(Flake8TrioVisitor_cst):
     error_codes: Mapping[str, str] = {
-        "TRIO100": (
+        "ASYNC100": (
             "{0}.{1} context contains no checkpoints, remove the context or add"
             " `await {0}.lowlevel.checkpoint()`."
         ),

flake8_trio/visitors/visitor101.py

@@ -1,4 +1,4 @@
-"""Contains visitor for TRIO101.
+"""Contains visitor for ASYNC101.
 
 `yield` inside a nursery or cancel scope is only safe when implementing a context manager
 - otherwise, it breaks exception handling.
@@ -25,7 +25,7 @@
 @error_class_cst
 class Visitor101(Flake8TrioVisitor_cst):
     error_codes: Mapping[str, str] = {
-        "TRIO101": (
+        "ASYNC101": (
             "`yield` inside a nursery or cancel scope is only safe when implementing "
             "a context manager - otherwise, it breaks exception handling."
         ),

flake8_trio/visitors/visitor102.py

@@ -19,7 +19,7 @@
 @error_class
 class Visitor102(Flake8TrioVisitor):
     error_codes: Mapping[str, str] = {
-        "TRIO102": (
+        "ASYNC102": (
             "await inside {0.name} on line {0.lineno} must have shielded cancel "
             "scope with a timeout."
         ),

flake8_trio/visitors/visitor103_104.py

@@ -17,7 +17,7 @@
 if TYPE_CHECKING:
     from collections.abc import Mapping
 
-_trio103_common_msg = "{} block with a code path that doesn't re-raise the error."
+_async103_common_msg = "{} block with a code path that doesn't re-raise the error."
 _suggestion = " Consider adding an `except {}: raise` before this exception handler."
 _suggestion_dict: dict[tuple[str, ...], str] = {
     ("anyio",): "anyio.get_cancelled_exc_class()",
@@ -26,12 +26,12 @@
 _suggestion_dict[("anyio", "trio")] = "[" + "|".join(_suggestion_dict.values()) + "]"
 
 _error_codes = {
-    "TRIO103": _trio103_common_msg,
-    "TRIO104": "Cancelled (and therefore BaseException) must be re-raised.",
+    "ASYNC103": _async103_common_msg,
+    "ASYNC104": "Cancelled (and therefore BaseException) must be re-raised.",
 }
 for poss_library in _suggestion_dict:
-    _error_codes[f"TRIO103_{'_'.join(poss_library)}"] = (
-        _trio103_common_msg + _suggestion.format(_suggestion_dict[poss_library])
+    _error_codes[f"ASYNC103_{'_'.join(poss_library)}"] = (
+        _async103_common_msg + _suggestion.format(_suggestion_dict[poss_library])
     )
 
 
@@ -61,21 +61,21 @@ def visit_ExceptHandler(self, node: ast.ExceptHandler):
         # If previous excepts have handled trio.Cancelled, don't do anything - namely
         # don't set self.unraised (so 104 isn't triggered) nor check for 103.
         if marker.name == "trio.Cancelled":
-            error_code = "TRIO103"
+            error_code = "ASYNC103"
             self.cancelled_caught.add("trio")
         elif marker.name in (
             "anyio.get_cancelled_exc_class()",
             "get_cancelled_exc_class()",
         ):
-            error_code = "TRIO103"
+            error_code = "ASYNC103"
             self.cancelled_caught.add("anyio")
         else:
             if self.cancelled_caught:
                 return
             if len(self.library) < 2:
-                error_code = f"TRIO103_{self.library_str}"
+                error_code = f"ASYNC103_{self.library_str}"
             else:
-                error_code = f"TRIO103_{'_'.join(sorted(self.library))}"
+                error_code = f"ASYNC103_{'_'.join(sorted(self.library))}"
             self.cancelled_caught.update("trio", "anyio")
 
         # Don't save the state of cancelled_caught, that's handled in Try and would
@@ -117,15 +117,15 @@ def visit_Raise(self, node: ast.Raise):
             and node.exc is not None
             and not (isinstance(node.exc, ast.Name) and node.exc.id == self.except_name)
         ):
-            self.error(node, error_code="TRIO104")
+            self.error(node, error_code="ASYNC104")
 
         # treat it as safe regardless, to avoid unnecessary error messages.
         self.unraised = False
 
     def visit_Return(self, node: ast.Return | ast.Yield):
         if self.unraised:
             # Error: must re-raise
-            self.error(node, error_code="TRIO104")
+            self.error(node, error_code="ASYNC104")
 
     visit_Yield = visit_Return
 
@@ -209,10 +209,10 @@ def visit_For(self, node: ast.For | ast.While):
 
     def visit_Break(self, node: ast.Break):
         if self.unraised and self.loop_depth == 0:
-            self.error(node, error_code="TRIO104")
+            self.error(node, error_code="ASYNC104")
         self.unraised_break |= self.unraised
 
     def visit_Continue(self, node: ast.Continue):
         if self.unraised and self.loop_depth == 0:
-            self.error(node, error_code="TRIO104")
+            self.error(node, error_code="ASYNC104")
         self.unraised_continue |= self.unraised