PyPI / ruff / 0.17.1

ruff 0.17.1

Source
https://github.com/astral-sh/ruff
Tag scanned
0.17.1
Compared with
0.17.0 (1 signals introduced since)
Files
6737 scanned, 4449 skipped (binary, oversized, or unrecognised)
Signals
0 critical · 6 warn · 604 info
Scan time
111.3 s
LLM review
Reviewed by claude-haiku-5-5 (Anthropic): the 126 most severe of 132 warn and critical signals (126 with a verdict); 126 demoted to info. The rest are unreviewed.
Disclude version
4.1.0
Scanned (UTC)
2026-10-22 00:57

Signals

Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.

  1. line length 2400 characters (raw pass, confidence 0.65)

    ERROR pandas/io/parsers/readers.py:914:5-15: Implementation signature `(filepath_or_buffer: PathLike[str] | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | str, *, sep: _NoDefault | str | None = _NoDefault.no_default, delimiter: _NoDefault | str | None = None, header: Literal['infer'] | Sequence[int] | int | None = 'infer'
  2. line length 2412 characters (raw pass, confidence 0.65)

    ERROR pandas/io/parsers/readers.py:924:5-15: Implementation signature `(filepath_or_buffer: PathLike[str] | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | str, *, sep: _NoDefault | str | None = _NoDefault.no_default, delimiter: _NoDefault | str | None = None, header: Literal['infer'] | Sequence[int] | int | None = 'infer'
  3. line length 2425 characters (raw pass, confidence 0.65)

    ERROR pandas/io/parsers/readers.py:934:5-15: Implementation signature `(filepath_or_buffer: PathLike[str] | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | str, *, sep: _NoDefault | str | None = _NoDefault.no_default, delimiter: _NoDefault | str | None = None, header: Literal['infer'] | Sequence[int] | int | None = 'infer'
  4. line length 8782 characters (raw pass, confidence 0.65)

    pandas/core/array_algos/datetimelike_accumulations.py:38:22: error[invalid-argument-type] Method `__getitem__` of type `bound method dict[(bound method _UFunc_Nin2_Nout1[Literal["maximum"], Literal[21], None].accumulate(array: _Buffer | _SupportsArray[dtype[Any]] | _NestedSequence[_SupportsArray[dtype[Any]]] | ... omit
  5. line length 20747 characters (raw pass, confidence 0.65)

    pandas/core/array_algos/masked_accumulations.py:56:22: error[invalid-argument-type] Method `__getitem__` of type `bound method dict[Overload[(a: _SupportsArray[dtype[numpy.bool[builtins.bool]]] | _NestedSequence[_SupportsArray[dtype[numpy.bool[builtins.bool]]]] | builtins.bool | _NestedSequence[builtins.bool], axis: Su
  6. line length 4221 characters (raw pass, confidence 0.65)

    torch/_dynamo/polyfills/itertools.py:314:1: error[invalid-argument-type] Argument is incorrect: Expected `Overload[[_T1, _T_co](iter1: Iterable[_T1], /, *, fillvalue: object = None) -> zip_longest[tuple[_T1]] | zip_longest[tuple[_T1@__new__ | Any, _T2@__new__ | Any]] | zip_longest[tuple[_T1@__new__ | _T@__new__, _T2@__
  7. info warn → info by review dynamic-execution README.md:153:1 new in this release

    [embedded bash] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)

    # For a specific version.
    curl -LsSf https://astral.sh/ruff/0.17.1/install.sh | sh
    powershell -c "irm https://astral.sh/ruff/0.17.1/install.ps1 | iex"
    likely benign LLM, confidence 0.85 README instructions for a pinned ruff version via curl-to-sh and PowerShell irm|iex.
    Reasoning

    Pinned-version installer from the same official astral.sh domain, plus a PowerShell irm|iex line for Windows. This is standard, documented installation for the project.

  8. info warn → info by review dynamic-execution .github/workflows/build-binaries.yml:73:13

    [embedded bash] command name is a variable (`$MODULE_NAME`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)

                pip install /dist/"${PACKAGE_NAME}"-*.tar.gz --force-reinstall
                "${MODULE_NAME}" --help
                python -m "${MODULE_NAME}" --help
    likely benign LLM, confidence 0.85 CI step runs the built package's module name from an env variable to smoke-test the install.
    Reasoning

    Shell variable used as command name in a CI smoke test; the value comes from workflow env set by the repo itself. Standard release-workflow pattern, not malicious.

  9. info critical → info by review dynamic-execution .github/workflows/build-binaries.yml:252:11

    [embedded bash] command name is a variable (`$LLVM_READOBJ`) and `LLVM_READOBJ` is assigned the output of a command — executed command determined at runtime (ast pass, confidence 0.90)

              IMPORTS_FILE="$RUNNER_TEMP/ruff-coff-imports.txt"
              "$LLVM_READOBJ" --coff-imports "target/${{ matrix.platform.target }}/release/ruff.exe" > "$IMPORTS_FILE"
    
              if grep -Eiq 'vcruntime[[:digit:]_]*\.dll|api-ms-win-crt-' "$IMPORTS_FILE"; then
    likely benign LLM, confidence 0.80 Windows build step locates llvm-readobj and inspects ruff.exe's COFF imports.
    Reasoning

    LLVM_READOBJ is assigned from tool discovery (llvm-readobj path) and used to inspect PE imports of the built ruff.exe for a vcruntime check. Runtime-determined command but consistent with build tooling; no download-and-execute or obfuscation visible.

  10. info warn → info by review dynamic-execution .github/workflows/build-binaries.yml:263:11

    [embedded bash] command name is a variable (`$MODULE_NAME`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)

              python -m pip install dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
              "${MODULE_NAME}" --help
              python -m "${MODULE_NAME}" --help
    likely benign LLM, confidence 0.85 CI smoke test runs the installed module's help command using a variable name.
    Reasoning

    Same benign smoke-test pattern with MODULE_NAME from workflow env, installing the freshly built wheel.

  11. info warn → info by review dynamic-execution .github/workflows/build-binaries.yml:332:13

    [embedded bash] command name is a variable (`$MODULE_NAME`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)

                pip install /dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
                "${MODULE_NAME}" --help
                python -m "${MODULE_NAME}" --help
    likely benign LLM, confidence 0.85 CI job installs the built package and runs its help command via a variable.
    Reasoning

    Same benign install-and-smoke-test pattern repeated across platform jobs.

  12. info warn → info by review dynamic-execution .github/workflows/build-binaries.yml:405:13

    [embedded bash] command name is a variable (`$MODULE_NAME`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)

                pip install /dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
                "${MODULE_NAME}" --help
                python -m "${MODULE_NAME}" --help
    likely benign LLM, confidence 0.85 CI job installs the built package and runs its help command via a variable.
    Reasoning

    Same benign install-and-smoke-test pattern.

  13. info warn → info by review dynamic-execution .github/workflows/build-binaries.yml:560:13

    [embedded bash] command name is a variable (`$MODULE_NAME`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)

                .venv/bin/pip3 install "${PACKAGE_NAME}" --no-index --find-links /dist --force-reinstall
                .venv/bin/"${MODULE_NAME}" --help
    likely benign LLM, confidence 0.85 CI job runs the venv-installed entry point's help command via a variable.
    Reasoning

    Same benign pattern invoking a venv-installed entry point by configured name.

  14. info warn → info by review dynamic-execution .github/workflows/build-binaries.yml:629:13

    [embedded bash] command name is a variable (`$MODULE_NAME`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)

                .venv/bin/pip3 install "${PACKAGE_NAME}" --no-index --find-links /dist --force-reinstall
                .venv/bin/"${MODULE_NAME}" --help
    likely benign LLM, confidence 0.85 CI job runs the venv-installed entry point's help command via a variable.
    Reasoning

    Same benign pattern as the other smoke tests.

  15. info warn → info by review dynamic-execution .github/workflows/ci.yaml:385:11

    [embedded bash] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)

              curl --proto '=https' --tlsv1.2 -LsSf \
                "https://github.com/astral-sh/hawk/releases/download/${HAWK_VERSION}/cargo-hawk-installer.sh" | sh
    likely benign LLM, confidence 0.75 CI step installs the pinned cargo-hawk tool by piping its release installer script to sh.
    Reasoning

    Pipes a curl download from the official astral-sh GitHub release, pinned by version variable, into sh. Piping an installer script to sh is a risky practice but it is from the project's own release host over HTTPS with TLS 1.2 enforced; common for installer bootstraps in CI.

  16. info identifier-low-length .github/workflows/ci.yaml:478:14

    [embedded bash] 14 of 35 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  17. line length 613 characters (raw pass, confidence 0.50)

        if: ${{ always() && needs.plan.result == 'success' && needs.plan.outputs.publishing == 'true' && needs.sign-release-binaries.result == 'success' && needs.generate-checksum-manifest.result == 'success' && (needs.build-global-artifacts.result == 'skipped' || needs.build-global-artifacts.result == 'success') && (needs
  18. info warn → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:358:11

    [embedded bash] command name is a variable () not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)

              fi
              "${python[@]}" -m pip install wheels/"$TARGET"/ruff-*.whl --force-reinstall --no-index --no-deps
              ruff --version
              ruff --help
    likely benign LLM, confidence 0.85 Release workflow installs the signed ruff wheel and runs version and help checks.
    Reasoning

    Array-expanded python command used to install the signed wheel and run ruff; the python array is set earlier in the same workflow. Benign release verification.

  19. info warn → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:361:11

    [embedded bash] command name is a variable () not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)

              ruff --help
              "${python[@]}" -m ruff --help
    likely benign LLM, confidence 0.85 Release workflow runs ruff module help check via the python array.
    Reasoning

    Benign help check using the locally defined python array.

  20. info warn → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:418:11

    [embedded bash] command name is a variable (`$ErrorActionPreference`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)

              $ErrorActionPreference = 'Stop'
              $wheel = Get-ChildItem -LiteralPath "wheels/$env:TARGET" -Filter 'ruff-*.whl'
              if (@($wheel).Count -ne 1) { throw 'Expected exactly one signed wheel' }
    dismissed LLM, confidence 0.85 PowerShell step sets ErrorActionPreference to Stop before locating the signed wheel.
    Reasoning

    PowerShell preference variable assignment, a standard setting, flagged only because the scanner misparsed it as a command.

  21. info warn → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:419:11

    [embedded bash] command name is a variable (`$wheel`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)

              $ErrorActionPreference = 'Stop'
              $wheel = Get-ChildItem -LiteralPath "wheels/$env:TARGET" -Filter 'ruff-*.whl'
              if (@($wheel).Count -ne 1) { throw 'Expected exactly one signed wheel' }
              python -m pip install $wheel.FullName --force-reinstall --no-index --no-deps
    likely benign LLM, confidence 0.85 PowerShell step locates the single signed ruff wheel and installs it with pip.
    Reasoning

    $wheel is a result of Get-ChildItem for the signed wheel, validated to exactly one match before pip install. Benign, parser artifact flagged as command invocation.

  22. info warn → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:420:17

    [embedded bash] command name is a variable (`$wheel`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)

              $wheel = Get-ChildItem -LiteralPath "wheels/$env:TARGET" -Filter 'ruff-*.whl'
              if (@($wheel).Count -ne 1) { throw 'Expected exactly one signed wheel' }
              python -m pip install $wheel.FullName --force-reinstall --no-index --no-deps
    likely benign LLM, confidence 0.90 PowerShell step in a release workflow that installs a signed ruff wheel.
    Reasoning

    The block is PowerShell in a workflow (Get-ChildItem, $LASTEXITCODE, throw), not bash. The scanner misread PowerShell variables as command names. It installs a signed wheel and checks the exit code, which is a normal release-verification step.

  23. info warn → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:422:15

    [embedded bash] command name is a variable (`$LASTEXITCODE`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)

              python -m pip install $wheel.FullName --force-reinstall --no-index --no-deps
              if ($LASTEXITCODE -ne 0) { throw 'Signed wheel installation failed' }
              ruff --version
              if ($LASTEXITCODE -ne 0) { throw 'Signed executable failed' }
    likely benign LLM, confidence 0.90 Exit-code check after installing the signed wheel in a PowerShell release step.
    Reasoning

    Same PowerShell block; $LASTEXITCODE is a PowerShell automatic variable checked after the install. The flag comes from parsing PowerShell as bash.

  24. info warn → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:424:15

    [embedded bash] command name is a variable (`$LASTEXITCODE`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)

              ruff --version
              if ($LASTEXITCODE -ne 0) { throw 'Signed executable failed' }
              ruff --help
              if ($LASTEXITCODE -ne 0) { throw 'Signed executable help failed' }
    likely benign LLM, confidence 0.90 Smoke test of the signed ruff executable in a release workflow.
    Reasoning

    Same PowerShell pattern: running the signed ruff executable and checking $LASTEXITCODE. Nothing suspicious is shown.

  25. info warn → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:426:15

    [embedded bash] command name is a variable (`$LASTEXITCODE`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)

              ruff --help
              if ($LASTEXITCODE -ne 0) { throw 'Signed executable help failed' }
              python -m ruff --help
              if ($LASTEXITCODE -ne 0) { throw 'Signed module invocation failed' }
    likely benign LLM, confidence 0.90 Smoke test of python -m ruff in a release workflow.
    Reasoning

    Same PowerShell pattern: testing that the module invocation works. This is a verification step with no network fetch or obfuscation.

  26. info warn → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:428:15

    [embedded bash] command name is a variable (`$LASTEXITCODE`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)

              python -m ruff --help
              if ($LASTEXITCODE -ne 0) { throw 'Signed module invocation failed' }
    likely benign LLM, confidence 0.90 Exit-code check after python -m ruff in a release workflow.
    Reasoning

    Same PowerShell pattern: an exit-code check after module invocation. Benign release verification.

  27. info warn → info by review dynamic-execution CONTRIBUTING.md:484:19

    [markup prose] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)

    1. Install `uv`: `curl -LsSf https://astral.sh/uv/install.sh | sh`
    likely benign LLM, confidence 0.85 Documentation line telling contributors to install uv via the official curl-to-sh script.
    Reasoning

    This is the official uv installer one-liner shown in contributor docs. curl | sh is a common install pattern. It points to the project's own domain, and no obfuscation is present.

  28. info warn → info by review dynamic-execution README.md:147:1

    [embedded bash] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)

    # On macOS and Linux.
    curl -LsSf https://astral.sh/ruff/install.sh | sh
    
    # On Windows.
    likely benign LLM, confidence 0.85 README install instructions for ruff via the official astral.sh curl-to-sh script.
    Reasoning

    This is the documented official ruff installer from astral.sh, matching the project's install instructions. The pipe-to-shell pattern is a known convention with no hidden payload.

  29. line length 555 characters (raw pass, confidence 0.50)

    - Add fix safety sections (`ASYNC116`, `FLY002`, `D200`, `RUF005`, `RUF017`, `RUF027`, `RUF028`, `RUF057`) ([#17497]https://github.com/astral-sh/ruff/pull/17497, [#17496]https://github.com/astral-sh/ruff/pull/17496, [#17502]https://github.com/astral-sh/ruff/pull/17502, [#17484](https://github.com/astral-sh/ruff/p
  30. line length 606 characters (raw pass, confidence 0.50)

        - \[`refurb`\] [`FURB105`](https://github.com/astral-sh/ruff/pull/22767), [`FURB116`](https://github.com/astral-sh/ruff/pull/22681), [`FURB136`](https://github.com/astral-sh/ruff/pull/22680), [`FURB140`](https://github.com/astral-sh/ruff/pull/22679), [`FURB145`](https://github.com/astral-sh/ruff/pull/22670), [`FURB
  31. compression ratio 0.847 is >2σ above file mean 0.683 (raw pass, confidence 0.50)

                err.to_string(),
                "Unknown HTML comment `snpshotttt-digggggnosstic` -- possibly a typo? \
                (Add to `HTML_COMMENT_ALLOWLIST` if this is a false positive)",
            );
  32. compression ratio 0.714 is >2σ above file mean 0.620 (raw pass, confidence 0.50)

                    warn_user_once!(
                        "The isort option `isort.lines-between-types` with a value greater than 1 is incompatible with the formatter. To avoid unexpected behavior, we recommend setting the option to one of: `1` or `0` (default)."
                    );
                }
  33. info whitespace-anomaly crates/ruff/tests/cli/lint.rs:17:1

    file mixes tab and space indentation (2 tab-indented and 3800 space-indented lines) (raw pass, confidence 0.40)

    impl CliTest {
        fn check_command(&self) -> Command {
            let mut command = self.command();
            command.args(STDIN_BASE_OPTIONS);
  34. file mixes tab and space indentation (39 tab-indented and 40 space-indented lines) (raw pass, confidence 0.40)

    use annotate_snippets::{
        AnnotationKind, Level, Origin, Patch, Renderer, Snippet, renderer::DecorStyle,
    };
  35. identifier `Aͫ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

      |  ___________^
    4 | |     { name = "Z͑ͫ̓ͪ̂ͫ̽⟨U+034F⟩̴̙̤̞͉͚̯̞̠͍A̴̵̜̰͔ͫ͗͢L̠ͨͧͩ͘G̴̻͈͍͔̹̑͗̎̅͛́Ǫ̵̹̻̝̳͂̌̌͘", email = 1 }
    5 | | ]
      | |_^ annotation
  36. identifier `Lͨͧͩ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

      |  ___________^
    4 | |     { name = "Z͑ͫ̓ͪ̂ͫ̽⟨U+034F⟩̴̙̤̞͉͚̯̞̠͍A̴̵̜̰͔ͫ͗͢L̠ͨͧͩ͘G̴̻͈͍͔̹̑͗̎̅͛́Ǫ̵̹̻̝̳͂̌̌͘", email = 1 }
    5 | | ]
      | |_^ annotation
  37. identifier `Aͫ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

      │ ┏━━━━━━━━━━━┛
    4 │ ┃     { name = "Z͑ͫ̓ͪ̂ͫ̽⟨U+034F⟩̴̙̤̞͉͚̯̞̠͍A̴̵̜̰͔ͫ͗͢L̠ͨͧͩ͘G̴̻͈͍͔̹̑͗̎̅͛́Ǫ̵̹̻̝̳͂̌̌͘", email = 1 }
    5 │ ┃ ]
      ╰╴┗━┛ annotation
  38. identifier `Lͨͧͩ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

      │ ┏━━━━━━━━━━━┛
    4 │ ┃     { name = "Z͑ͫ̓ͪ̂ͫ̽⟨U+034F⟩̴̙̤̞͉͚̯̞̠͍A̴̵̜̰͔ͫ͗͢L̠ͨͧͩ͘G̴̻͈͍͔̹̑͗̎̅͛́Ǫ̵̹̻̝̳͂̌̌͘", email = 1 }
    5 │ ┃ ]
      ╰╴┗━┛ annotation
  39. identifier `Ӻi` mixes scripts: Cyrillic + Latin (in string/comment) (raw pass, confidence 0.40)

    ��|�\u{0002}!5�cc\u{0015}\u{0002}�Ӻi��WWj�ȥ�'�}�\u{0012}�J�ȉ��W�\u{001e}O�@����\u{001c}w�V���LO����\u{0014}[ \u{0003}_�'���SQ�~ذ��ų&��-\t��lN~��!@␌ _#���kQ��h⟨U+E1C5⟩�⟨U+F3C1⟩\u{001d}�:�\u{001c}\u{0007}�";
  40. identifier `Ӻi` mixes scripts: Cyrillic + Latin (in string/comment) (raw pass, confidence 0.40)

      |
    1 | �|�␂!5�cc␕␂�Ӻi��WWj�ȥ�'�}�␒�J�ȉ��W�␞O�@����␜w�V���LO����␔[ ␃_�'���SQ�~ذ��ų&��-    ��lN~��!@␌ _#���kQ��h⟨U+E1C5⟩�⟨U+F3C1⟩␝�:�␜␇�
      | ^
  41. identifier `Ӻi` mixes scripts: Cyrillic + Latin (in string/comment) (raw pass, confidence 0.40)

      │
    1 │ �|�␂!5�cc␕␂�Ӻi��WWj�ȥ�'�}�␒�J�ȉ��W�␞O�@����␜w�V���LO����␔[ ␃_�'���SQ�~ذ��ų&��-    ��lN~��!@␌ _#���kQ��h⟨U+E1C5⟩�⟨U+F3C1⟩␝�:�␜␇�
      │ ━
  42. file mixes tab and space indentation (1 tab-indented and 3952 space-indented lines) (raw pass, confidence 0.40)

    fn ends_on_col0() {
        let source = r#"
    fn foo() {
    }
  43. info warn → info by review whitespace-anomaly crates/ruff_annotate_snippets/tests/rustc_tests.rs:4533:3

    invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)

        let s = c"foo\
      ⟨U+00A0⟩          bar
                 ";
        //~^^^ WARNING whitespace symbol '\u{a0}' is not skipped
    dismissed LLM, confidence 0.90 Rust test fixture that deliberately contains a non-breaking space to check whitespace diagnostics.
    Reasoning

    The NBSP is inside a test string literal and the adjacent comment expects a WARNING for '\u{a0}'. It is a deliberate test case for whitespace handling, not code that hides anything.

  44. file mixes tab and space indentation (2 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)

    def foo(x, y, z):
        content = 1 # print('hello')
        print(x, y, z)
  45. info critical → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_async/ASYNC22x.py:73:5

    `os.spawnl` with a non-literal binary path — runtime-determined process spawn (ast pass, confidence 0.85)

        # if mode is given, and is not os.P_WAIT: ASYNC220
        os.spawnl(os.P_NOWAIT)  # ASYNC220
        os.spawnl(P_NOWAIT)  # ASYNC220
        os.spawnl(mode=os.P_NOWAIT)  # ASYNC220
    dismissed LLM, confidence 0.93 Linter test case calling os.spawnl with a P_NOWAIT mode, annotated with the expected rule code.
    Reasoning

    This is a linter test fixture. The os.spawnl calls exist to trigger rule ASYNC220 and carry matching expectation comments. The flagged call is test input, not runtime execution.

  46. info critical → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_async/ASYNC22x.py:74:5

    `os.spawnl` with a non-literal binary path — runtime-determined process spawn (ast pass, confidence 0.85)

        os.spawnl(os.P_NOWAIT)  # ASYNC220
        os.spawnl(P_NOWAIT)  # ASYNC220
        os.spawnl(mode=os.P_NOWAIT)  # ASYNC220
        os.spawnl(mode=P_NOWAIT)  # ASYNC220
    dismissed LLM, confidence 0.93 Linter test case for os.spawnl with mode arguments, expecting ASYNC220.
    Reasoning

    Same linter test fixture with ASYNC220 expectation comments. The spawn calls are inputs for static-analysis tests.

  47. info critical → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_async/ASYNC22x.py:81:5

    `os.spawnl` with a non-literal binary path — runtime-determined process spawn (ast pass, confidence 0.85)

        # if it is P_WAIT, ASYNC221
        os.spawnl(P_WAIT)  # ASYNC221
        os.spawnl(mode=os.P_WAIT)  # ASYNC221
        os.spawnl(mode=P_WAIT)  # ASYNC221
    dismissed LLM, confidence 0.93 Linter test case for os.spawnl with P_WAIT mode, expecting ASYNC221.
    Reasoning

    Linter test fixture for ASYNC221 with explicit expectation comments. The os.spawnl calls only exercise the rule's detection logic.

  48. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_async/ASYNC22x.py:86:5

    `os.spawnl` called with a literal binary path (ast pass, confidence 0.70)

        # other weird cases: ASYNC220
        os.spawnl(0)  # ASYNC220
        os.spawnl(1)  # ASYNC220
        os.spawnl(foo())  # ASYNC220
    dismissed LLM, confidence 0.92 Linter test case covering unusual os.spawnl arguments, expecting ASYNC220.
    Reasoning

    Linter test fixture with literal and call arguments to os.spawnl, marked with ASYNC220 expectations. It is a rule-coverage case and not a real spawn.

  49. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_async/ASYNC22x.py:87:5

    `os.spawnl` called with a literal binary path (ast pass, confidence 0.70)

        os.spawnl(0)  # ASYNC220
        os.spawnl(1)  # ASYNC220
        os.spawnl(foo())  # ASYNC220
    likely benign LLM, confidence 0.90 Test fixture calling os.spawnl to exercise the ASYNC220 lint rule.
    Reasoning

    This is a linter test fixture (ruff) exercising os.spawnl detection with literal and dynamic arguments; the calls are inert test cases, not malicious.

  50. info critical → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_async/ASYNC22x.py:88:5

    `os.spawnl` with a non-literal binary path — runtime-determined process spawn (ast pass, confidence 0.85)

        os.spawnl(1)  # ASYNC220
        os.spawnl(foo())  # ASYNC220
    
        # ASYNC222
    likely benign LLM, confidence 0.90 Test fixture containing os.spawnl with a non-literal path to exercise lint rules.
    Reasoning

    The critical severity is driven by a non-literal argument, but the file is a ruff linter test fixture with commented expectations; the call is never meant to run.

  51. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S605.py:8:1

    `os.system` called with a literal shell command (ast pass, confidence 0.70)

    # Check all shell functions.
    os.system("true")
    os.popen("true")
    os.popen2("true")
    likely benign LLM, confidence 0.92 Test fixture calling os.system and os.popen with literal commands.
    Reasoning

    Ruff's flake8-bandit S605 test fixture enumerating shell-invoking functions with literal arguments; benign test data.

  52. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S605.py:9:1

    `os.popen` called with a literal shell command (ast pass, confidence 0.70)

    os.system("true")
    os.popen("true")
    os.popen2("true")
    os.popen3("true")
    likely benign LLM, confidence 0.92 Test fixture calling os.popen with a literal command.
    Reasoning

    Same S605 bandit test fixture; literal os.popen call exists to test detection rules.

  53. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S605.py:20:1

    `subprocess.getoutput` called with a literal shell command (ast pass, confidence 0.70)

    commands.getstatusoutput("true")
    subprocess.getoutput("true")
    subprocess.getstatusoutput("true")
    likely benign LLM, confidence 0.92 Test fixture calling subprocess.getoutput with a literal command.
    Reasoning

    Bandit rule test fixture for subprocess shell helpers with literal strings; no malicious behaviour.

  54. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S605.py:21:1

    `subprocess.getstatusoutput` called with a literal shell command (ast pass, confidence 0.70)

    subprocess.getoutput("true")
    subprocess.getstatusoutput("true")
    likely benign LLM, confidence 0.92 Test fixture calling subprocess.getstatusoutput with a literal command.
    Reasoning

    Bandit rule test fixture for subprocess shell helpers; literal arguments in a linter test.

  55. info critical → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S605.py:26:1

    `os.system` called on a non-literal command — runtime-determined shell invocation (ast pass, confidence 0.85)

    var_string = "true"
    os.system(var_string)
    os.system([var_string])
    os.system([var_string, ""])
    likely benign LLM, confidence 0.90 Test fixture calling os.system with variable arguments.
    Reasoning

    Non-literal os.system calls appear in a ruff S605 test fixture to check that dynamic commands are flagged; not deployed code.

  56. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S605.py:27:1

    `os.system` called with a literal shell command (ast pass, confidence 0.70)

    os.system(var_string)
    os.system([var_string])
    os.system([var_string, ""])
    likely benign LLM, confidence 0.92 Test fixture calling os.system with variable and list arguments.
    Reasoning

    Linter fixture repeating os.system variants to test rule coverage.

  57. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S605.py:28:1

    `os.system` called with a literal shell command (ast pass, confidence 0.70)

    os.system([var_string])
    os.system([var_string, ""])
    likely benign LLM, confidence 0.92 Test fixture calling os.system with list arguments.
    Reasoning

    Linter fixture for os.system argument shapes; benign test code.

  58. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S606.py:12:1

    `os.spawnl` called with a literal binary path (ast pass, confidence 0.70)

    os.execvpe("true")
    os.spawnl("true")
    os.spawnle("true")
    os.spawnlp("true")
    likely benign LLM, confidence 0.92 Test fixture calling os.execvpe with a literal path.
    Reasoning

    Bandit S606 test fixture listing os.spawn-family calls with literal strings; benign test data.

  59. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S606.py:13:1

    `os.spawnle` called with a literal binary path (ast pass, confidence 0.70)

    os.spawnl("true")
    os.spawnle("true")
    os.spawnlp("true")
    os.spawnlpe("true")
    likely benign LLM, confidence 0.92 Test fixture calling os.spawnle with a literal path.
    Reasoning

    S606 linter test fixture; no real spawn behaviour of concern.

  60. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S606.py:14:1

    `os.spawnlp` called with a literal binary path (ast pass, confidence 0.70)

    os.spawnle("true")
    os.spawnlp("true")
    os.spawnlpe("true")
    os.spawnv("true")
    likely benign LLM, confidence 0.92 Test fixture calling os.spawnlp with a literal path.
    Reasoning

    S606 linter test fixture enumerating spawn functions; benign.

  61. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S606.py:15:1

    `os.spawnlpe` called with a literal binary path (ast pass, confidence 0.70)

    os.spawnlp("true")
    os.spawnlpe("true")
    os.spawnv("true")
    os.spawnve("true")
    likely benign LLM, confidence 0.92 Test fixture calling os.spawnlpe with a literal path.
    Reasoning

    S606 linter test fixture; benign test code.

  62. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S606.py:16:1

    `os.spawnv` called with a literal binary path (ast pass, confidence 0.70)

    os.spawnlpe("true")
    os.spawnv("true")
    os.spawnve("true")
    os.spawnvp("true")
    likely benign LLM, confidence 0.92 Test fixture calling os.spawnv with a literal path.
    Reasoning

    S606 linter test fixture; benign test code.

  63. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S606.py:17:1

    `os.spawnve` called with a literal binary path (ast pass, confidence 0.70)

    os.spawnv("true")
    os.spawnve("true")
    os.spawnvp("true")
    os.spawnvpe("true")
    likely benign LLM, confidence 0.92 Test fixture calling os.spawnve with a literal path.
    Reasoning

    S606 linter test fixture; benign test code.

  64. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S606.py:18:1

    `os.spawnvp` called with a literal binary path (ast pass, confidence 0.70)

    os.spawnve("true")
    os.spawnvp("true")
    os.spawnvpe("true")
    os.startfile("true")
    likely benign LLM, confidence 0.92 Test fixture calling os.spawnvp with a literal path.
    Reasoning

    S606 linter test fixture; benign test code.

  65. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S606.py:19:1

    `os.spawnvpe` called with a literal binary path (ast pass, confidence 0.70)

    os.spawnvp("true")
    os.spawnvpe("true")
    os.startfile("true")
    likely benign LLM, confidence 0.92 Test fixture calling os.spawnvpe with a literal path.
    Reasoning

    S606 linter test fixture; benign test code.

  66. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:9:1

    `os.system` called with a literal shell command (ast pass, confidence 0.70)

    subprocess.run("true")
    os.system("true")
    os.popen("true")
    os.popen2("true")
    dismissed LLM, confidence 0.97 Test fixture calling os.system with a literal harmless command "true".
    Reasoning

    The file is a test fixture for ruff's bandit S607 rule, with a regression reference to a ruff issue. The literal "true" command is a harmless placeholder used to exercise the linter, not a payload.

  67. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:10:1

    `os.popen` called with a literal shell command (ast pass, confidence 0.70)

    os.system("true")
    os.popen("true")
    os.popen2("true")
    os.popen3("true")
    dismissed LLM, confidence 0.97 Test fixture calling os.popen with a literal harmless command "true".
    Reasoning

    This is a linter test fixture for the S607 rule. The os.popen call uses the literal placeholder "true", so it is a legitimate pattern in a test file.

  68. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:29:1

    `os.spawnl` called with a literal binary path (ast pass, confidence 0.70)

    os.execvpe("true")
    os.spawnl("true")
    os.spawnle("true")
    os.spawnlp("true")
    dismissed LLM, confidence 0.97 Test fixture calling os.spawnl with a literal placeholder binary path.
    Reasoning

    Part of the S607 test fixture exercising os.spawn* variants with a placeholder literal. No obfuscation or malicious intent is present.

  69. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:30:1

    `os.spawnle` called with a literal binary path (ast pass, confidence 0.70)

    os.spawnl("true")
    os.spawnle("true")
    os.spawnlp("true")
    os.spawnlpe("true")
    dismissed LLM, confidence 0.97 Test fixture calling os.spawnle with a literal placeholder binary path.
    Reasoning

    Part of the S607 test fixture exercising os.spawn* variants with a placeholder literal. No obfuscation or malicious intent is present.

  70. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:31:1

    `os.spawnlp` called with a literal binary path (ast pass, confidence 0.70)

    os.spawnle("true")
    os.spawnlp("true")
    os.spawnlpe("true")
    os.spawnv("true")
    dismissed LLM, confidence 0.97 Test fixture calling os.spawnlp with a literal placeholder binary path.
    Reasoning

    Part of the S607 test fixture exercising os.spawn* variants with a placeholder literal. No obfuscation or malicious intent is present.

  71. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:32:1

    `os.spawnlpe` called with a literal binary path (ast pass, confidence 0.70)

    os.spawnlp("true")
    os.spawnlpe("true")
    os.spawnv("true")
    os.spawnve("true")
    dismissed LLM, confidence 0.97 Test fixture calling os.spawnlpe with a literal placeholder binary path.
    Reasoning

    Part of the S607 test fixture exercising os.spawn* variants with a placeholder literal. No obfuscation or malicious intent is present.

  72. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:33:1

    `os.spawnv` called with a literal binary path (ast pass, confidence 0.70)

    os.spawnlpe("true")
    os.spawnv("true")
    os.spawnve("true")
    os.spawnvp("true")
    dismissed LLM, confidence 0.97 Test fixture calling os.spawnv with a literal placeholder binary path.
    Reasoning

    Part of the S607 test fixture exercising os.spawn* variants with a placeholder literal. No obfuscation or malicious intent is present.

  73. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:34:1

    `os.spawnve` called with a literal binary path (ast pass, confidence 0.70)

    os.spawnv("true")
    os.spawnve("true")
    os.spawnvp("true")
    os.spawnvpe("true")
    dismissed LLM, confidence 0.97 Test fixture calling os.spawnve with a literal placeholder binary path.
    Reasoning

    Part of the S607 test fixture exercising os.spawn* variants with a placeholder literal. No obfuscation or malicious intent is present.

  74. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:35:1

    `os.spawnvp` called with a literal binary path (ast pass, confidence 0.70)

    os.spawnve("true")
    os.spawnvp("true")
    os.spawnvpe("true")
    os.startfile("true")
    dismissed LLM, confidence 0.97 Test fixture calling os.spawnvp with a literal placeholder binary path.
    Reasoning

    Part of the S607 test fixture exercising os.spawn* variants with a placeholder literal. No obfuscation or malicious intent is present.

  75. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:36:1

    `os.spawnvpe` called with a literal binary path (ast pass, confidence 0.70)

    os.spawnvp("true")
    os.spawnvpe("true")
    os.startfile("true")
    dismissed LLM, confidence 0.97 Test fixture calling os.spawnvpe with a literal placeholder binary path.
    Reasoning

    Part of the S607 test fixture exercising os.spawn* variants with a placeholder literal. No obfuscation or malicious intent is present.

  76. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:40:1

    `os.system` called with a literal shell command (ast pass, confidence 0.70)

    # Check it does not fail for full paths.
    os.system("/bin/ls")
    os.system("./bin/ls")
    os.system(["/bin/ls"])
    dismissed LLM, confidence 0.97 Test fixture calling os.system with the literal full path /bin/ls.
    Reasoning

    Test fixture for the S607 rule checking that full paths are handled. The literal /bin/ls is a benign, expected pattern in a linter test.

  77. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:41:1

    `os.system` called with a literal shell command (ast pass, confidence 0.70)

    os.system("/bin/ls")
    os.system("./bin/ls")
    os.system(["/bin/ls"])
    os.system(["/bin/ls", "/tmp"])
    dismissed LLM, confidence 0.97 Test fixture calling os.system with literal ls commands.
    Reasoning

    Test fixture for the S607 rule with benign literal ls commands. No obfuscation or malicious behavior is present.

  78. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:42:1

    `os.system` called with a literal shell command (ast pass, confidence 0.70)

    os.system("./bin/ls")
    os.system(["/bin/ls"])
    os.system(["/bin/ls", "/tmp"])
    os.system(r"C:\\bin\ls")
    dismissed LLM, confidence 0.97 Test fixture calling os.system with literal ls and Windows path strings.
    Reasoning

    Test fixture for the S607 rule with benign literal commands and a raw Windows path. No obfuscation or malicious behavior is present.

  79. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:43:1

    `os.system` called with a literal shell command (ast pass, confidence 0.70)

    os.system(["/bin/ls"])
    os.system(["/bin/ls", "/tmp"])
    os.system(r"C:\\bin\ls")
    dismissed LLM, confidence 0.97 Test fixture calling os.system with literal command lists.
    Reasoning

    Test fixture for the S607 rule with benign literal command lists. No obfuscation or malicious behavior is present.

  80. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:44:1

    `os.system` called with a literal shell command (ast pass, confidence 0.70)

    os.system(["/bin/ls", "/tmp"])
    os.system(r"C:\\bin\ls")
    
    # Regression for https://github.com/astral-sh/ruff/issues/24075
    dismissed LLM, confidence 0.97 Test fixture calling os.system with a literal ls command list.
    Reasoning

    Test fixture for the S607 rule with a benign literal command list and a reference to a ruff issue. No malicious behavior is present.

  81. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S609.py:4:1

    `os.popen` called with a literal shell command (ast pass, confidence 0.70)

    
    os.popen("chmod +w foo*")
    subprocess.Popen("/bin/chown root: *", shell=True)
    subprocess.Popen(["/usr/local/bin/rsync", "*", "some_where:"], shell=True)
    dismissed LLM, confidence 0.96 Test fixture calling os.popen and subprocess.Popen with literal wildcard-argument commands.
    Reasoning

    Test fixture for the S609 wildcard-injection rule. The os.popen and subprocess calls use literal benign commands in a linter test file, not an attack.

  82. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S609.py:5:1

    `subprocess.Popen` called with `shell=True` and a literal command (ast pass, confidence 0.70)

    os.popen("chmod +w foo*")
    subprocess.Popen("/bin/chown root: *", shell=True)
    subprocess.Popen(["/usr/local/bin/rsync", "*", "some_where:"], shell=True)
    subprocess.Popen("/usr/local/bin/rsync * no_injection_here:")
    likely benign LLM, confidence 0.90 Test fixture calling subprocess.Popen with shell=True and a literal command.
    Reasoning

    The file is a ruff linter test fixture for bandit rule S609. The shell=True calls exist so the rule can fire on them, and the commands are literal, not built from untrusted input.

  83. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S609.py:6:1

    `subprocess.Popen` called with `shell=True` and a literal command (ast pass, confidence 0.70)

    subprocess.Popen("/bin/chown root: *", shell=True)
    subprocess.Popen(["/usr/local/bin/rsync", "*", "some_where:"], shell=True)
    subprocess.Popen("/usr/local/bin/rsync * no_injection_here:")
    os.system("tar cf foo.tar bar/*")
    likely benign LLM, confidence 0.90 Test fixture calling subprocess.Popen with shell=True and a literal chown command.
    Reasoning

    Same S609 test fixture. The shell=True call uses a fixed literal command string with no attacker-controlled input.

  84. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S609.py:8:1

    `os.system` called with a literal shell command (ast pass, confidence 0.70)

    subprocess.Popen("/usr/local/bin/rsync * no_injection_here:")
    os.system("tar cf foo.tar bar/*")
    
    subprocess.Popen(["chmod", "+w", "*.py"], shell={**{}})
    likely benign LLM, confidence 0.90 Test fixture calling os.system and subprocess with a literal shell command.
    Reasoning

    Part of the S609 linter test fixture, which deliberately includes os.system and shell= variants to exercise the rule. The commands are static literals.

  85. 28 of 65 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  86. 25 of 61 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  87. 18 of 37 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  88. 21 of 40 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  89. file mixes tab and space indentation (3 tab-indented and 68 space-indented lines) (raw pass, confidence 0.40)

    _ = "abc" \
        "def"
    
    _ = (
  90. file mixes tab and space indentation (4 tab-indented and 161 space-indented lines) (raw pass, confidence 0.40)

    def foo2(x, y, w, z):
        if x:  # [no-else-return]
            a = 1
            return y
  91. file mixes tab and space indentation (4 tab-indented and 69 space-indented lines) (raw pass, confidence 0.40)

    if a:
        b = c
    else:
        b = d
  92. mean non-conventional identifier length 1.52 over 63 names (token pass, confidence 0.50)

  93. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

        # SIM110
        for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ":
            if x.isdigit():
                return True
  94. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

        # SIM110
        for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ":
            if x.isdigit():
                return True
  95. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

        # SIM110
        for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ":
            if x.isdigit():
                return True
  96. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

        # SIM110
        for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ":
            if x.isdigit():
                return True
  97. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

        # OK (too long)
        for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9":
            if x.isdigit():
                return True
  98. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

        # OK (too long)
        for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9":
            if x.isdigit():
                return True
  99. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

        # OK (too long)
        for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9":
            if x.isdigit():
                return True
  100. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

        # OK (too long)
        for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9":
            if x.isdigit():
                return True
  101. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

        # SIM111
        for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9":
            if x.isdigit():
                return False
  102. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

        # SIM111
        for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9":
            if x.isdigit():
                return False
  103. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

        # SIM111
        for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9":
            if x.isdigit():
                return False
  104. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

        # SIM111
        for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9":
            if x.isdigit():
                return False
  105. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

        # OK (too long)
        for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß90":
            if x.isdigit():
                return False
  106. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

        # OK (too long)
        for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß90":
            if x.isdigit():
                return False
  107. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

        # OK (too long)
        for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß90":
            if x.isdigit():
                return False
  108. identifier `ℝ9012ß90` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

        # OK (too long)
        for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß90":
            if x.isdigit():
                return False
  109. file mixes tab and space indentation (1 tab-indented and 85 space-indented lines) (raw pass, confidence 0.40)

    if a:
        b
    elif c:
        b
  110. identifier `ℝ8901ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # SIM117 (auto-fixable)
    with A("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as a:
        with B("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as b:
            print("hello")
  111. identifier `ℝ8901ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # SIM117 (auto-fixable)
    with A("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as a:
        with B("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as b:
            print("hello")
  112. identifier `ℝ8901ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    with A("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as a:
        with B("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as b:
            print("hello")
  113. identifier `ℝ8901ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    with A("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as a:
        with B("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as b:
            print("hello")
  114. identifier `ℝ8901ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # SIM117 (not auto-fixable too long)
    with A("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ890") as a:
        with B("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as b:
            print("hello")
  115. identifier `ℝ8901ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # SIM117 (not auto-fixable too long)
    with A("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ890") as a:
        with B("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as b:
            print("hello")
  116. identifier `ℝ8901ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    with A("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ890") as a:
        with B("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as b:
            print("hello")
  117. identifier `ℝ8901ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    with A("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ890") as a:
        with B("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as b:
            print("hello")
  118. mean non-conventional identifier length 1.81 over 27 names (token pass, confidence 0.50)

  119. identifier `ℝ6789ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    else:
        vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789"
    
    # SIM401
  120. identifier `ℝ6789ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    else:
        vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789"
    
    # SIM401
  121. identifier `ℝ6789ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    else:
        vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789"
    
    # SIM401
  122. identifier `ℝ6789ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    else:
        vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789"
    
    # SIM401
  123. identifier `ℝ6789ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    else:
        vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß"
    
    # OK (false negative)
  124. identifier `ℝ6789ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    else:
        vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß"
    
    # OK (false negative)
  125. identifier `ℝ6789ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    else:
        vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß"
    
    # OK (false negative)
  126. identifier `ℝ6789ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    else:
        vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß"
    
    # OK (false negative)
  127. identifier `ℝ6789ß` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    else:
        vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß"
    
    # OK (false negative)
  128. 78 of 195 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  129. 20 of 40 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  130. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # The next import fits on one line.
    from f import g  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ
    # The next import doesn't fit on one line.
  131. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # The next import fits on one line.
    from f import g  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ
    # The next import doesn't fit on one line.
  132. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # The next import fits on one line.
    from f import g  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ
    # The next import doesn't fit on one line.
  133. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # The next import fits on one line.
    from f import g  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ
    # The next import doesn't fit on one line.
  134. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # The next import fits on one line.
    from f import g  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ
    # The next import doesn't fit on one line.
  135. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # The next import fits on one line.
    from f import g  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ
    # The next import doesn't fit on one line.
  136. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # The next import doesn't fit on one line.
    from h import i  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9
  137. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # The next import doesn't fit on one line.
    from h import i  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9
  138. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # The next import doesn't fit on one line.
    from h import i  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9
  139. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # The next import doesn't fit on one line.
    from h import i  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9
  140. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # The next import doesn't fit on one line.
    from h import i  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9
  141. identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # The next import doesn't fit on one line.
    from h import i  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9
  142. identifier `μεδιυυυυυμ` mixes scripts: Latin + Greek (raw pass, confidence 0.80)

        looooooooooooooong,
        μεδιυυυυυμ,
        short,
        mediuuuuuum,
    likely benign LLM, confidence 0.85 Identifier in a sorting test fixture that mixes Greek and Latin letters.
    Reasoning

    This is an isort test fixture for sorting non-ASCII names. The identifier mixes Greek and Latin letters on purpose to test sort ordering, not to hide code from a reader.

  143. identifier `μεδιυυυυυμ` mixes scripts: Latin + Greek (raw pass, confidence 0.80)

    import λοοοοοοοοοοοοοονγ
    import μεδιυυυυυμ
    import looooooooooooooong
    likely benign LLM, confidence 0.85 Import name in a sorting test fixture that mixes Greek and Latin letters.
    Reasoning

    Same isort non-ASCII fixture. The mixed-script import name exists to test length-based sorting of unicode module names and is not used to disguise a call.

  144. 40 of 100 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  145. 14 of 30 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  146. info warn → info by review unicode-mixed-script crates/ruff_linter/resources/test/fixtures/isort/unicode.py:4:17

    identifier `CƐgHHHhIILlNZΩZKÅBCeEFio` mixes scripts: Latin + Greek (raw pass, confidence 0.80)

    import numpy as ℂℇℊℋℌℍℎℐℑℒℓℕℤΩℨKÅℬℭℯℰℱℹℴ
    import numpy as CƐgHHHhIILlNZΩZKÅBCeEFio
    
    h = 2 * π * ℏ
    likely benign LLM, confidence 0.85 Import alias in a unicode test fixture mixing Latin and Greek letters.
    Reasoning

    This is an isort unicode test fixture. The mixed-script alias is an intentional case for the sorter, and the identifier is only bound to an import with no dangerous use.

  147. file mixes tab and space indentation (2 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    def func_all_spaces():
        # No error
        print("spaces")
  148. file mixes tab and space indentation (1 tab-indented and 23 space-indented lines) (raw pass, confidence 0.40)

    if x > 2:
      print(x)
    #: E111 E117
    if True:
  149. 63 of 154 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  150. file mixes tab and space indentation (1 tab-indented and 17 space-indented lines) (raw pass, confidence 0.40)

    if   1:
        pass
    #: E273
    True and		False
  151. file mixes tab and space indentation (8 tab-indented and 287 space-indented lines) (raw pass, confidence 0.40)

    class Class:
        pass
    # end
  152. file mixes tab and space indentation (11 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    # aaaaa
        # a
    	# a
    	# aa
  153. 40 of 98 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  154. 40 of 98 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  155. file mixes tab and space indentation (44 tab-indented and 24 space-indented lines) (raw pass, confidence 0.40)

    	'''File starts with a tab
    	multiline string with tab in it'''
  156. file mixes tab and space indentation (1 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

        
        bang = 12
    #: W291:2:35
    '''multiline
  157. identifier `ℝing` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    #!/usr/bin/env python3
    """Here's a top-level ß9💣2ℝing that's over theß9💣2ℝ."""
  158. identifier `ℝing` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    def f1():
        """Here's a ß9💣2ℝing that's also over theß9💣2ℝ."""
    
        x = 1  # Here's a comment that's over theß9💣2ℝ, but it's not standalone.
  159. identifier `ℝing` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    
        print("Here's a string that's over theß9💣2ℝ, but it's not a ß9💣2ℝing.")
  160. identifier `ℝing` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    
    "This is also considered a ß9💣2ℝing, and is over theß9💣2ℝ."
  161. identifier `ℝing` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    def f2():
        """Here's a multi-line ß9💣2ℝing.
    
        It's over theß9💣2ℝ on this line, which isn't the first line in the ß9💣2ℝing.
  162. identifier `ℝing` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    
        It's over theß9💣2ℝ on this line, which isn't the first line in the ß9💣2ℝing.
        """
  163. identifier `ℝing` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    def f3():
        """Here's a multi-line ß9💣2ℝing.
    
        It's over theß9💣2ℝ on this line, which isn't the first line in the ß9💣2ℝing."""
  164. identifier `ℝing` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    
        It's over theß9💣2ℝ on this line, which isn't the first line in the ß9💣2ℝing."""
  165. info warn → info by review whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pydocstyle/D.py:723:4

    invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)

    
       ⟨U+00A0⟩ ⟨U+00A0⟩ Returns:
        """
    likely benign LLM, confidence 0.90 Non-breaking space in the indentation of a docstring in a pydocstyle fixture.
    Reasoning

    A non-breaking space in docstring indentation within a pydocstyle test fixture. It is a cosmetic whitespace artifact with no code effect.

  166. info warn → info by review whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pydocstyle/D208.py:9:9

    invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)

                Args:
            ⟨U+00A0⟩ ⟨U+00A0⟩ Returns:
                """
    likely benign LLM, confidence 0.90 Non-breaking space in docstring indentation in a pydocstyle fixture.
    Reasoning

    A non-breaking space in a docstring indentation inside a pydocstyle test fixture. It is a whitespace quirk that exists to test D208 and does not change behavior.

  167. info warn → info by review whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pydocstyle/D208.py:15:1

    invisible whitespace U+3000 in indentation (raw pass, confidence 0.80)

        """
    ⟨U+3000⟩⟨U+3000⟩⟨U+3000⟩参数含义:precision:精确到小数点后几位
        """
    likely benign LLM, confidence 0.90 Ideographic space in the indentation of a Chinese docstring in a fixture.
    Reasoning

    An ideographic space inside a Chinese-language docstring in a pydocstyle fixture. This is ordinary CJK typography and is confined to a string literal.

  168. mean non-conventional identifier length 1.00 over 29 names (token pass, confidence 0.50)

  169. file mixes tab and space indentation (4 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    class A:
        pass
  170. file mixes tab and space indentation (2 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

    if TYPE_CHECKING:
        # See: https://github.com/astral-sh/ruff/issues/22554
        # should detect -------------------------vvvvvvvvvvvvv
        from faststream._internal.broker import BrokerUsecase
  171. 112 of 270 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  172. U+202C POP DIRECTIONAL FORMATTING in source (raw pass, confidence 0.98)

    # E2502
    print("שלום⟨U+202C⟩")
    
    # E2502
    likely benign LLM, confidence 0.85 Bidirectional formatting control character inside a string in a linter test fixture.
    Reasoning

    The file is a pylint E2502 test fixture for bidi characters. The pop-directional mark is deliberately placed to exercise the rule, and it sits in a string literal. The snippet matches the Trojan Source pattern, but the context is a test.

  173. U+202E RIGHT-TO-LEFT OVERRIDE in source (raw pass, confidence 0.98)

    # E2502
    if access_level != "none⟨U+202E⟩⟨U+2066⟩":  # Check if admin ⟨U+2069⟩⟨U+2066⟩' and access_level != 'user
        print("You are an admin.")
    likely benign LLM, confidence 0.85 Right-to-left override control character in a test fixture comparison line.
    Reasoning

    This is the E2502 test fixture. The right-to-left override sits in a comment-adjacent string and is a deliberate test case for the rule. The same Trojan Source shape would be dangerous in real code, but here the file is a test fixture.

  174. U+2066 LEFT-TO-RIGHT ISOLATE in source (raw pass, confidence 0.98)

    # E2502
    if access_level != "none⟨U+202E⟩⟨U+2066⟩":  # Check if admin ⟨U+2069⟩⟨U+2066⟩' and access_level != 'user
        print("You are an admin.")
    likely benign LLM, confidence 0.85 Left-to-right isolate control character in a bidi linter test fixture.
    Reasoning

    Part of the same deliberate E2502 test fixture. The isolate character is placed to trigger the bidi rule and belongs to test data.

  175. U+2069 POP DIRECTIONAL ISOLATE in source (raw pass, confidence 0.98)

    # E2502
    if access_level != "none⟨U+202E⟩⟨U+2066⟩":  # Check if admin ⟨U+2069⟩⟨U+2066⟩' and access_level != 'user
        print("You are an admin.")
    likely benign LLM, confidence 0.85 Pop-directional isolate control character in a bidi linter test fixture.
    Reasoning

    Same E2502 fixture. The pop-isolate character is an intentional test artifact used to check bidi detection.

  176. U+2066 LEFT-TO-RIGHT ISOLATE in source (raw pass, confidence 0.98)

    # E2502
    if access_level != "none⟨U+202E⟩⟨U+2066⟩":  # Check if admin ⟨U+2069⟩⟨U+2066⟩' and access_level != 'user
        print("You are an admin.")
    likely benign LLM, confidence 0.85 Left-to-right isolate control character in a bidi linter test fixture.
    Reasoning

    Same E2502 fixture. The second left-to-right isolate is another deliberate bidi test character and does not alter any shipped code.

  177. U+2067 RIGHT-TO-LEFT ISOLATE in source (raw pass, confidence 0.98)

    def subtract_funds(account: str, amount: int):
        """Subtract funds from bank account then ⟨U+2067⟩"""
        return
        bank[account] -= amount
    likely benign LLM, confidence 0.85 Right-to-left isolate control character in a docstring in a bidi linter test fixture.
    Reasoning

    Same E2502 fixture. The right-to-left isolate inside a docstring is a deliberate test case for detecting bidi characters in documentation text.

  178. 171 of 345 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  179. file mixes tab and space indentation (1 tab-indented and 23 space-indented lines) (raw pass, confidence 0.40)

    if a < b and b < c:  # [boolean-chained-comparison]
        pass
    
    a = int(input())
  180. 28 of 54 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  181. info warn → info by review unicode-homoglyph crates/ruff_linter/resources/test/fixtures/pylint/empty_comment.py:57:1

    identifier `α` contains homoglyph candidates: α (03B1)→a (raw pass, confidence 0.70)

    
    α = 1
    α#
    likely benign LLM, confidence 0.85 Greek letter alpha used as an identifier in a ruff test fixture.
    Reasoning

    Greek alpha used as a variable name in a linter test fixture for empty comments. The homoglyph is a deliberate test input, not a deceptive identifier in shipped code.

  182. info warn → info by review unicode-homoglyph crates/ruff_linter/resources/test/fixtures/pylint/empty_comment.py:58:1

    identifier `α` contains homoglyph candidates: α (03B1)→a (raw pass, confidence 0.70)

    α = 1
    α#
    likely benign LLM, confidence 0.85 Greek letter alpha identifier in a ruff pylint test fixture.
    Reasoning

    Same Greek alpha identifier in the same test fixture. It is a lint test case, not an attack.

  183. 21 of 39 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  184. 30 of 49 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  185. `subprocess.run` called with `shell=True` and a literal command (ast pass, confidence 0.70)

    subprocess.run("ls")
    subprocess.run("ls", shell=True)
    subprocess.run(
        ["ls"],
    likely benign LLM, confidence 0.90 Test fixture calling subprocess.run with shell=True on a literal command.
    Reasoning

    subprocess.run with shell=True and a fixed literal command 'ls' in a linter fixture. No untrusted input reaches the shell, and the file exists to test a lint rule about check=.

  186. `subprocess.run` called with `shell=True` and a literal command (ast pass, confidence 0.70)

    subprocess.run("ls", check=False)
    subprocess.run("ls", shell=True, check=True)
    subprocess.run("ls", shell=True, check=False)
    foo.run("ls")  # Not a subprocess.run call.
    likely benign LLM, confidence 0.90 Test fixture variants of subprocess.run with literal commands.
    Reasoning

    Several variants of subprocess.run with a literal 'ls' command, including a deliberate non-subprocess foo.run control line. This is lint test data.

  187. `subprocess.run` called with `shell=True` and a literal command (ast pass, confidence 0.70)

    subprocess.run("ls", shell=True, check=True)
    subprocess.run("ls", shell=True, check=False)
    foo.run("ls")  # Not a subprocess.run call.
    subprocess.bar("ls")  # Not a subprocess.run call.
    likely benign LLM, confidence 0.90 Test fixture variants of subprocess.run with literal commands.
    Reasoning

    Same fixture with a literal command and no dynamic input. The comment marks it as a test of the check= argument.

  188. 90 of 151 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  189. 267 of 619 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  190. 85 of 138 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  191. `open(__file__)` — file reads its own source, common pattern for extracting payloads hidden in comments (ast pass, confidence 0.85)

        for name in ["demo"]:
            with open(__file__) as f:
                if name in f.read():
                    break
    likely benign LLM, confidence 0.85 Test fixture reading its own source file inside a for loop.
    Reasoning

    open(__file__) inside a loop checking for a marker string is a contrived control-flow test for the useless-else rule. It is not a real payload extractor in shipped code.

  192. file mixes tab and space indentation (1 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)

    """.encode(
        "utf-8"
    )
    (
  193. mean non-conventional identifier length 1.88 over 32 names (token pass, confidence 0.50)

  194. file mixes tab and space indentation (3 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)

    def f(a: Foo['''Bar[
        Multi |
        Line]''']): ...
  195. mean non-conventional identifier length 1.19 over 27 names (token pass, confidence 0.50)

  196. mean non-conventional identifier length 1.00 over 28 names (token pass, confidence 0.50)

  197. 48 of 75 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  198. 150 of 284 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  199. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/ruff/RUF028.py:103:12

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

    def test_eval(test_input, expected):
        assert eval(test_input) == expected
    likely benign LLM, confidence 0.85 Test helper using eval on a parametrized input in a ruff fixture.
    Reasoning

    eval of a test input inside a test helper, in a ruff rule fixture. It is a normal test assertion pattern.

  200. 24 of 52 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  201. 24 of 52 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  202. mean non-conventional identifier length 1.99 over 223 names (token pass, confidence 0.50)

  203. file mixes tab and space indentation (3 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    
     ⟨U+000C⟩
    
    		⟨U+000C⟩
  204. info warn → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/ruff/RUF100_0.py:113:5

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

        # Disabled - check redirects are reported correctly
        eval(command)  # noqa: PGH001
    likely benign LLM, confidence 0.85 Fixture line calling eval with a noqa directive.
    Reasoning

    eval(command) with a noqa comment in a ruff noqa-handling fixture. The code exists to test directive parsing.

  205. info critical → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/ruff/RUF100_0.py:128:5

    `eval` at module scope (runs on import) on a non-literal expression (ast pass, confidence 0.80)

    # Allow code redirects
    x = eval(command)  # noqa: PGH001, S307
    x = eval(command)  # noqa: S307, PGH001, S307, S307, S307
    x = eval(command)  # noqa: PGH001, S307, PGH001
    likely benign LLM, confidence 0.80 Repeated eval lines with varying noqa comments in a ruff fixture.
    Reasoning

    Module-scope eval repeated across lines that only vary noqa comments. The repetition is intentional test input for the unused-noqa rule, not a dropper.

  206. info critical → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/ruff/RUF100_0.py:129:5

    `eval` at module scope (runs on import) on a non-literal expression (ast pass, confidence 0.80)

    x = eval(command)  # noqa: PGH001, S307
    x = eval(command)  # noqa: S307, PGH001, S307, S307, S307
    x = eval(command)  # noqa: PGH001, S307, PGH001
    x = eval(command)  # noqa: PGH001, S307, PGH001, S307
    likely benign LLM, confidence 0.80 Repeated module-scope eval lines in a ruff noqa test fixture.
    Reasoning

    Same repeated module-scope eval fixture for noqa parsing. Severity is high only because the detector ignores the test context.

  207. info critical → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/ruff/RUF100_0.py:130:5

    `eval` at module scope (runs on import) on a non-literal expression (ast pass, confidence 0.80)

    x = eval(command)  # noqa: S307, PGH001, S307, S307, S307
    x = eval(command)  # noqa: PGH001, S307, PGH001
    x = eval(command)  # noqa: PGH001, S307, PGH001, S307
    likely benign LLM, confidence 0.80 Module-scope eval lines varying noqa directives in a ruff fixture.
    Reasoning

    Same noqa-variant fixture with eval on an undefined name. This is lint test data.

  208. info critical → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/ruff/RUF100_0.py:131:5

    `eval` at module scope (runs on import) on a non-literal expression (ast pass, confidence 0.80)

    x = eval(command)  # noqa: PGH001, S307, PGH001
    x = eval(command)  # noqa: PGH001, S307, PGH001, S307
    likely benign LLM, confidence 0.80 Module-scope eval line in a ruff noqa test fixture.
    Reasoning

    Final variant of the same noqa test fixture. Nothing indicates a real payload.

  209. identifier `𝐁ad` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    x = "𝐁ad string"
    y = "−"
  210. identifier `ρ` contains homoglyph candidates: ρ (03C1)→p (in string/comment) (raw pass, confidence 0.35)

    def f():
        """Here's a docstring with a greek rho: ρ"""
        # And here's a comment with a greek alpha: ∗
        ...
  211. identifier `𝐁ad` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    
    x = "𝐁ad string"
    x = "−"
  212. identifier `Bαd` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    # contains ASCII.
    x = "βα Bαd"
    
    # The two characters should be flagged here. The first character is a "word"
  213. identifier `Bαd` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

    # contains ASCII.
    x = "βα Bαd"
    
    # The two characters should be flagged here. The first character is a "word"
  214. identifier `Р` contains homoglyph candidates: Р (0420)→P (in string/comment) (raw pass, confidence 0.35)

    # boundary" (whitespace) that it itself ambiguous.
    x = "Р⟨U+2000⟩усский"
    
    # Same test cases as above but using f-strings instead:
  215. identifier `𝐁ad` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # Same test cases as above but using f-strings instead:
    x = f"𝐁ad string"
    x = f"−"
    x = f"Русский"
  216. identifier `Bαd` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    x = f"Русский"
    x = f"βα Bαd"
    x = f"Р⟨U+2000⟩усский"
  217. identifier `Bαd` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

    x = f"Русский"
    x = f"βα Bαd"
    x = f"Р⟨U+2000⟩усский"
  218. identifier `Р` contains homoglyph candidates: Р (0420)→P (in string/comment) (raw pass, confidence 0.35)

    x = f"βα Bαd"
    x = f"Р⟨U+2000⟩усский"
    
    # Nested f-strings
  219. identifier `𝐁ad` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # Nested f-strings
    x = f"𝐁ad string {f"⟨U+2000⟩{f"Р⟨U+2000⟩усский"}"}"
    
    # Comments inside f-strings
  220. identifier `Р` contains homoglyph candidates: Р (0420)→P (in string/comment) (raw pass, confidence 0.35)

    # Nested f-strings
    x = f"𝐁ad string {f"⟨U+2000⟩{f"Р⟨U+2000⟩усский"}"}"
    
    # Comments inside f-strings
  221. identifier `𝐁ad` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # Implicit string concatenation
    x = "𝐁ad" f"𝐁ad string"
    
    from typing import Literal
  222. identifier `𝐁ad` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    # Implicit string concatenation
    x = "𝐁ad" f"𝐁ad string"
    
    from typing import Literal
  223. 23 of 47 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  224. 26 of 56 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  225. info warn → info by review whitespace-anomaly crates/ruff_linter/src/lib.rs:77:9

    invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)

                Args:
            ⟨U+00A0⟩ ⟨U+00A0⟩ Returns:
                """
    "#;
    likely benign LLM, confidence 0.75 Docstring-style raw string containing a non-breaking space in indentation.
    Reasoning

    A non-breaking space in indentation inside a raw string docstring example. It is most likely test or documentation text, though a stray NBSP is a plausible copy-paste artifact.

  226. info whitespace-anomaly crates/ruff_linter/src/linter.rs:41:1

    file mixes tab and space indentation (58 tab-indented and 965 space-indented lines) (raw pass, confidence 0.40)

    pub struct LinterResult {
        /// A collection of diagnostic messages generated by the linter.
        pub diagnostics: Vec<Diagnostic>,
        /// Flag indicating that the parsed source code does not contain any
  227. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ///
        /// let locator = Locator::new("α");
        ///
        /// assert_eq!(
  228. identifier `ρ` contains homoglyph candidates: ρ (03C1)→p (in string/comment) (raw pass, confidence 0.35)

                &settings::LinterSettings {
                    allowed_confusables: FxHashSet::from_iter(['−', 'ρ', '∗']),
                    ..settings::LinterSettings::for_rules(vec![
                        Rule::AmbiguousUnicodeCharacterString,
  229. identifier `ρ` contains homoglyph candidates: ρ (03C1)→p (in string/comment) (raw pass, confidence 0.35)

                    unresolved_target_version: PythonVersion::PY313.into(),
                    allowed_confusables: FxHashSet::from_iter(['−', 'ρ', '∗']),
                    ..settings::LinterSettings::for_rules(vec![
                        Rule::AmbiguousUnicodeCharacterString,
  230. identifier `ρ` contains homoglyph candidates: ρ (03C1)→p (in string/comment) (raw pass, confidence 0.35)

                    unresolved_target_version: PythonVersion::PY314.into(),
                    allowed_confusables: FxHashSet::from_iter(['−', 'ρ', '∗']),
                    ..settings::LinterSettings::for_rules(vec![
                        Rule::AmbiguousUnicodeCharacterString,
  231. identifier `ρ` contains homoglyph candidates: ρ (03C1)→p (in string/comment) (raw pass, confidence 0.35)

                    preview: PreviewMode::Enabled,
                    allowed_confusables: FxHashSet::from_iter(['−', 'ρ', '∗']),
                    ..settings::LinterSettings::for_rules(vec![
                        Rule::AmbiguousUnicodeCharacterString,
  232. identifier `Ηello` contains homoglyph candidates: Η (0397)→H (in string/comment) (raw pass, confidence 0.35)

    /// ```python
    /// print("Ηello, world!")  # "Η" is the Greek eta (`U+0397`).
    /// ```
    ///
  233. identifier `Ηello` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    /// ```python
    /// print("Ηello, world!")  # "Η" is the Greek eta (`U+0397`).
    /// ```
    ///
  234. identifier `Η` contains homoglyph candidates: Η (0397)→H (in string/comment) (raw pass, confidence 0.35)

    /// ```python
    /// print("Ηello, world!")  # "Η" is the Greek eta (`U+0397`).
    /// ```
    ///
  235. identifier `nоqa` contains homoglyph candidates: о (043E)→o (in string/comment) (raw pass, confidence 0.35)

    /// ```python
    /// foo()  # nоqa  # "о" is Cyrillic (`U+043E`)
    /// ```
    ///
  236. identifier `nоqa` mixes scripts: Latin + Cyrillic (in string/comment) (raw pass, confidence 0.40)

    /// ```python
    /// foo()  # nоqa  # "о" is Cyrillic (`U+043E`)
    /// ```
    ///
  237. identifier `о` contains homoglyph candidates: о (043E)→o (in string/comment) (raw pass, confidence 0.35)

    /// ```python
    /// foo()  # nоqa  # "о" is Cyrillic (`U+043E`)
    /// ```
    ///
  238. info proc-macro-presence crates/ruff_macros/src/lib.rs:23:1

    proc-macro attribute `#[proc_macro_derive]` present (ast pass, confidence 0.95)

    
    #[proc_macro_derive(OptionsMetadata, attributes(option, option_group))]
    pub fn derive_options_metadata(input: TokenStream) -> TokenStream {
        let input = parse_macro_input!(input as DeriveInput);
  239. file mixes tab and space indentation (1 tab-indented and 2004 space-indented lines) (raw pass, confidence 0.40)

    use ruff_python_ast::{
        self as ast, Alias, AnyStringFlags, ArgOrKeyword, BoolOp, BytesLiteralFlags, CmpOp,
        Comprehension, ConversionFlag, DebugText, ExceptHandler, Expr, Identifier, MatchCase, Operator,
        Parameter, Parameters, Pattern, Singleton, Stmt, StringFlags, Suite, TypeParam,
  240. file mixes tab and space indentation (1 tab-indented and 253 space-indented lines) (raw pass, confidence 0.40)

    pub struct Stylist<'a> {
        indentation: Indentation,
        quote: Quote,
        line_ending: LineEndingDetection<'a>,
  241. info warn → info by review whitespace-anomaly crates/ruff_python_codegen/src/stylist.rs:255:1

    invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)

    x = (
    ⟨U+00A0⟩1,
    ⟨U+00A0⟩2,
    ⟨U+00A0⟩3,
    likely benign LLM, confidence 0.75 Raw string Python snippet with non-breaking spaces in indentation.
    Reasoning

    NBSP in indentation inside a raw Python snippet used as test input for the stylist's indentation detection. The character is probably deliberate test data.

  242. info warn → info by review whitespace-anomaly crates/ruff_python_codegen/src/stylist.rs:256:1

    invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)

    ⟨U+00A0⟩1,
    ⟨U+00A0⟩2,
    ⟨U+00A0⟩3,
    )
    likely benign LLM, confidence 0.75 Test snippet with non-breaking spaces in indentation.
    Reasoning

    Same NBSP-indented test snippet in the stylist tests. It is probably deliberate input for indentation detection.

  243. info warn → info by review whitespace-anomaly crates/ruff_python_codegen/src/stylist.rs:257:1

    invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)

    ⟨U+00A0⟩2,
    ⟨U+00A0⟩3,
    )
    ";
    likely benign LLM, confidence 0.75 Test snippet with non-breaking spaces in indentation.
    Reasoning

    Same NBSP-indented test snippet in the stylist tests. Benign test data.

  244. file mixes tab and space indentation (12 tab-indented and 95 space-indented lines) (raw pass, confidence 0.40)

    class MyClass:
      """ Multiline
      class docstring
      """
  245. 168 of 250 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  246. 18 of 43 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  247. 34 of 69 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  248. 29 of 56 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  249. mean non-conventional identifier length 1.88 over 420 names (token pass, confidence 0.50)

  250. mean non-conventional identifier length 1.15 over 26 names (token pass, confidence 0.50)

  251. mean non-conventional identifier length 1.00 over 53 names (token pass, confidence 0.50)

  252. file uses only 11 distinct printable characters ("*.01=abcdef") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)

    a = 1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1
    b = 1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1
    c = 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1
    likely benign LLM, confidence 0.93 Formatter test fixture with repeated exponentiation expressions.
    Reasoning

    This is a formatter test fixture containing long chains of power operators on literal 1s; the narrow charset comes from the trivial content of a test case, not obfuscation.

  253. compression ratio 0.831 is >2σ above file mean 0.705 (raw pass, confidence 0.50)

    
    log.info(f'Skipping: {desc["db_id"]} {foo("bar",x=123)} {"foo" != "bar"} {(x := "abc=")} {pos_share=} {desc["status"]} {desc["exposure_max"]}')
    
    log.info(f'Skipping: {desc["db_id"]} {desc["ms_name"]} {money=} {(x := "abc=")=} {pos_share=} {desc["status"]} {desc["exposure_max"]}')
  254. string literal compression ratio 0.970 (132 bytes) (raw pass, confidence 0.60)

    hangul = '코드포인트 수는 적으나 실제 터미널이나 에디터에서 렌더링될 땐 너무 길어서 줄바꿈이 필요한 문자열'
    hanzi = '中文測試:代碼點數量少,但在真正的終端模擬器或編輯器中呈現時太長,因此需要換行的字符串。'
    likely benign LLM, confidence 0.93 Plain CJK string literals used to test line-width formatting.
    Reasoning

    Ordinary Korean and Chinese string literals in a formatter test about east-asian width handling; the compression ratio flag is a false positive on natural text.

  255. `os.system` called on a non-literal command — runtime-determined shell invocation (ast pass, confidence 0.85)

        def foo():
            os.system("This is a regression test. xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxxx.".format("xxxxxxxxxx", "xxxxxx", "xxxxxxxxxx"))
    likely benign LLM, confidence 0.90 Test fixture calling os.system with a formatted string inside a function that is never run.
    Reasoning

    This is a formatter regression fixture; os.system is called with a str.format result on a literal template with placeholder arguments inside a test file that is never executed. Flagged only because the command is not a plain literal.

  256. compression ratio 0.845 is >2σ above file mean 0.458 (raw pass, confidence 0.50)

    
    cmd_fstring = f"sudo -E deluge-console info --detailed --sort-reverse=time_added {'{{}}' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
    
    cmd_fstring = f"sudo -E deluge-console info --detailed --sort-reverse=time_added {{'' if ID is None else ID}} | perl -nE 'print if /^{field}:/'"
  257. 128 of 176 non-conventional identifiers are single-character (73%) (token pass, confidence 0.50)

  258. U+E0100 VARIATION SELECTOR SUPPLEMENT (invisible payload carrier, encodes byte 0x10) in source (raw pass, confidence 0.90)

    蟒 = 3
    x⟨U+E0100⟩ = 4
    មុ = 1
    Q̇_per_meter = 4
    likely benign LLM, confidence 0.85 Unicode identifier test fixture containing a variation selector supplement character.
    Reasoning

    The file is a formatter test for unicode identifiers, and the variation selector sits in an identifier used to test tricky unicode handling. Such characters in a test fixture are deliberate test input, though an invisible character in an identifier is worth noting.

  259. file mixes tab and space indentation (6 tab-indented and 72 space-indented lines) (raw pass, confidence 0.40)

    def single_line_backslashes1():
      """ content\     """
      return
  260. file mixes tab and space indentation (27 tab-indented and 634 space-indented lines) (raw pass, confidence 0.40)

    def doctest_simple():
        """
        Do cool stuff.
  261. file mixes tab and space indentation (28 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    def tab_argument(arg1: str) -> None:
    	"""
    	Arguments:
    		arg1: super duper arg with 2 tabs in front
  262. 55 of 126 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  263. file mixes tab and space indentation (2 tab-indented and 489 space-indented lines) (raw pass, confidence 0.40)

    lambda x: lambda y: lambda z: (
        x,
        y,
    z)  # Trailing
  264. `subprocess.check_call` called with `shell=True` and a literal command (ast pass, confidence 0.70)

    def foo():
        subprocess.check_call(f"rm -rf {' '.join(map(lambda object_name: os.path.join(dest_path, object_name), objects_to_remove))}", shell=True)
    
    def bar():
    likely benign LLM, confidence 0.88 Formatter test fixture using subprocess.check_call with shell=True on an f-string command.
    Reasoning

    This is a formatter fixture for lambda expressions; the shell=True call is never executed and the command is a formatting test case, not a real attack payload.

  265. `subprocess.check_call` called with `shell=True` and a literal command (ast pass, confidence 0.70)

    def foo():
        subprocess.check_call(f"rm -rf {' '.join(map(lambda object_name: max(candidate_paths, key=lambda candidate: os.path.join(dest_path, object_name, candidate)), objects_to_remove))}", shell=True)
    
    # Regression test for https://github.com/astral-sh/ruff/issues/25397
    likely benign LLM, confidence 0.88 Formatter test fixture with a shell=True subprocess call containing nested lambdas.
    Reasoning

    Same formatter lambda fixture as the neighboring finding; the shell call is syntax-only test input and is not executed.

  266. mean non-conventional identifier length 1.93 over 41 names (token pass, confidence 0.50)

  267. 239 of 558 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  268. line length 569 characters (raw pass, confidence 0.50)

    c1 = (("cicero"), ("Qui", "autem,", "si", "maxime", "hoc", "placeat,", "moderatius", "tamen", "id", "uolunt", "fieri,", "difficilem", "quandam", "temperantiam", "postulant", "in", "eo,", "quod", "semel", "admissum", "coerceri", "reprimique", "non", "potest,", "ut", "propemodum", "iustioribus", "utamur", "illis,", "qui"
  269. file mixes tab and space indentation (2 tab-indented and 129 space-indented lines) (raw pass, confidence 0.40)

    if not aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb:
        pass
    
    a = True
  270. mean non-conventional identifier length 1.00 over 41 names (token pass, confidence 0.50)

  271. file mixes tab and space indentation (1 tab-indented and 9 space-indented lines) (raw pass, confidence 0.40)

    def test():
     # fmt: off
     	a_very_small_indent
     	(
  272. mean non-conventional identifier length 1.30 over 27 names (token pass, confidence 0.50)

  273. file mixes tab and space indentation (1 tab-indented and 14 space-indented lines) (raw pass, confidence 0.40)

    if True:
        for i in range(10): print(i)  # fmt: skip
    
    # Multiple statements in body (should not apply - multiline)
  274. mean non-conventional identifier length 1.54 over 28 names (token pass, confidence 0.50)

  275. 80 of 98 non-conventional identifiers are single-character (82%) (token pass, confidence 0.50)

  276. file mixes tab and space indentation (22 tab-indented and 474 space-indented lines) (raw pass, confidence 0.40)

    match foo:  # dangling match comment
        case "bar":
            pass
  277. file mixes tab and space indentation (3 tab-indented and 44 space-indented lines) (raw pass, confidence 0.40)

    type \
    	X = int
    type X \
    	= int
  278. mean non-conventional identifier length 1.98 over 41 names (token pass, confidence 0.50)

  279. 25 of 39 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  280. 32 of 76 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  281. identifier `a𝐁c` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

    b'123a𝐁c'
    rb"a𝐁c123"
    b"""123a𝐁c"""
  282. identifier `a𝐁c123` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

    b'123a𝐁c'
    rb"a𝐁c123"
    b"""123a𝐁c"""
  283. identifier `a𝐁c` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

    rb"a𝐁c123"
    b"""123a𝐁c"""
  284. mean non-conventional identifier length 1.97 over 30 names (token pass, confidence 0.50)

  285. 17 of 30 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  286. mean non-conventional identifier length 1.73 over 52 names (token pass, confidence 0.50)

  287. mean non-conventional identifier length 1.73 over 75 names (token pass, confidence 0.50)

  288. 48 of 78 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  289. mean non-conventional identifier length 1.34 over 58 names (token pass, confidence 0.50)

  290. mean non-conventional identifier length 1.33 over 24 names (token pass, confidence 0.50)

  291. 16 of 40 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  292. mean non-conventional identifier length 1.86 over 21 names (token pass, confidence 0.50)

  293. 114 of 262 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  294. 100 of 249 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  295. file mixes tab and space indentation (6 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    type \
    	X = int
    type X \
    	= int
  296. identifier `aβ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

        fn non_ascii_identifier_flag() {
            let mut lexer = Lexer::new("a€\naβ = β\nascii", Mode::Module, TextSize::default());
            let mut flags = Vec::new();
            loop {
  297. identifier `a𝐁c` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

                        // test_err invalid_byte_literal
                        // b'123a𝐁c'
                        // rb"a𝐁c123"
                        // b"""123a𝐁c"""
  298. identifier `a𝐁c123` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

                        // b'123a𝐁c'
                        // rb"a𝐁c123"
                        // b"""123a𝐁c"""
                        StringType::Bytes(ast::BytesLiteral {
  299. identifier `a𝐁c` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

                        // rb"a𝐁c123"
                        // b"""123a𝐁c"""
                        StringType::Bytes(ast::BytesLiteral {
                            value: Box::new([]),
  300. info warn → info by review encoding-hex crates/ruff_python_parser/src/string.rs:939:78

    18 consecutive `\xNN` escapes (entropy 4.2 bits/byte) (raw pass, confidence 0.65)

    \x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\
    likely benign LLM, confidence 0.90 Parser test string literal enumerating byte escapes.
    Reasoning

    This is a Rust parser test string enumerating all byte values as escapes, used to test escape handling; the hex escapes are the expected content of a unit test.

  301. info warn → info by review encoding-escape-soup crates/ruff_python_parser/src/string.rs:939:247

    129 consecutive `\xNN` escapes (entropy 7.0 bits/byte) (raw pass, confidence 0.80)

    NOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\x
    likely benign LLM, confidence 0.90 Parser test string literal with a long run of high-byte hex escapes.
    Reasoning

    Continuation of the same parser test byte-escape table; it is deliberate test data for the string parser.

  302. info warn → info by review encoding-hex crates/ruff_python_parser/src/string.rs:947:78

    18 consecutive `\xNN` escapes (entropy 4.2 bits/byte) (raw pass, confidence 0.65)

    \x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\
    likely benign LLM, confidence 0.90 Second parser test string enumerating byte escapes.
    Reasoning

    Same parser test pattern repeated in a second test string; it enumerates byte values to exercise escape parsing.

  303. info warn → info by review encoding-escape-soup crates/ruff_python_parser/src/string.rs:947:247

    129 consecutive `\xNN` escapes (entropy 7.0 bits/byte) (raw pass, confidence 0.80)

    NOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\x
    likely benign LLM, confidence 0.90 Parser test string with long run of high-byte hex escapes.
    Reasoning

    Continuation of the repeated parser test byte-escape table; expected test data in a Rust string parser.

  304. identifier `a𝐁c` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

        fn test_invalid_byte_literal_error() {
            let source = r"b'123a𝐁c'";
            let error = parse_suite(source).unwrap_err();
            insta::assert_debug_snapshot!(error);
  305. identifier `πr` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

            assert!(is_identifier("кириллица"));
            assert!(is_identifier("πr"));
            assert!(!is_identifier(""));
            assert!(!is_identifier("percentile_co³t"));
  306. identifier `αbc` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    /// assert!(is_lowercase("_"));
    /// assert!(is_lowercase("αbc"));
    /// assert!(!is_lowercase("αBC"));
    /// assert!(!is_lowercase("Ωbc"));
  307. info unicode-mixed-script crates/ruff_python_stdlib/src/str.rs:17:27

    identifier `αbc` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    /// assert!(is_lowercase("_"));
    /// assert!(is_lowercase("αbc"));
    /// assert!(!is_lowercase("αBC"));
    /// assert!(!is_lowercase("Ωbc"));
  308. identifier `αBC` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    /// assert!(is_lowercase("αbc"));
    /// assert!(!is_lowercase("αBC"));
    /// assert!(!is_lowercase("Ωbc"));
    /// ```
  309. info unicode-mixed-script crates/ruff_python_stdlib/src/str.rs:18:28

    identifier `αBC` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    /// assert!(is_lowercase("αbc"));
    /// assert!(!is_lowercase("αBC"));
    /// assert!(!is_lowercase("Ωbc"));
    /// ```
  310. info unicode-mixed-script crates/ruff_python_stdlib/src/str.rs:19:28

    identifier `Ωbc` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    /// assert!(!is_lowercase("αBC"));
    /// assert!(!is_lowercase("Ωbc"));
    /// ```
    pub fn is_lowercase(s: &str) -> bool {
  311. info unicode-mixed-script crates/ruff_python_stdlib/src/str.rs:54:27

    identifier `ΩBC` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    /// assert!(is_uppercase("_"));
    /// assert!(is_uppercase("ΩBC"));
    /// assert!(!is_uppercase("Ωbc"));
    /// assert!(!is_uppercase("αBC"));
  312. info unicode-mixed-script crates/ruff_python_stdlib/src/str.rs:55:28

    identifier `Ωbc` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    /// assert!(is_uppercase("ΩBC"));
    /// assert!(!is_uppercase("Ωbc"));
    /// assert!(!is_uppercase("αBC"));
    /// ```
  313. identifier `αBC` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    /// assert!(!is_uppercase("Ωbc"));
    /// assert!(!is_uppercase("αBC"));
    /// ```
    pub fn is_uppercase(s: &str) -> bool {
  314. info unicode-mixed-script crates/ruff_python_stdlib/src/str.rs:56:28

    identifier `αBC` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    /// assert!(!is_uppercase("Ωbc"));
    /// assert!(!is_uppercase("αBC"));
    /// ```
    pub fn is_uppercase(s: &str) -> bool {
  315. identifier `ρ` contains homoglyph candidates: ρ (03C1)→p (in string/comment) (raw pass, confidence 0.35)

                # which could be confused for "-", "p", and "*", respectively.
                allowed-confusables = ["−", "ρ", "∗"]
            "#
        )]
  316. info unicode-mixed-script crates/ty_ide/src/selection_range.rs:415:6

    identifier `a𝐁` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

                    r#"
    b"123a𝐁<CURSOR>c"
    "#,
                )
  317. identifier `a𝐁c` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

            1 | /
            2 | | b"123a𝐁c"
              | |__________^
  318. identifier `a𝐁c` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

              |
            2 | b"123a𝐁c"
              | ^^^^^^^^^
            "#);
  319. mean non-conventional identifier length 1.00 over 26 names (token pass, confidence 0.50)

  320. mean non-conventional identifier length 1.31 over 26 names (token pass, confidence 0.50)

  321. line length 2903 characters (raw pass, confidence 0.65)

    {**{0:1},**{1:2},**{2:3},**{3:4},**{4:5},**{5:6},**{6:7},**{7:8},**{8:9},**{9:10},**{10:11},**{11:12},**{12:13},**{13:14},**{14:15},**{15:16},**{16:17},**{17:18},**{18:19},**{19:20},**{20:21},**{21:22},**{22:23},**{23:24},**{24:25},**{25:26},**{26:27},**{27:28},**{28:29},**{29:30},**{30:31},**{31:32},**{32:33},**{33:34
    likely benign LLM, confidence 0.90 Very long dict-unpacking expression used as a type-checker test case.
    Reasoning

    A long single-line dict literal built from unpacking is a stress test corpus input for a type checker; no obfuscation or malicious behavior is evident.

  322. mean non-conventional identifier length 1.29 over 24 names (token pass, confidence 0.50)

  323. mean non-conventional identifier length 1.67 over 21 names (token pass, confidence 0.50)

  324. 20 of 34 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  325. `builtins.__import__ = ...` — patches a built-in for every importer of this module (ast pass, confidence 0.95)

    
    builtins.__import__: Callable[..., object] = __import__
    likely benign LLM, confidence 0.85 Test fixture that assigns builtins.__import__ with an annotation.
    Reasoning

    This is a test corpus file for annotation handling; assigning builtins.__import__ is a deliberate semantic fixture, not an attack in this repo context, though the pattern itself is what a real supply-chain patch would look like.

  326. [embedded python] 18 of 34 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  327. [embedded python] 24 of 60 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  328. [embedded python] 41 of 61 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  329. [embedded python] 18 of 37 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  330. [embedded python] 17 of 38 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  331. [embedded python] 23 of 37 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  332. [embedded python] 17 of 40 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  333. [embedded python] 18 of 42 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  334. [embedded python] 90 of 140 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  335. [embedded python] 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  336. [embedded python] 27 of 42 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  337. info critical → info by review dynamic-import crates/ty_python_semantic/resources/mdtest/call/dunder_import.md:33:17

    [embedded python] `__import__` called on a non-literal expression (ast pass, confidence 0.70)

        reveal_type(name)  # revealed: Literal["sys", "os"]
        reveal_type(__import__(name))  # revealed: ModuleType
    
        if flag:
    likely benign LLM, confidence 0.85 Documentation test calling __import__ on a variable to check revealed type.
    Reasoning

    Markdown mdtest of how the type checker reveals types for __import__ on a non-literal; it is a documented test case, not a dropper.

  338. [embedded python] 13 of 31 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  339. [embedded python] 16 of 34 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  340. [embedded python] 15 of 31 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  341. [embedded python] 16 of 35 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  342. [embedded python] 21 of 43 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  343. [embedded python] 19 of 33 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  344. [embedded python] 22 of 51 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  345. [embedded python] 29 of 67 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  346. [embedded python] 17 of 36 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  347. [embedded python] 175 of 362 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  348. [embedded python] 36 of 77 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  349. [embedded python] mean non-conventional identifier length 1.55 over 47 names (token pass, confidence 0.50)

  350. [embedded python] 17 of 37 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  351. [embedded python] 46 of 89 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  352. [embedded python] 21 of 50 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  353. [embedded python] 19 of 39 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  354. [embedded python] 17 of 36 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  355. [embedded python] 18 of 31 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  356. [embedded python] 17 of 42 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  357. [embedded python] 14 of 32 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  358. [embedded python] 26 of 40 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  359. [embedded python] 28 of 40 non-conventional identifiers are single-character (70%) (token pass, confidence 0.50)

  360. [embedded python] 26 of 41 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  361. [embedded python] 39 of 64 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  362. [embedded python] 30 of 42 non-conventional identifiers are single-character (71%) (token pass, confidence 0.50)

  363. [embedded python] 16 of 33 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  364. [embedded python] 19 of 34 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  365. [embedded python] 24 of 49 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  366. [embedded python] 31 of 74 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  367. [embedded python] 17 of 31 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  368. [embedded python] 14 of 31 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  369. [embedded python] 23 of 54 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  370. [embedded python] 72 of 170 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  371. [embedded python] 14 of 31 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  372. [embedded python] 17 of 42 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  373. [embedded python] 18 of 42 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  374. [embedded python] 22 of 52 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  375. [embedded python] 21 of 44 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  376. [embedded python] 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  377. [embedded python] 15 of 31 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  378. [embedded python] 14 of 33 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  379. [embedded python] 17 of 42 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  380. [embedded python] 161 of 351 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  381. [embedded python] 155 of 337 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  382. [embedded python] 156 of 343 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  383. [embedded python] 20 of 34 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  384. [embedded python] 22 of 46 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  385. [embedded python] 16 of 38 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  386. [embedded python] 17 of 36 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  387. [embedded python] 15 of 30 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  388. [embedded python] 29 of 69 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  389. [embedded python] 22 of 38 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  390. [embedded python] 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  391. [embedded python] 57 of 106 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  392. [embedded python] 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  393. [embedded python] 28 of 63 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  394. [embedded python] 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  395. [embedded python] 15 of 32 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  396. [embedded python] 28 of 62 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  397. [embedded python] 20 of 42 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  398. [embedded python] 28 of 69 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  399. [embedded python] 14 of 32 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  400. [embedded python] 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  401. [embedded python] 71 of 107 non-conventional identifiers are single-character (66%) (token pass, confidence 0.50)

  402. [embedded python] 17 of 36 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  403. [embedded python] 51 of 101 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  404. [embedded python] 158 of 341 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  405. [embedded python] 158 of 340 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  406. [embedded python] 159 of 352 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  407. [embedded python] 163 of 351 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  408. [embedded python] 40 of 82 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  409. [embedded python] 14 of 32 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  410. [embedded python] 27 of 67 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  411. [embedded python] 25 of 60 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  412. [embedded python] 15 of 36 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  413. [embedded python] 36 of 69 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  414. [embedded python] 29 of 63 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  415. [embedded python] 14 of 33 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  416. [embedded python] mean non-conventional identifier length 1.82 over 22 names (token pass, confidence 0.50)

  417. [embedded python] 16 of 32 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  418. [embedded python] 13 of 32 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  419. [embedded python] 18 of 43 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  420. info critical → info by review builtins-write crates/ty_python_semantic/resources/mdtest/import/builtins.md:329:1

    [embedded python] `builtins.foo = ...` — patches a built-in for every importer of this module (ast pass, confidence 0.95)

    
    builtins.foo = 123
    builtins.bar = 456  # error: [unresolved-attribute]
    builtins.baz = 789  # error: [invalid-assignment]
    likely benign LLM, confidence 0.85 Test case assigning attributes on builtins module with expected errors.
    Reasoning

    Embedded python in a type-checker mdtest exercising error reporting for builtins assignments; the lines carry expected-error comments.

  421. info critical → info by review builtins-write crates/ty_python_semantic/resources/mdtest/import/builtins.md:330:1

    [embedded python] `builtins.bar = ...` — patches a built-in for every importer of this module (ast pass, confidence 0.95)

    builtins.foo = 123
    builtins.bar = 456  # error: [unresolved-attribute]
    builtins.baz = 789  # error: [invalid-assignment]
    builtins.chr = lambda x: str(x)  # error: [invalid-assignment]
    likely benign LLM, confidence 0.85 Test case assigning builtins.bar with expected error.
    Reasoning

    Same mdtest fixture with inline error expectations; it validates diagnostics, not real patching.

  422. info critical → info by review builtins-write crates/ty_python_semantic/resources/mdtest/import/builtins.md:331:1

    [embedded python] `builtins.baz = ...` — patches a built-in for every importer of this module (ast pass, confidence 0.95)

    builtins.bar = 456  # error: [unresolved-attribute]
    builtins.baz = 789  # error: [invalid-assignment]
    builtins.chr = lambda x: str(x)  # error: [invalid-assignment]
    builtins.chr = 10
    likely benign LLM, confidence 0.85 Test case assigning builtins.baz with expected error.
    Reasoning

    Same mdtest fixture with inline error expectations; it validates diagnostics, not real patching.

  423. info critical → info by review builtins-write crates/ty_python_semantic/resources/mdtest/import/builtins.md:332:1

    [embedded python] `builtins.chr = ...` — patches a built-in for every importer of this module (ast pass, confidence 0.95)

    builtins.baz = 789  # error: [invalid-assignment]
    builtins.chr = lambda x: str(x)  # error: [invalid-assignment]
    builtins.chr = 10
    likely benign LLM, confidence 0.85 Test case reassigning builtins.chr with expected error.
    Reasoning

    Same mdtest fixture; the assignment to builtins.chr is annotated with an expected invalid-assignment error.

  424. info critical → info by review builtins-write crates/ty_python_semantic/resources/mdtest/import/builtins.md:333:1

    [embedded python] `builtins.chr = ...` — patches a built-in for every importer of this module (ast pass, confidence 0.95)

    builtins.chr = lambda x: str(x)  # error: [invalid-assignment]
    builtins.chr = 10
    likely benign LLM, confidence 0.85 Second builtins.chr reassignment in the mdtest fixture.
    Reasoning

    Same mdtest fixture; repeated builtins.chr assignment is part of the diagnostic test.

  425. [embedded python] 23 of 30 non-conventional identifiers are single-character (77%) (token pass, confidence 0.50)

  426. [embedded python] mean non-conventional identifier length 1.93 over 27 names (token pass, confidence 0.50)

  427. info warn → info by review unicode-mixed-script crates/ty_python_semantic/resources/mdtest/import/star.md:1023:1

    [embedded python] identifier `__aℓℓ__` mixes scripts: Latin + Other (raw pass, confidence 0.80)

    __all__ = ["first"]
    __aℓℓ__.append("second")
    ```
    likely benign LLM, confidence 0.80 Identifier with mixed script used in a star-import test.
    Reasoning

    A Latin/other script mix in an identifier is a deliberate homoglyph test in a star-import mdtest; it is a test of unicode handling rather than an attack in this context.

  428. [embedded python] 40 of 90 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  429. [embedded python] 34 of 65 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  430. [embedded python] 19 of 34 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  431. [embedded python] 19 of 34 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  432. [embedded python] 21 of 49 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  433. [embedded python] 17 of 37 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  434. [embedded python] 20 of 43 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  435. [embedded python] 19 of 46 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  436. [embedded python] 58 of 139 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  437. [embedded python] 68 of 109 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  438. [embedded python] 44 of 84 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  439. [embedded python] 32 of 67 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  440. [embedded python] U+200B ZERO WIDTH SPACE in source (in string/comment) (raw pass, confidence 0.45)

            # In this case, it may seem like we can narrow it down to `int`,
            # but different values ⟨U+200B⟩⟨U+200B⟩may be reassigned to `x` and `y` in another place.
            reveal_type(c.y)  # revealed: int | None
  441. [embedded python] U+200B ZERO WIDTH SPACE in source (in string/comment) (raw pass, confidence 0.45)

            # In this case, it may seem like we can narrow it down to `int`,
            # but different values ⟨U+200B⟩⟨U+200B⟩may be reassigned to `x` and `y` in another place.
            reveal_type(c.y)  # revealed: int | None
  442. [embedded python] 36 of 71 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  443. [embedded python] 25 of 62 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  444. [embedded python] 51 of 89 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  445. [embedded python] 31 of 77 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  446. [embedded python] 14 of 30 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  447. info critical → info by review dynamic-execution crates/ty_python_semantic/resources/mdtest/pep613_type_aliases.md:818:28

    [embedded python] `eval` at module scope (runs on import) on a non-literal expression (ast pass, confidence 0.80)

    # typing conformance cases:
    BadTypeAlias1: TypeAlias = eval("".join(map(chr, [105, 110, 116])))  # error: [invalid-type-form]
    BadTypeAlias2: TypeAlias = [int, str]  # error: [invalid-type-form]
    BadTypeAlias3: TypeAlias = ((int, str),)  # error: [invalid-type-form]
    likely benign LLM, confidence 0.85 eval call inside a PEP 613 conformance test case.
    Reasoning

    eval used in a typing conformance test case expecting an invalid-type-form error; it is a test fixture with a literal string argument.

  448. [embedded python] 18 of 36 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  449. [embedded python] 13 of 30 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  450. [embedded python] 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  451. identifier `Dᵧ` mixes scripts: Latin + Other (raw pass, confidence 0.80)

    | E5   | `∃X ∈ {int, str}. C(X, Y, Z)`    | Solutions remain paired with each choice    |
    | E6   | `∀Y ∈ Dᵧ. ∃X ∈ Dₓ. R(X, Y)`      | `X` may depend on the choice of `Y`         |
    
    ```toml
    likely benign LLM, confidence 0.85 Mathematical subscript identifier in a documentation table.
    Reasoning

    Subscript Unicode letters in a markdown table of quantifier notation; mathematical notation, not identifiers used for evasion.

  452. identifier `Dₓ` mixes scripts: Latin + Other (raw pass, confidence 0.80)

    | E5   | `∃X ∈ {int, str}. C(X, Y, Z)`    | Solutions remain paired with each choice    |
    | E6   | `∀Y ∈ Dᵧ. ∃X ∈ Dₓ. R(X, Y)`      | `X` may depend on the choice of `Y`         |
    
    ```toml
    likely benign LLM, confidence 0.85 Mathematical subscript identifier in a documentation table.
    Reasoning

    Same notation table; subscript letter is mathematical typography in documentation.

  453. [embedded python] 33 of 58 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  454. [embedded python] 18 of 42 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  455. [embedded python] 33 of 65 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  456. info warn → info by review unicode-zero-width crates/ty_python_semantic/resources/mdtest/typed_dict.md:368:23

    U+200B ZERO WIDTH SPACE in source (raw pass, confidence 0.75)

    
    Also, the value types ⟨U+200B⟩⟨U+200B⟩declared in a `TypedDict` affect generic call inference:
    
    ```py
    likely benign LLM, confidence 0.85 Zero-width space in prose text of a markdown document.
    Reasoning

    A zero-width space in prose in a markdown test doc is a typographic artifact, not code hiding anything.

  457. info warn → info by review unicode-zero-width crates/ty_python_semantic/resources/mdtest/typed_dict.md:368:26

    U+200B ZERO WIDTH SPACE in source (raw pass, confidence 0.75)

    
    Also, the value types ⟨U+200B⟩⟨U+200B⟩declared in a `TypedDict` affect generic call inference:
    
    ```py
    likely benign LLM, confidence 0.85 Stray zero-width space in a markdown documentation sentence about TypedDict inference.
    Reasoning

    A zero-width space appears in prose inside a markdown test file, likely a stray typo from editing. It is not used to hide code or evade detection, and the surrounding text is ordinary documentation.

  458. [embedded python] 17 of 42 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  459. [embedded python] 19 of 42 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  460. [embedded python] 15 of 31 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  461. [embedded python] 72 of 152 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  462. [embedded python] 14 of 33 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  463. U+00AD SOFT HYPHEN in source (in string/comment) (raw pass, confidence 0.45)

        /// You must provide the `inherited_generic_context` that we should use for the `__new__` or
        /// `__init__` member. This is inherited from the containing class -⟨U+00AD⟩but importantly, from the
        /// class that the lookup is being performed on, and not the class containing the (possibly
        /// inherited) member.
  464. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given constraints `α ≤ T` and `T ≤ β`, `α ≤ β` must also hold. If those bounds contain
            // other typevars, we can infer additional constraints. (α and U won't be bare typevars,
            // since those will be modeled by `TypeVarRange` bounds.)
  465. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given constraints `α ≤ T` and `T ≤ β`, `α ≤ β` must also hold. If those bounds contain
            // other typevars, we can infer additional constraints. (α and U won't be bare typevars,
            // since those will be modeled by `TypeVarRange` bounds.)
  466. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            // Given constraints `α ≤ T` and `T ≤ β`, `α ≤ β` must also hold. If those bounds contain
            // other typevars, we can infer additional constraints. (α and U won't be bare typevars,
            // since those will be modeled by `TypeVarRange` bounds.)
            //
  467. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            // To handle all of these cases, we perform a constraint set assignability check to see
            // when `α ≤ β`. This gives us a constraint set, which should be the rhs of the sequent
            // implication. (That is, this check directly encodes `(α ≤ T) ∧ (T ≤ β) → (α ≤ β)` as an
  468. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            // when `α ≤ β`. This gives us a constraint set, which should be the rhs of the sequent
            // implication. (That is, this check directly encodes `(α ≤ T) ∧ (T ≤ β) → (α ≤ β)` as an
            // implication.)
  469. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            // when `α ≤ β`. This gives us a constraint set, which should be the rhs of the sequent
            // implication. (That is, this check directly encodes `(α ≤ T) ∧ (T ≤ β) → (α ≤ β)` as an
            // implication.)
  470. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given constraints `T = α` and `T = β`, `α = β` must also hold. If those bounds contain
            // other typevars, we can infer additional constraints.
            if lower.bound().is_static_sequent_eligible(db, env)
  471. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given constraints `T = α` and `T = β`, `α = β` must also hold. If those bounds contain
            // other typevars, we can infer additional constraints.
            if lower.bound().is_static_sequent_eligible(db, env)
  472. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `α ≤ T` and `β ≤ U`, if α contains U covariantly, we can substitute β for U:
            //
            //   (Co[U] ≤ T) ∧ (β ≤ U) ⇒ (Co[β] ≤ T)
  473. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `α ≤ T` and `β ≤ U`, if α contains U covariantly, we can substitute β for U:
            //
            //   (Co[U] ≤ T) ∧ (β ≤ U) ⇒ (Co[β] ≤ T)
  474. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `T ≤ α` and `U ≤ β`, if α contains U covariantly, we can substitute β for U:
            //
            //   (T ≤ Co[U]) ∧ (U ≤ β) ⇒ (T ≤ Co[β])
  475. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `T ≤ α` and `U ≤ β`, if α contains U covariantly, we can substitute β for U:
            //
            //   (T ≤ Co[U]) ∧ (U ≤ β) ⇒ (T ≤ Co[β])
  476. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `T = α` and `U = β`, if α contains U covariantly, we can substitute β for U:
            //
            //   (T = Co[U]) ∧ (U = β) ⇒ (T = Co[β])
  477. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `T = α` and `U = β`, if α contains U covariantly, we can substitute β for U:
            //
            //   (T = Co[U]) ∧ (U = β) ⇒ (T = Co[β])
  478. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // Given `α ≤ T` and `U ≤ β`, if α contains U contravariantly, substitute β for U:
            //
            //   (Contra[U] ≤ T) ∧ (U ≤ β) ⇒ (Contra[β] ≤ T)
  479. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // Given `α ≤ T` and `U ≤ β`, if α contains U contravariantly, substitute β for U:
            //
            //   (Contra[U] ≤ T) ∧ (U ≤ β) ⇒ (Contra[β] ≤ T)
  480. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // If β contains T contravariantly, substitute α for T:
            //
            //   (α ≤ T) ∧ (U ≤ Contra[T]) ⇒ (U ≤ Contra[α])
  481. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            //
            //   (α ≤ T) ∧ (U ≤ Contra[T]) ⇒ (U ≤ Contra[α])
            if upper
                .bound()
  482. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            //
            //   (α ≤ T) ∧ (U ≤ Contra[T]) ⇒ (U ≤ Contra[α])
            if upper
                .bound()
  483. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `T ~ α` and `U = β`, if α contains U invariantly, we can substitute β for U. For
            // instance,
            //
  484. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `T ~ α` and `U = β`, if α contains U invariantly, we can substitute β for U. For
            // instance,
            //
  485. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `α ≤ T` and `S ≤ U`, if α contains U covariantly, we can substitute S for U. For
            // instance,
            //
  486. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `α ≤ T` and `S ≤ U`, if α contains U covariantly, we can substitute S for U. For
            // instance,
            //
  487. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `T ≤ α` and `U ≤ S`, if α contains U covariantly, we can substitute S for U. For
            // instance,
            //
  488. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `T ≤ α` and `U ≤ S`, if α contains U covariantly, we can substitute S for U. For
            // instance,
            //
  489. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `T = α` and `S = U`, if α contains S covariantly, we can substitute U for S. For
            // instance,
            //
  490. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `T = α` and `S = U`, if α contains S covariantly, we can substitute U for S. For
            // instance,
            //
  491. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `α ≤ T` and `U ≤ S`, if α contains U contravariantly, we can substitute S for U
            // and flip the constraint. For instance,
            //
  492. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `α ≤ T` and `U ≤ S`, if α contains U contravariantly, we can substitute S for U
            // and flip the constraint. For instance,
            //
  493. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `T ≤ α` and `S ≤ U`, if α contains U contravariantly, we can substitute S for U
            // and flip the constraint. For instance,
            //
  494. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `T ≤ α` and `S ≤ U`, if α contains U contravariantly, we can substitute S for U
            // and flip the constraint. For instance,
            //
  495. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `T = α` and `S = U`, if α contains U contravariantly, we can substitute S for U
            // and flip the constraint. For instance,
            //
  496. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `T = α` and `S = U`, if α contains U contravariantly, we can substitute S for U
            // and flip the constraint. For instance,
            //
  497. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `T ~ α` and `S = U`, if α contains U invariantly, we can substitute S for U. For
            // instance,
            //
  498. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given `T ~ α` and `S = U`, if α contains U invariantly, we can substitute S for U. For
            // instance,
            //
  499. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // We can infer sequents from `α ≤ T` and `β ≤ U` if α _contains_ U and/or β contains T.
            if !self.typevar.is_same_typevar_as(db, other.typevar) {
                Constraint::add_covariant_lower_tightened_sequent(db, env, map, self, other);
  500. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // We can infer sequents from `α ≤ T` and `β ≤ U` if α _contains_ U and/or β contains T.
            if !self.typevar.is_same_typevar_as(db, other.typevar) {
                Constraint::add_covariant_lower_tightened_sequent(db, env, map, self, other);
  501. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // (β ≤ α) ⇒ ((α ≤ T) ⇒ (β ≤ T))
            if other_lower.is_constraint_set_subtype_of(db, env, lower) {
                map.add_single_implication(self.into(), other.into());
  502. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // (β ≤ α) ⇒ ((α ≤ T) ⇒ (β ≤ T))
            if other_lower.is_constraint_set_subtype_of(db, env, lower) {
                map.add_single_implication(self.into(), other.into());
  503. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // (α ≤ β) ⇒ ((β ≤ T) ⇒ (α ≤ T))
            if lower.is_constraint_set_subtype_of(db, env, other_lower) {
                map.add_single_implication(other.into(), self.into());
  504. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // (α ≤ β) ⇒ ((β ≤ T) ⇒ (α ≤ T))
            if lower.is_constraint_set_subtype_of(db, env, other_lower) {
                map.add_single_implication(other.into(), self.into());
  505. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // `(α ≤ T) ∧ (β ≤ T)` is equivalent to `(α | β) ≤ T`. We do not create lower bounds that
            // are unions, so only add sequents when the union simplifies away.
            let combined = possibly_reversed_union(db, env, reversed, self.bound, other.bound);
  506. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // `(α ≤ T) ∧ (β ≤ T)` is equivalent to `(α | β) ≤ T`. We do not create lower bounds that
            // are unions, so only add sequents when the union simplifies away.
            let combined = possibly_reversed_union(db, env, reversed, self.bound, other.bound);
  507. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // We can infer sequents from `α ≤ T` and `U ≤ β` if α _contains_ U and/or β contains T.
            if !self.typevar.is_same_typevar_as(db, other.typevar) {
                Constraint::add_contravariant_tightened_sequent(db, env, map, self, other);
  508. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // We can infer sequents from `α ≤ T` and `U ≤ β` if α _contains_ U and/or β contains T.
            if !self.typevar.is_same_typevar_as(db, other.typevar) {
                Constraint::add_contravariant_tightened_sequent(db, env, map, self, other);
  509. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // `(α ≤ T) ∧ (T ≤ β)` simplifies to `T = α` when `α = β`. For ordinary typevars, only
            // simplify when the materialized bounds are the same `Type`; checking semantic equivalence
            // can recursively expand protocol members. ParamSpec bounds still need the semantic check
  510. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // `(α ≤ T) ∧ (T ≤ β)` simplifies to `T = α` when `α = β`. For ordinary typevars, only
            // simplify when the materialized bounds are the same `Type`; checking semantic equivalence
            // can recursively expand protocol members. ParamSpec bounds still need the semantic check
  511. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // `(α ≤ T) ∧ (T ≤ β)` simplifies to `T = α` when `α = β`. For ordinary typevars, only
            // simplify when the materialized bounds are the same `Type`; checking semantic equivalence
            // can recursively expand protocol members. ParamSpec bounds still need the semantic check
  512. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            // because callable types with different return types can represent the same parameter list.
            // (We don't need to add the projection implication `(T = α) ⇒ (α ≤ T)`, since anything we
            // can derive from `α ≤ T` we can also derive from `T = α`.)
  513. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            // because callable types with different return types can represent the same parameter list.
            // (We don't need to add the projection implication `(T = α) ⇒ (α ≤ T)`, since anything we
            // can derive from `α ≤ T` we can also derive from `T = α`.)
  514. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            // (We don't need to add the projection implication `(T = α) ⇒ (α ≤ T)`, since anything we
            // can derive from `α ≤ T` we can also derive from `T = α`.)
            let lower = self.bound.bottom_materialization(db, env);
            let upper = other.bound.top_materialization(db, env);
  515. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            // (We don't need to add the projection implication `(T = α) ⇒ (α ≤ T)`, since anything we
            // can derive from `α ≤ T` we can also derive from `T = α`.)
            let lower = self.bound.bottom_materialization(db, env);
            let upper = other.bound.top_materialization(db, env);
  516. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // We can infer sequents from `α ≤ T` and `U = β` if α _contains_ U and/or β contains T.
            if !self.typevar.is_same_typevar_as(db, other.typevar) {
                Constraint::add_covariant_lower_tightened_sequent(db, env, map, self, other);
  517. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // We can infer sequents from `α ≤ T` and `U = β` if α _contains_ U and/or β contains T.
            if !self.typevar.is_same_typevar_as(db, other.typevar) {
                Constraint::add_covariant_lower_tightened_sequent(db, env, map, self, other);
  518. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // (α ≤ β) ⇒ ((T = β) ⇒ (α ≤ T))
            if self
                .bound
  519. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // (α ≤ β) ⇒ ((T = β) ⇒ (α ≤ T))
            if self
                .bound
  520. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // Given constraints `α ≤ T` and `T = β`, `α ≤ β` must also hold. If those bounds contain
            // other typevars, we can infer additional constraints.
            Constraint::add_sequents_for_range(db, env, map, self, other);
  521. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // Given constraints `α ≤ T` and `T = β`, `α ≤ β` must also hold. If those bounds contain
            // other typevars, we can infer additional constraints.
            Constraint::add_sequents_for_range(db, env, map, self, other);
  522. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given constraints `α ≤ T` and `T ≤ U`, `α ≤ U` must also hold.
            if self.typevar.is_same_typevar_as(db, other.left) {
                let provenance = ConstraintProvenance::derived(self.provenance, other.provenance);
  523. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given constraints `α ≤ T` and `T ≤ U`, `α ≤ U` must also hold.
            if self.typevar.is_same_typevar_as(db, other.left) {
                let provenance = ConstraintProvenance::derived(self.provenance, other.provenance);
  524. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // We can infer sequents from `α ≤ T` and `S ≤ U` if α _contains_ U.
            Constraint::add_covariant_lower_weakened_sequent(db, env, map, self, other);
            Constraint::add_contravariant_lower_weakened_sequent(db, env, map, self, other);
  525. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // We can infer sequents from `α ≤ T` and `S ≤ U` if α _contains_ U.
            Constraint::add_covariant_lower_weakened_sequent(db, env, map, self, other);
            Constraint::add_contravariant_lower_weakened_sequent(db, env, map, self, other);
  526. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given constraints `α ≤ T` and `T = U`, `α ≤ U` must also hold.
            let other_typevar = if self.typevar.is_same_typevar_as(db, other.left) {
                Some(other.right)
  527. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given constraints `α ≤ T` and `T = U`, `α ≤ U` must also hold.
            let other_typevar = if self.typevar.is_same_typevar_as(db, other.left) {
                Some(other.right)
  528. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // We can infer sequents from `α ≤ T` and `S ≤ U` if α _contains_ U.
            map.add_grouped_sequents(other, |map, other| {
                let reversed = other.reverse();
  529. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // We can infer sequents from `α ≤ T` and `S ≤ U` if α _contains_ U.
            map.add_grouped_sequents(other, |map, other| {
                let reversed = other.reverse();
  530. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // We can infer sequents from `T ≤ α` and `U ≤ β` if α _contains_ U and/or β contains T.
            if !self.typevar.is_same_typevar_as(db, other.typevar) {
                Constraint::add_covariant_upper_tightened_sequent(db, env, map, self, other);
  531. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // We can infer sequents from `T ≤ α` and `U ≤ β` if α _contains_ U and/or β contains T.
            if !self.typevar.is_same_typevar_as(db, other.typevar) {
                Constraint::add_covariant_upper_tightened_sequent(db, env, map, self, other);
  532. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // (α ≤ β) ⇒ ((T ≤ α) ⇒ (T ≤ β))
            if upper.is_constraint_set_subtype_of(db, env, other_upper) {
                map.add_single_implication(self.into(), other.into());
  533. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // (α ≤ β) ⇒ ((T ≤ α) ⇒ (T ≤ β))
            if upper.is_constraint_set_subtype_of(db, env, other_upper) {
                map.add_single_implication(self.into(), other.into());
  534. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // (β ≤ α) ⇒ ((T ≤ β) ⇒ (T ≤ α))
            if other_upper.is_constraint_set_subtype_of(db, env, upper) {
                map.add_single_implication(other.into(), self.into());
  535. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // (β ≤ α) ⇒ ((T ≤ β) ⇒ (T ≤ α))
            if other_upper.is_constraint_set_subtype_of(db, env, upper) {
                map.add_single_implication(other.into(), self.into());
  536. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // `(T ≤ α) ∧ (T ≤ β)` is equivalent to `T ≤ (α & β)`. We do not create upper bounds that
            // are intersections, so only add sequents when the intersection simplifies away.
            let combined = possibly_reversed_intersection(db, env, reversed, self.bound, other.bound);
  537. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // `(T ≤ α) ∧ (T ≤ β)` is equivalent to `T ≤ (α & β)`. We do not create upper bounds that
            // are intersections, so only add sequents when the intersection simplifies away.
            let combined = possibly_reversed_intersection(db, env, reversed, self.bound, other.bound);
  538. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // We can infer sequents from `T ≤ α` and `U = β` if α _contains_ U and/or β contains T.
            if !self.typevar.is_same_typevar_as(db, other.typevar) {
                Constraint::add_covariant_upper_tightened_sequent(db, env, map, self, other);
  539. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // We can infer sequents from `T ≤ α` and `U = β` if α _contains_ U and/or β contains T.
            if !self.typevar.is_same_typevar_as(db, other.typevar) {
                Constraint::add_covariant_upper_tightened_sequent(db, env, map, self, other);
  540. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // (β ≤ α) ⇒ ((T = β) ⇒ (T ≤ α))
            if other
                .bound
  541. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // (β ≤ α) ⇒ ((T = β) ⇒ (T ≤ α))
            if other
                .bound
  542. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // Given constraints `T ≤ α` and `T = β`, `α ≤ β` must also hold. If those bounds contain
            // other typevars, we can infer additional constraints.
            Constraint::add_sequents_for_range(db, env, map, other, self);
  543. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // Given constraints `T ≤ α` and `T = β`, `α ≤ β` must also hold. If those bounds contain
            // other typevars, we can infer additional constraints.
            Constraint::add_sequents_for_range(db, env, map, other, self);
  544. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given constraints `T ≤ α` and `U ≤ T`, `U ≤ α` must also hold.
            if self.typevar.is_same_typevar_as(db, other.right) {
                let provenance = ConstraintProvenance::derived(self.provenance, other.provenance);
  545. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given constraints `T ≤ α` and `U ≤ T`, `U ≤ α` must also hold.
            if self.typevar.is_same_typevar_as(db, other.right) {
                let provenance = ConstraintProvenance::derived(self.provenance, other.provenance);
  546. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // We can infer sequents from `T ≤ α` and `S ≤ U` if α _contains_ S.
            Constraint::add_covariant_upper_weakened_sequent(db, env, map, self, other);
            Constraint::add_contravariant_upper_weakened_sequent(db, env, map, self, other);
  547. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // We can infer sequents from `T ≤ α` and `S ≤ U` if α _contains_ S.
            Constraint::add_covariant_upper_weakened_sequent(db, env, map, self, other);
            Constraint::add_contravariant_upper_weakened_sequent(db, env, map, self, other);
  548. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given constraints `T ≤ α` and `U = T`, `U ≤ α` must also hold.
            let other_typevar = if self.typevar.is_same_typevar_as(db, other.left) {
                Some(other.right)
  549. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given constraints `T ≤ α` and `U = T`, `U ≤ α` must also hold.
            let other_typevar = if self.typevar.is_same_typevar_as(db, other.left) {
                Some(other.right)
  550. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // We can infer sequents from `T ≤ α` and `S = U` if α _contains_ S.
            map.add_grouped_sequents(other, |map, other| {
                let reversed = other.reverse();
  551. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // We can infer sequents from `T ≤ α` and `S = U` if α _contains_ S.
            map.add_grouped_sequents(other, |map, other| {
                let reversed = other.reverse();
  552. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // We cannot infer any sequents from `T = α` on its own.
        }
  553. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // We can infer sequents from `T = α` and `U = β` if α _contains_ U and/or β contains T.
            if !self.typevar.is_same_typevar_as(db, other.typevar) {
                Constraint::add_covariant_equivalence_tightened_sequent(db, env, map, self, other);
  554. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // We can infer sequents from `T = α` and `U = β` if α _contains_ U and/or β contains T.
            if !self.typevar.is_same_typevar_as(db, other.typevar) {
                Constraint::add_covariant_equivalence_tightened_sequent(db, env, map, self, other);
  555. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // Given `T = α` and `T = β`, if α and β are equivalent (but not _identical_), we can infer
            // either from the other.
            if self.bound == other.bound {
  556. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // Given `T = α` and `T = β`, if α and β are equivalent (but not _identical_), we can infer
            // either from the other.
            if self.bound == other.bound {
  557. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // Given constraints `T = α` and `T = β`, `α = β` must also hold. If those bounds contain
            // other typevars, we can infer additional constraints.
            Constraint::add_sequents_for_equivalence(db, env, map, self, other);
  558. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // Given constraints `T = α` and `T = β`, `α = β` must also hold. If those bounds contain
            // other typevars, we can infer additional constraints.
            Constraint::add_sequents_for_equivalence(db, env, map, self, other);
  559. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given constraints `T = α` and `T ≤ U`, `α ≤ U` must also hold.
            // Retaining the equality makes this an equivalent replacement for `T ≤ U`, so the
            // fixed `T` does not remain in `U`'s inference bounds.
  560. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given constraints `T = α` and `T ≤ U`, `α ≤ U` must also hold.
            // Retaining the equality makes this an equivalent replacement for `T ≤ U`, so the
            // fixed `T` does not remain in `U`'s inference bounds.
  561. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // Given constraints `T = α` and `U ≤ T`, `U ≤ α` must also hold.
            // The retained equality likewise makes this an equivalent replacement for `U ≤ T`.
            if self.typevar.is_same_typevar_as(db, other.right) {
  562. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // Given constraints `T = α` and `U ≤ T`, `U ≤ α` must also hold.
            // The retained equality likewise makes this an equivalent replacement for `U ≤ T`.
            if self.typevar.is_same_typevar_as(db, other.right) {
  563. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // We can infer sequents from `T = α` and `S ≤ U` if α _contains_ S or U.
            Constraint::add_covariant_lower_weakened_sequent(db, env, map, self, other);
            Constraint::add_covariant_upper_weakened_sequent(db, env, map, self, other);
  564. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // We can infer sequents from `T = α` and `S ≤ U` if α _contains_ S or U.
            Constraint::add_covariant_lower_weakened_sequent(db, env, map, self, other);
            Constraint::add_covariant_upper_weakened_sequent(db, env, map, self, other);
  565. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given constraints `T = α` and `T = U`, `U = α` must also hold.
            let other_typevar = if self.typevar.is_same_typevar_as(db, other.left) {
                Some(other.right)
  566. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
            // Given constraints `T = α` and `T = U`, `U = α` must also hold.
            let other_typevar = if self.typevar.is_same_typevar_as(db, other.left) {
                Some(other.right)
  567. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // We can infer sequents from `T = α` and `S = U` if α _contains_ U.
            map.add_grouped_sequents(other, |map, other| {
                let reversed = other.reverse();
  568. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
            // We can infer sequents from `T = α` and `S = U` if α _contains_ U.
            map.add_grouped_sequents(other, |map, other| {
                let reversed = other.reverse();
  569. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            //
            //   (α | β) ≤ T   ⇔ (α ≤ T) ∧ (β ≤ T)
            match bound {
                Type::Union(bound) => Either::Left(
  570. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            //
            //   (α | β) ≤ T   ⇔ (α ≤ T) ∧ (β ≤ T)
            match bound {
                Type::Union(bound) => Either::Left(
  571. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            //
            //   T ≤ (α & β)   ⇔ (T ≤ α) ∧ (T ≤ β)
            //   T ≤ (¬α & ¬β) ⇔ (T ≤ ¬α) ∧ (T ≤ ¬β)
            match bound {
  572. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            //
            //   T ≤ (α & β)   ⇔ (T ≤ α) ∧ (T ≤ β)
            //   T ≤ (¬α & ¬β) ⇔ (T ≤ ¬α) ∧ (T ≤ ¬β)
            match bound {
  573. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            //   T ≤ (α & β)   ⇔ (T ≤ α) ∧ (T ≤ β)
            //   T ≤ (¬α & ¬β) ⇔ (T ≤ ¬α) ∧ (T ≤ ¬β)
            match bound {
                Type::Intersection(bound) => {
  574. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            //   T ≤ (α & β)   ⇔ (T ≤ α) ∧ (T ≤ β)
            //   T ≤ (¬α & ¬β) ⇔ (T ≤ ¬α) ∧ (T ≤ ¬β)
            match bound {
                Type::Intersection(bound) => {
  575. identifier `λT` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    //! ```text
    //! μF. λT. tuple[T, F[list[T]] | None]
    //! ```
    //!
  576. identifier `λT` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    //!
    //! Here `μF` binds the recursive constructor, and `λT` binds its type parameter.
    //! The occurrence `F[list[T]]` is stored as `RecursiveVar` with the constructor's
    //! `RecursiveCycle` and unspecialized arguments `[list[T]]`.
  577. identifier `λT` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    //! ```text
    //! unfold((μF. λT. tuple[T, F[list[T]] | None])[int])
    //! = tuple[int, (μF. λT. tuple[T, F[list[T]] | None])[list[int]] | None]
    //! = tuple[int, Tree[list[int]] | None]
  578. identifier `λT` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    //! unfold((μF. λT. tuple[T, F[list[T]] | None])[int])
    //! = tuple[int, (μF. λT. tuple[T, F[list[T]] | None])[list[int]] | None]
    //! = tuple[int, Tree[list[int]] | None]
    //! ```
  579. U+200B ZERO WIDTH SPACE in source (in string/comment) (raw pass, confidence 0.45)

    
    /// If the value ⟨U+200B⟩⟨U+200B⟩is defined recursively, widening is performed from fewer literal elements,
    /// resulting in faster convergence of the fixed-point iteration.
    const MAX_RECURSIVE_UNION_LITERALS: usize = 5;
  580. U+200B ZERO WIDTH SPACE in source (in string/comment) (raw pass, confidence 0.45)

    
    /// If the value ⟨U+200B⟩⟨U+200B⟩is defined recursively, widening is performed from fewer literal elements,
    /// resulting in faster convergence of the fixed-point iteration.
    const MAX_RECURSIVE_UNION_LITERALS: usize = 5;
  581. U+200B ZERO WIDTH SPACE in source (in string/comment) (raw pass, confidence 0.45)

    const MAX_RECURSIVE_UNION_LITERALS: usize = 5;
    /// If the value ⟨U+200B⟩⟨U+200B⟩is defined non-recursively, the fixed-point iteration will converge in one go,
    /// so in principle we can have as many literal elements as we want.
    /// We set a large limit for union and enum literals.
  582. U+200B ZERO WIDTH SPACE in source (in string/comment) (raw pass, confidence 0.45)

    const MAX_RECURSIVE_UNION_LITERALS: usize = 5;
    /// If the value ⟨U+200B⟩⟨U+200B⟩is defined non-recursively, the fixed-point iteration will converge in one go,
    /// so in principle we can have as many literal elements as we want.
    /// We set a large limit for union and enum literals.
  583. info warn → info by review dynamic-execution docs/faq.md:244:3

    [embedded bash] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)

    $ # On macOS and Linux.
    $ curl -LsSf https://astral.sh/ruff/install.sh | sh
    
    $ # On Windows.
    likely benign LLM, confidence 0.90 Documentation showing the official curl-pipe-to-sh install command for ruff.
    Reasoning

    This is the standard documented installer one-liner for the ruff project, served from its official domain. Piping to sh is a common, transparent install method in documentation, not hidden malicious behavior.

  584. info warn → info by review dynamic-execution docs/faq.md:250:3

    [embedded bash] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)

    $ # For a specific version.
    $ curl -LsSf https://astral.sh/ruff/0.5.0/install.sh | sh
    $ powershell -c "irm https://astral.sh/ruff/0.5.0/install.ps1 | iex"
    ```
    likely benign LLM, confidence 0.90 Documentation showing a versioned curl-pipe-to-sh install command for ruff.
    Reasoning

    Same official ruff installer pattern with a pinned version, shown in user-facing docs. Legitimate install instructions.

  585. info identifier-low-length docs/formatter/black.md:455:1

    [embedded python] mean non-conventional identifier length 1.86 over 21 names (token pass, confidence 0.50)

  586. info warn → info by review dynamic-execution docs/installation.md:39:3

    [embedded bash] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)

    $ # On macOS and Linux.
    $ curl -LsSf https://astral.sh/ruff/install.sh | sh
    
    $ # On Windows.
    likely benign LLM, confidence 0.90 Installation docs with the official ruff curl-pipe-to-sh command.
    Reasoning

    Official installation documentation for ruff using the standard astral.sh installer. Transparent and expected in install docs.

  587. info warn → info by review dynamic-execution docs/installation.md:45:3

    [embedded bash] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)

    $ # For a specific version.
    $ curl -LsSf https://astral.sh/ruff/0.5.0/install.sh | sh
    $ powershell -c "irm https://astral.sh/ruff/0.5.0/install.ps1 | iex"
    ```
    likely benign LLM, confidence 0.90 Installation docs with a pinned-version curl-pipe-to-sh command.
    Reasoning

    Versioned official installer command in installation docs, matching the common pattern for this project. Legitimate.

  588. info warn → info by review dynamic-execution scripts/generate_builtin_modules.py:76:16

    `eval` called on a non-literal expression (ast pass, confidence 0.70)

        ]
        return set(eval(run(command_2)))
    likely benign LLM, confidence 0.75 Dev script evaluates the output of a helper command to produce a set of module names.
    Reasoning

    eval is applied to the output of a command run by a dev script, which is a code-generation tool. This is poor practice and risky if the command output is untrusted, but in a maintainer script the input is controlled by the repo, so it is most likely benign.

  589. info critical → info by review dynamic-execution scripts/setup_primer_project.py:204:9

    `subprocess.run` with `shell=True` and a non-literal command — runtime-determined shell invocation (ast pass, confidence 0.85)

            # Primer install commands are trusted project metadata and may use shell syntax.
            subprocess.run(install_cmd, cwd=target_dir, shell=True, check=True)  # ruff: ignore[subprocess-popen-with-shell-equals-true]
    
        # Install listed dependencies (matching primer's setup())
    likely benign LLM, confidence 0.80 Setup script runs trusted project install commands through a shell.
    Reasoning

    shell=True runs install commands from a project's metadata, which the code comment describes as trusted. It is a supply-chain-relevant pattern, but it is a maintainer setup script for a known third-party benchmark project and the comment and linter suppression show it is intentional.

  590. info warn → info by review dynamic-execution scripts/ty_benchmark/README.md:4:14

    [markup prose] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)

        - Unix: `curl -LsSf https://astral.sh/uv/install.sh | sh`
    likely benign LLM, confidence 0.85 README listing the official uv curl-pipe-to-sh installer.
    Reasoning

    Standard uv installation instructions in a benchmark README, using the official astral.sh domain. Normal documentation.

  591. 23 lines of text indented with invisible whitespace (U+00A0), first at line 4 (raw pass, confidence 0.40)

      <CWD>/src/black/__init__.py:1018:15 - error: Cannot access attribute "detach" for class "AnsiToWin32"
      ⟨U+00A0⟩⟨U+00A0⟩Attribute "detach" is unknown (reportAttributeAccessIssue)
      <CWD>/src/black/__init__.py:1072:11 - error: Cannot access attribute "detach" for class "AnsiToWin32"
  592. 419 lines of text indented with invisible whitespace (U+00A0), first at line 4 (raw pass, confidence 0.40)

      <CWD>/discord/abc.py:123:9 - error: "pinned" overrides symbol of same name in class "Message"
      ⟨U+00A0⟩⟨U+00A0⟩Variable is mutable so its type is invariant
      ⟨U+00A0⟩⟨U+00A0⟩⟨U+00A0⟩⟨U+00A0⟩Override type "Literal[True]" is not the same as base type "bool" (reportIncompatibleVariableOverride)
    <CWD>/discord/activity.py
  593. 20122 lines of text indented with invisible whitespace (U+00A0), first at line 3 (raw pass, confidence 0.40)

      <CWD>/homeassistant/auth/__init__.py:137:12 - error: Could not access item in TypedDict
      ⟨U+00A0⟩⟨U+00A0⟩"type" is not a required key in "AuthFlowResult", so access may result in runtime exception (reportTypedDictNotRequiredAccess)
      <CWD>/homeassistant/auth/__init__.py:141:23 - error: Could not access item in TypedDict
  594. line length 2112 characters (raw pass, confidence 0.65)

      <CWD>/homeassistant/components/lg_thinq/sensor.py:429:81 - error: Type "dict[str, tuple[SensorEntityDescription, SensorEntityDescription, SensorEntityDescription, SensorEntityDescription, SensorEntityDescription, SensorEntityDescription, SensorEntityDescription, SensorEntityDescription, SensorEntityDescription, Senso
    likely benign LLM, confidence 0.95 Long generated type-error line in a benchmark snapshot file.
    Reasoning

    A very long line in a generated type-checker output snapshot. Long type signatures are expected in this kind of output and no obfuscation is present.

  595. line length 668 characters (raw pass, confidence 0.50)

      <CWD>/homeassistant/components/lg_thinq/switch.py:41:86 - error: Type "dict[str, tuple[ThinQSwitchEntityDescription, ThinQSwitchEntityDescription, ThinQSwitchEntityDescription, ThinQSwitchEntityDescription] | tuple[ThinQSwitchEntityDescription, ThinQSwitchEntityDescription, ThinQSwitchEntityDescription] | tuple[ThinQ
  596. 11 lines of text indented with invisible whitespace (U+00A0), first at line 13 (raw pass, confidence 0.40)

      <CWD>/isort/main.py:520:32 - error: Cannot access attribute "__members__" for class "Enum"
      ⟨U+00A0⟩⟨U+00A0⟩Attribute "__members__" is unknown (reportAttributeAccessIssue)
      <CWD>/isort/main.py:521:50 - error: Cannot access attribute "__members__" for class "Enum"
  597. 57 lines of text indented with invisible whitespace (U+00A0), first at line 3 (raw pass, confidence 0.40)

      <CWD>/src/jinja2/async_utils.py:91:25 - error: Cannot access attribute "__aiter__" for class "Iterable[V@auto_aiter]"
      ⟨U+00A0⟩⟨U+00A0⟩Attribute "__aiter__" is unknown (reportAttributeAccessIssue)
      <CWD>/src/jinja2/async_utils.py:93:41 - error: No overloads for "iter" match the provided arguments (reportCallIssue)
  598. info warn → info by review long-line scripts/ty_benchmark/snapshots/pandas_Pyrefly.txt:1352:1

    line length 2416 characters (raw pass, confidence 0.65)

    ERROR pandas/io/parsers/readers.py:317:5-13: Implementation signature `(filepath_or_buffer: PathLike[str] | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | str, *, sep: _NoDefault | str | None = _NoDefault.no_default, delimiter: _NoDefault | str | None = None, header: Literal['infer'] | Sequence[int] | int | None = 'infer'
    likely benign LLM, confidence 0.95 Long generated diagnostic line in a benchmark snapshot.
    Reasoning

    Long generated diagnostic line from a type checker output snapshot. Expected for long signatures.

  599. info warn → info by review long-line scripts/ty_benchmark/snapshots/pandas_Pyrefly.txt:1353:1

    line length 2400 characters (raw pass, confidence 0.65)

    ERROR pandas/io/parsers/readers.py:327:5-13: Implementation signature `(filepath_or_buffer: PathLike[str] | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | str, *, sep: _NoDefault | str | None = _NoDefault.no_default, delimiter: _NoDefault | str | None = None, header: Literal['infer'] | Sequence[int] | int | None = 'infer'
    likely benign LLM, confidence 0.95 Long generated diagnostic line in a benchmark snapshot.
    Reasoning

    Same kind of long generated type-checker diagnostic in a snapshot file. No malicious content.

  600. info warn → info by review long-line scripts/ty_benchmark/snapshots/pandas_Pyrefly.txt:1354:1

    line length 2412 characters (raw pass, confidence 0.65)

    ERROR pandas/io/parsers/readers.py:337:5-13: Implementation signature `(filepath_or_buffer: PathLike[str] | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | str, *, sep: _NoDefault | str | None = _NoDefault.no_default, delimiter: _NoDefault | str | None = None, header: Literal['infer'] | Sequence[int] | int | None = 'infer'
    likely benign LLM, confidence 0.95 Long generated diagnostic line in a benchmark snapshot.
    Reasoning

    Long generated type-checker diagnostic in a snapshot file, with no obfuscation.

  601. info warn → info by review long-line scripts/ty_benchmark/snapshots/pandas_Pyrefly.txt:1355:1

    line length 2425 characters (raw pass, confidence 0.65)

    ERROR pandas/io/parsers/readers.py:347:5-13: Implementation signature `(filepath_or_buffer: PathLike[str] | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | str, *, sep: _NoDefault | str | None = _NoDefault.no_default, delimiter: _NoDefault | str | None = None, header: Literal['infer'] | Sequence[int] | int | None = 'infer'
    likely benign LLM, confidence 0.95 Long generated diagnostic line in a benchmark snapshot.
    Reasoning

    Long generated type-checker diagnostic in a snapshot file, consistent with the other lines from the same output.

  602. info warn → info by review long-line scripts/ty_benchmark/snapshots/pandas_Pyrefly.txt:1356:1

    line length 2416 characters (raw pass, confidence 0.65)

    ERROR pandas/io/parsers/readers.py:904:5-15: Implementation signature `(filepath_or_buffer: PathLike[str] | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | str, *, sep: _NoDefault | str | None = _NoDefault.no_default, delimiter: _NoDefault | str | None = None, header: Literal['infer'] | Sequence[int] | int | None = 'infer'
    dismissed LLM, confidence 0.97 A long line in a text snapshot of a Pyrefly type-checker output for pandas, containing an ordinary function signature error message.
    Reasoning

    The finding is a raw-pass long-line warning on a plain-text benchmark snapshot file. The snippet is a type-checker error message wrapping a long function signature, which is a normal artifact of tool output, not obfuscation or malicious content. Raw-pass findings have a high false-positive rate, and nothing here suggests intent.

  603. 2589 lines of text indented with invisible whitespace (U+00A0), first at line 9 (raw pass, confidence 0.40)

      ⟨U+00A0⟩⟨U+00A0⟩Parameter 2 name mismatch: base parameter is named "y_", override parameter is named "other" (reportIncompatibleMethodOverride)
      <CWD>/pandas/_libs/sparse.pyi:45:9 - error: Method "make_union" overrides class "SparseIndex" in an incompatible manner
  604. 435 lines of text indented with invisible whitespace (U+00A0), first at line 3 (raw pass, confidence 0.40)

      ⟨U+00A0⟩⟨U+00A0⟩"TTLCache[_KT2@__init__, _VT2@__init__, float]" is not assignable to "TTLCache[frozenset[str], bool, float]"
      ⟨U+00A0⟩⟨U+00A0⟩⟨U+00A0⟩⟨U+00A0⟩Type parameter "_KT@TTLCache" is invariant, but "_KT2@__init__" is not the same as "frozenset[str]"
  605. 10422 lines of text indented with invisible whitespace (U+00A0), first at line 133 (raw pass, confidence 0.40)

      ⟨U+00A0⟩⟨U+00A0⟩Argument types: ((**_InputT@compile) -> _RetT@compile, bool, bool | None, str | ((...) -> Unknown), str | None, dict[str, str | int | bool | ((...) -> Unknown)] | None, str | None, bool, int | None, bool, Any | None) (reportCallIssue)
  606. compression ratio 0.845 is >2σ above file mean 0.514 (raw pass, confidence 0.50)

      <CWD>/torch/_functorch/_aot_autograd/graph_compile.py:2614:55 - error: Type "None" is not assignable to declared type "(compiled_bw_func: (...) -> Any, bw_module: GraphModule, _fw_metadata: ViewAndMutationMeta, aot_config: AOTConfig) -> (GenericAOTAutogradResult[Any, Any] | None)"
  607. compression ratio 0.845 is >2σ above file mean 0.514 (raw pass, confidence 0.50)

      ⟨U+00A0⟩⟨U+00A0⟩Type "None" is not assignable to type "(compiled_bw_func: (...) -> Any, bw_module: GraphModule, _fw_metadata: ViewAndMutationMeta, aot_config: AOTConfig) -> (GenericAOTAutogradResult[Any, Any] | None)" (reportAssignmentType)
  608. compression ratio 0.845 is >2σ above file mean 0.514 (raw pass, confidence 0.50)

      <CWD>/torch/_functorch/_aot_autograd/graph_compile.py:2689:36 - error: Type "None" is not assignable to declared type "(compiled_bw_func: (...) -> Any, bw_module: GraphModule, _fw_metadata: ViewAndMutationMeta, aot_config: AOTConfig) -> (GenericAOTAutogradResult[Any, Any] | None)"
  609. compression ratio 0.845 is >2σ above file mean 0.514 (raw pass, confidence 0.50)

      ⟨U+00A0⟩⟨U+00A0⟩Type "None" is not assignable to type "(compiled_bw_func: (...) -> Any, bw_module: GraphModule, _fw_metadata: ViewAndMutationMeta, aot_config: AOTConfig) -> (GenericAOTAutogradResult[Any, Any] | None)" (reportAssignmentType)
  610. line length 884 characters (raw pass, confidence 0.50)

    mypy.ini: note: unused section(s): [mypy-torch.for_onnx.onnx], [mypy-torch.ao.quantization.pt2e._affine_quantization], [mypy-test_torch], [mypy-torch.testing._internal.hypothesis_utils.*], [mypy-torch.testing._internal.common_quantization.*], [mypy-torch.testing._internal.generated.*], [mypy-torch.multiprocessing.pool]

Reproduce This Scan

Run disclude locally to verify. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.

cargo install disclude --version 4.1.0
git clone https://github.com/astral-sh/ruff ruff && cd ruff
git checkout 0.17.1
disclude scan --severity info --diff 0.17.0 .