disclude.io

PyPI / ty / 0.0.90

ty 0.0.90

Source
https://github.com/astral-sh/ty
Artifact scanned
ty-0.0.90.tar.gz (sdist · 7.6 MB · SHA-256 25cef63ec07a…)
Compared with
ty-0.0.89.tar.gz (0 signals introduced since)
Files
3404 scanned, 1845 skipped (binary, oversized, or unrecognised)
Signals
0 critical · 0 warn · 357 info
Scan time
47.8 s
LLM review
Reviewed by claude-haiku-5-5 (Anthropic): 30 of 30 warn and critical signals; 30 demoted to info.
Disclude version
4.3.0
Scanned (UTC)
2026-10-23 12:33

Signals

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

  1. info warn → info by review unicode-mixed-script README.md:102:36

    identifier `tiː` mixes scripts: Latin + Other (raw pass, confidence 0.80)

    
It's pronounced as "tee - why" ([`/tiː waɪ/`](https://en.wikipedia.org/wiki/Help:IPA/English#Key))

#### How should I stylize ty?
    likely benign LLM, confidence 0.95 IPA phonetic character tiː in a README pronunciation note.
    Reasoning

    The mixed-script flag fires on IPA phonetic symbols in a markdown pronunciation guide, a legitimate use of Unicode.

  2. info warn → info by review unicode-mixed-script README.md:102:41

    identifier `waɪ` mixes scripts: Latin + Other (raw pass, confidence 0.80)

    
It's pronounced as "tee - why" ([`/tiː waɪ/`](https://en.wikipedia.org/wiki/Help:IPA/English#Key))

#### How should I stylize ty?
    likely benign LLM, confidence 0.95 IPA phonetic character waɪ in a README pronunciation note.
    Reasoning

    IPA character waɪ in a README pronunciation guide is legitimate Unicode text, not an identifier hiding anything.

  3. info high-complexity ruff/crates/mdtest/src/parser.rs:2378:14

    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)",
        );
  4. info whitespace-anomaly ruff/crates/ruff_annotate_snippets/tests/color/multiline_removal_suggestion.rs:2:1

    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,
};
  5. info unicode-mixed-script ruff/crates/ruff_annotate_snippets/tests/formatter.rs:2991:58

    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
  6. info unicode-mixed-script ruff/crates/ruff_annotate_snippets/tests/formatter.rs:2991:75

    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
  7. info unicode-mixed-script ruff/crates/ruff_annotate_snippets/tests/formatter.rs:3005:62

    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
  8. info unicode-mixed-script ruff/crates/ruff_annotate_snippets/tests/formatter.rs:3005:79

    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
  9. info unicode-mixed-script ruff/crates/ruff_annotate_snippets/tests/formatter.rs:3368:64

    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}�";
  10. info unicode-mixed-script ruff/crates/ruff_annotate_snippets/tests/formatter.rs:3396:31

    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⟩␝�:�␜␇�
  | ^
  11. info unicode-mixed-script ruff/crates/ruff_annotate_snippets/tests/formatter.rs:3414:33

    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⟩␝�:�␜␇�
  │ ━
  12. info whitespace-anomaly ruff/crates/ruff_annotate_snippets/tests/rustc_tests.rs:12:1

    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() {
}
  13. info warn → info by review whitespace-anomaly ruff/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
    likely benign LLM, confidence 0.93 Test case deliberately containing a non-breaking space to check whitespace handling.
    Reasoning

    The U+00A0 is inside a test fixture that deliberately tests how non-breaking spaces are handled; the comment states this intent.

  14. info proc-macro-presence ruff/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);
  15. info whitespace-anomaly ruff/crates/ruff_python_codegen/src/generator.rs:8:1

    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,
  16. info whitespace-anomaly ruff/crates/ruff_python_codegen/src/stylist.rs:13:1

    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>,
  17. info warn → info by review whitespace-anomaly ruff/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.93 Test string with non-breaking spaces used to check indentation detection.
    Reasoning

    Non-breaking spaces within a Rust test string for indentation detection; this is a stylist test fixture, not a payload.

  18. info warn → info by review whitespace-anomaly ruff/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.93 Test string with non-breaking spaces used to check indentation detection.
    Reasoning

    Same stylist test fixture with non-breaking space indentation; a deliberate edge-case test.

  19. info warn → info by review whitespace-anomaly ruff/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.93 Test string with non-breaking spaces used to check indentation detection.
    Reasoning

    Same stylist test fixture; the non-breaking spaces are deliberate test input.

  20. info whitespace-anomaly ruff/crates/ruff_python_formatter/resources/test/fixtures/black/cases/docstring.py:2:1

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

    class MyClass:
  """ Multiline
  class docstring
  """
  21. info identifier-low-length ruff/crates/ruff_python_formatter/resources/test/fixtures/black/cases/generics_wrapping.py:1:1

    168 of 250 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  22. info identifier-low-length ruff/crates/ruff_python_formatter/resources/test/fixtures/black/cases/import_comments.py:1:1

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

  23. info identifier-low-length ruff/crates/ruff_python_formatter/resources/test/fixtures/black/cases/pep_570.py:1:1

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

  24. info identifier-low-length ruff/crates/ruff_python_formatter/resources/test/fixtures/black/cases/pep_572_py310.py:1:1

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

  25. info identifier-low-length ruff/crates/ruff_python_formatter/resources/test/fixtures/black/cases/pep_646.py:1:1

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

  26. info identifier-low-length ruff/crates/ruff_python_formatter/resources/test/fixtures/black/cases/percent_precedence.py:1:1

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

  27. info identifier-low-length ruff/crates/ruff_python_formatter/resources/test/fixtures/black/cases/power_op_spacing_long.py:1:1

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

  28. info warn → info by review narrow-file-charset ruff/crates/ruff_python_formatter/resources/test/fixtures/black/cases/power_op_spacing_long.py:1:1

    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.90 Formatter test fixture of repeated ** power expressions.
    Reasoning

    A formatter fixture that repeats exponent expressions to test power-operator spacing; the narrow charset is just digits and operators in Python code, not a hidden payload.

  29. info high-complexity ruff/crates/ruff_python_formatter/resources/test/fixtures/black/cases/preview_long_strings.py:311:12

    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"]}')
  30. info warn → info by review high-complexity ruff/crates/ruff_python_formatter/resources/test/fixtures/black/cases/preview_long_strings__east_asian_width.py:5:10

    string literal compression ratio 0.970 (132 bytes) (raw pass, confidence 0.60)

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

    Ordinary Korean and Chinese string literals in a formatter test about east-asian width; the compression ratio is an artifact of the heuristic on natural text.

  31. info critical → info by review dynamic-execution ruff/crates/ruff_python_formatter/resources/test/fixtures/black/cases/preview_long_strings__regression.py:20:9

    `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 Formatter regression fixture calling os.system with a formatted string.
    Reasoning

    This is formatter test input containing a string-format call inside os.system; the command is a fixed literal template with format arguments in a test fixture, never executed.

  32. info high-complexity ruff/crates/ruff_python_formatter/resources/test/fixtures/black/cases/preview_long_strings__regression.py:235:17

    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}:/'"
  33. info identifier-low-length ruff/crates/ruff_python_formatter/resources/test/fixtures/black/cases/skip_magic_trailing_comma_generic_wrap.py:1:1

    128 of 176 non-conventional identifiers are single-character (73%) (token pass, confidence 0.50)

  34. info warn → info by review unicode-invisible ruff/crates/ruff_python_formatter/resources/test/fixtures/black/cases/tricky_unicode_symbols.py:4:2

    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.90 Test fixture containing a variation selector in an identifier for formatter edge-case testing.
    Reasoning

    A formatter fixture named tricky_unicode_symbols deliberately includes variation selectors to test parsing and formatting of unusual identifiers.

  35. info whitespace-anomaly ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring.py:2:1

    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
  36. info whitespace-anomaly ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring_code_examples.py:12:1

    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.
  37. info whitespace-anomaly ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring_tab_indentation.py:7:1

    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
  38. info identifier-low-length ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/attribute.py:1:1

    55 of 126 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  39. info whitespace-anomaly ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/lambda.py:27:1

    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
  40. info warn → info by review dynamic-execution ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/lambda.py:845:5

    `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 fixture containing a subprocess shell=True call that is never executed.
    Reasoning

    This is formatter test input; the rm -rf command is inside a function that is only parsed, never run, and the snippet is formatting-specific syntax.

  41. info warn → info by review dynamic-execution ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/lambda.py:858:5

    `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 fixture containing a subprocess shell=True call that is never executed.
    Reasoning

    Same formatter lambda fixture; the shell call is syntax input for the formatter, not executed code.

  42. info identifier-low-length ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/nested_string_quote_style.py:1:1

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

  43. info identifier-low-length ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/tstring.py:1:1

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

  44. info long-line ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/tuple.py:15:1

    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"
  45. info whitespace-anomaly ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/unary.py:2:1

    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
  46. info identifier-low-length ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/fluent.py:1:1

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

  47. info whitespace-anomaly ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/fmt_on_off/mixed_space_and_tab.py:2:1

    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
 	(
  48. info identifier-low-length ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/fmt_on_off/off_on_off_on.py:1:1

    mean non-conventional identifier length 1.30 over 27 names (token pass, confidence 0.50)

  49. info whitespace-anomaly ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/fmt_skip/compound_one_liners.py:15:1

    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)
  50. info identifier-low-length ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/parentheses/nested.py:1:1

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

  51. info identifier-low-length ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/statement/delete.py:1:1

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

  52. info whitespace-anomaly ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/statement/match.py:3:1

    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
  53. info whitespace-anomaly ruff/crates/ruff_python_formatter/resources/test/fixtures/ruff/statement/type_alias.py:42:1

    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
  54. info identifier-low-length ruff/crates/ruff_python_parser/resources/inline/err/different_match_pattern_bindings.py:1:1

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

  55. info identifier-low-length ruff/crates/ruff_python_parser/resources/inline/err/duplicate_type_parameter_names.py:1:1

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

  56. info identifier-low-length ruff/crates/ruff_python_parser/resources/inline/err/invalid_annotation_function.py:1:1

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

  57. info unicode-mixed-script ruff/crates/ruff_python_parser/resources/inline/err/invalid_byte_literal.py:1:6

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

    b'123a𝐁c'
rb"a𝐁c123"
b"""123a𝐁c"""
  58. info unicode-mixed-script ruff/crates/ruff_python_parser/resources/inline/err/invalid_byte_literal.py:2:4

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

    b'123a𝐁c'
rb"a𝐁c123"
b"""123a𝐁c"""
  59. info unicode-mixed-script ruff/crates/ruff_python_parser/resources/inline/err/invalid_byte_literal.py:3:8

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

    rb"a𝐁c123"
b"""123a𝐁c"""
  60. info identifier-low-length ruff/crates/ruff_python_parser/resources/inline/ok/ambiguous_lpar_with_items_binary_expr.py:1:1

    mean non-conventional identifier length 1.97 over 30 names (token pass, confidence 0.50)

  61. info identifier-low-length ruff/crates/ruff_python_parser/resources/inline/ok/non_duplicate_type_parameter_names.py:1:1

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

  62. info identifier-low-length ruff/crates/ruff_python_parser/resources/valid/expressions/bool_op.py:1:1

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

  63. info identifier-low-length ruff/crates/ruff_python_parser/resources/valid/expressions/compare.py:1:1

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

  64. info identifier-low-length ruff/crates/ruff_python_parser/resources/valid/expressions/lambda.py:1:1

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

  65. info identifier-low-length ruff/crates/ruff_python_parser/resources/valid/expressions/t_string.py:1:1

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

  66. info identifier-low-length ruff/crates/ruff_python_parser/resources/valid/expressions/tuple.py:1:1

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

  67. info identifier-low-length ruff/crates/ruff_python_parser/resources/valid/other/decorator.py:1:1

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

  68. info identifier-low-length ruff/crates/ruff_python_parser/resources/valid/statement/delete.py:1:1

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

  69. info identifier-low-length ruff/crates/ruff_python_parser/resources/valid/statement/function.py:1:1

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

  70. info identifier-low-length ruff/crates/ruff_python_parser/resources/valid/statement/type.py:1:1

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

  71. info whitespace-anomaly ruff/crates/ruff_python_parser/resources/valid/statement/type.py:27:1

    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
  72. info unicode-mixed-script ruff/crates/ruff_python_parser/src/lexer.rs:2117:43

    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 {
  73. info unicode-mixed-script ruff/crates/ruff_python_parser/src/parser/expression.rs:1541:29

    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"""
  74. info unicode-mixed-script ruff/crates/ruff_python_parser/src/parser/expression.rs:1542:27

    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 {
  75. info unicode-mixed-script ruff/crates/ruff_python_parser/src/parser/expression.rs:1543:31

    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([]),
  76. info warn → info by review encoding-hex ruff/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 enumerating hex escape sequences.
    Reasoning

    A Rust parser test string listing all byte escapes as a deliberate test of escape handling, which is expected in a parser's test suite.

  77. info warn → info by review encoding-escape-soup ruff/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.95 Byte-range escape test data in Ruff's Python string parser.
    Reasoning

    The snippet is a run of \xNN escapes covering the full byte range, which is typical of parser test data exercising string escape handling in a Rust compiler front end. The pass is raw, which has a higher false-positive rate, and nothing suggests a payload.

  78. info warn → info by review encoding-hex ruff/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.95 Hex escape table of all byte values in Ruff's string parser.
    Reasoning

    This is the same kind of full-byte-range escape table in a parser source file. It is test or reference data for escape decoding, not executable obfuscation.

  79. info warn → info by review encoding-escape-soup ruff/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.95 Continuation of the byte-escape test table in Ruff's string parser.
    Reasoning

    Continuation of the same escape table in the Rust parser's string handling. It is a legitimate coding pattern for exercising byte escapes.

  80. info unicode-mixed-script ruff/crates/ruff_python_parser/src/string.rs:1149:29

    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);
  81. info unicode-mixed-script ruff/crates/ruff_python_stdlib/src/identifiers.rs:113:32

    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"));
  82. info unicode-homoglyph ruff/crates/ruff_python_stdlib/src/str.rs:17:27

    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"));
  83. info unicode-mixed-script ruff/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"));
  84. info unicode-homoglyph ruff/crates/ruff_python_stdlib/src/str.rs:18:28

    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"));
/// ```
  85. info unicode-mixed-script ruff/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"));
/// ```
  86. info unicode-mixed-script ruff/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 {
  87. info unicode-mixed-script ruff/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"));
  88. info unicode-mixed-script ruff/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"));
/// ```
  89. info unicode-homoglyph ruff/crates/ruff_python_stdlib/src/str.rs:56:28

    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 {
  90. info unicode-mixed-script ruff/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 {
  91. info unicode-mixed-script ruff/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"
"#,
            )
  92. info unicode-mixed-script ruff/crates/ty_ide/src/selection_range.rs:425:20

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

            1 | /
        2 | | b"123a𝐁c"
          | |__________^
  93. info unicode-mixed-script ruff/crates/ty_ide/src/selection_range.rs:431:18

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

              |
        2 | b"123a𝐁c"
          | ^^^^^^^^^
        "#);
  94. info identifier-low-length ruff/crates/ty_python_semantic/resources/corpus/02_expr_binary.py:1:1

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

  95. info identifier-low-length ruff/crates/ty_python_semantic/resources/corpus/02_expr_rel.py:1:1

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

  96. info warn → info by review long-line ruff/crates/ty_python_semantic/resources/corpus/03_dict_unpack_huge.py:1:1

    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.95 Generated stress-test line of dict unpacking in a type checker corpus.
    Reasoning

    The file lives in a type-checker corpus and is a generated stress input of repeated dict unpacking. The long line is an artifact of that generation, not concealment.

  97. info identifier-low-length ruff/crates/ty_python_semantic/resources/corpus/06_funcall_many_args.py:1:1

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

  98. info identifier-low-length ruff/crates/ty_python_semantic/resources/corpus/06_funcall_varargs_kwargs_mixed.py:1:1

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

  99. info identifier-low-length ruff/crates/ty_python_semantic/resources/corpus/10_if_false.py:1:1

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

  100. info critical → info by review builtins-write ruff/crates/ty_python_semantic/resources/corpus/98_ann_assign_annotation_future_annotations.py:5:1

    `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 Corpus fixture that assigns builtins.__import__ to test annotation handling.
    Reasoning

    This is a numbered type-checker corpus fixture testing annotated assignment to a builtin attribute with future annotations. Assigning builtins.__import__ in a test input does not run in a shipped package, though the pattern is what a real attack would use, so the verdict is not certain.

  101. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/annotations/intersection_types.md:195:1

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

  102. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/annotations/invalid.md:415:1

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

  103. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/annotations/new_types.md:525:1

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

  104. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/annotations/string.md:254:1

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

  105. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/attributes.md:1583:1

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

  106. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/attributes.md:3023:1

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

  107. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/attributes.md:3502:1

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

  108. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/bidirectional.md:2653:1

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

  109. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/binary/booleans.md:8:1

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

  110. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/binary/classes.md:22:1

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

  111. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/binary/custom.md:387:1

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

  112. info critical → info by review dynamic-import ruff/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.90 Mdtest checking the inferred type of __import__ called on a variable.
    Reasoning

    This is a markdown test for the type checker, with reveal_type annotations showing the expected inferred type of __import__ on a non-literal argument. The dynamic import is the subject of the test, not an attack.

  113. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/call/functools_partial.md:385:1

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

  114. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/call/functools_partial.md:977:1

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

  115. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/call/functools_partial.md:1691:1

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

  116. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/call/overloads.md:175:1

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

  117. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/call/overloads.md:234:1

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

  118. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/call/overloads.md:273:1

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

  119. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/call/overloads.md:600:1

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

  120. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/call/overloads.md:647:1

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

  121. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/call/overloads.md:895:1

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

  122. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/call/overloads.md:954:1

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

  123. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/call/overloads.md:1170:1

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

  124. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/call/overloads.md:1283:1

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

  125. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/call/type.md:1341:1

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

  126. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/class/super.md:28:1

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

  127. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/class/super.md:497:1

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

  128. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/class/super.md:530:1

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

  129. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/class/super.md:565:1

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

  130. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/comparison/enums.md:47:1

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

  131. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/comparison/instances/rich_comparison.md:236:1

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

  132. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/comparison/instances/rich_comparison.md:500:1

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

  133. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/comparison/tuples.md:16:1

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

  134. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/comparison/tuples.md:37:1

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

  135. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/comparison/tuples.md:61:1

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

  136. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/comparison/tuples.md:234:1

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

  137. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/comparison/tuples.md:274:1

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

  138. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/comparison/tuples.md:311:1

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

  139. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/comparison/tuples.md:500:1

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

  140. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/diagnostics/semantic_syntax_errors.md:565:1

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

  141. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/diagnostics/semantic_syntax_errors.md:637:1

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

  142. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/diagnostics/unknown_argument.md:23:1

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

  143. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/directives/assert_type.md:161:1

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

  144. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/directives/assert_type.md:246:1

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

  145. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/exhaustiveness_checking.md:516:1

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

  146. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/final.md:8:1

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

  147. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/function/parameters.md:56:1

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

  148. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/function/return_type.md:312:1

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

  149. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/legacy/callables.md:965:1

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

  150. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/legacy/functions.md:1534:1

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

  151. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/legacy/functions.md:1729:1

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

  152. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/legacy/functions.md:2047:1

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

  153. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/legacy/variables.md:312:1

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

  154. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/legacy/variables.md:1458:1

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

  155. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/legacy/variance.md:25:1

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

  156. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/legacy/variance.md:107:1

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

  157. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/legacy/variance.md:220:1

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

  158. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/aliases.md:734:1

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

  159. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/callables.md:1299:1

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

  160. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/classes.md:112:1

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

  161. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/classes.md:1032:1

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

  162. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md:1670:1

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

  163. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md:1829:1

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

  164. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md:1969:1

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

  165. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md:2152:1

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

  166. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md:2766:1

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

  167. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/paramspec.md:46:1

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

  168. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/paramspec.md:524:1

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

  169. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/paramspec.md:1010:1

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

  170. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:232:1

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

  171. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:468:1

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

  172. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:572:1

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

  173. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:587:1

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

  174. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:608:1

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

  175. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:619:1

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

  176. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:1088:1

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

  177. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:1442:1

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

  178. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:1532:1

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

  179. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:32:1

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

  180. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:111:1

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

  181. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:219:1

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

  182. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:295:1

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

  183. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:624:1

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

  184. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:647:1

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

  185. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:834:1

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

  186. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:865:1

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

  187. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:1262:1

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

  188. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:1783:1

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

  189. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:2322:1

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

  190. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/scoping.md:354:1

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

  191. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/scoping.md:433:1

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

  192. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/scoping.md:532:1

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

  193. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/implicit_type_aliases.md:798:1

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

  194. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/implicit_type_aliases.md:2554:1

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

  195. info critical → info by review builtins-write ruff/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.90 Mdtest assignment to builtins.foo with expected type error annotations.
    Reasoning

    The embedded Python sits in a type-checker mdtest with inline error expectations such as '# error: [unresolved-attribute]'. The assignments exercise diagnostics for builtins writes and are never run as malware.

  196. info critical → info by review builtins-write ruff/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.90 Mdtest assignment to builtins.bar with an expected diagnostic.
    Reasoning

    Same mdtest block with expected-error comments. The line asserts diagnostics for builtin attribute assignment rather than performing a real patch.

  197. info critical → info by review builtins-write ruff/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.90 Mdtest assignment to builtins.baz checking invalid-assignment diagnostics.
    Reasoning

    Part of the same type-checker test that verifies invalid-assignment diagnostics for builtins. It is a test expectation, not a live patch.

  198. info critical → info by review builtins-write ruff/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.90 Mdtest assignment to builtins.chr with expected invalid-assignment error.
    Reasoning

    Same mdtest, exercising diagnostics for overriding builtins.chr. The error comments confirm the purpose is checking the type checker's behavior.

  199. info critical → info by review builtins-write ruff/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.90 Second builtins.chr assignment in the mdtest fixture.
    Reasoning

    Repeated builtins.chr assignment inside the same type-checker test, serving as a diagnostics fixture.

  200. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/import/star.md:227:1

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

  201. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/import/star.md:436:1

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

  202. info warn → info by review unicode-mixed-script ruff/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.70 Mdtest using a letterlike-symbol identifier that normalizes to __all__ in a star-import test.
    Reasoning

    The identifier __aℓℓ__ mixes Latin with a letterlike symbol that NFKC-normalizes to __all__. In a star-import mdtest this looks like a deliberate test of how the checker handles normalized __all__ names, which is a legitimate subject. Some doubt remains because the homoglyph could be a crafted evasion.

  203. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/intersection_types.md:136:1

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

  204. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/intersection_types.md:185:1

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

  205. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/mro.md:96:1

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

  206. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/mro.md:119:1

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

  207. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/mro.md:142:1

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

  208. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/mro.md:168:1

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

  209. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/named_tuple.md:195:1

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

  210. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/narrow/aliased_conditions.md:168:1

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

  211. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/narrow/assignment.md:8:1

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

  212. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/narrow/assignment.md:105:1

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

  213. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/narrow/assignment.md:451:1

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

  214. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/narrow/complex_target.md:131:1

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

  215. info unicode-zero-width ruff/crates/ty_python_semantic/resources/mdtest/narrow/complex_target.md:146:32

    [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
  216. info unicode-zero-width ruff/crates/ty_python_semantic/resources/mdtest/narrow/complex_target.md:146:35

    [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
  217. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/narrow/conditionals/eq.md:586:1

    [embedded python] 36 of 71 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  218. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/narrow/conditionals/nested.md:77:1

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

  219. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/narrow/conditionals/nested.md:122:1

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

  220. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/narrow/conditionals/nested.md:310:1

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

  221. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/narrow/type_guards.md:491:1

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

  222. info critical → info by review dynamic-execution ruff/crates/ty_python_semantic/resources/mdtest/pep613_type_aliases.md:867: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.90 An embedded-Python test case in a type-checker markdown spec evaluates a string spelling 'int' to build an intentionally invalid type alias.
    Reasoning

    The eval call sits in a markdown test fixture for type-checker conformance cases. Its argument is built from chr codes 105, 110, 116, which spell 'int', and the line carries an expected-error annotation. It is an intentionally obscure invalid type alias meant to trigger [invalid-type-form], not a payload. The pattern is unusual but matches a deliberate test case, not an attack.

  223. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/pep695_type_aliases.md:390:1

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

  224. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/subscript/tuple.md:595:1

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

  225. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/type_properties/constraints.md:1090:1

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

  226. info warn → info by review unicode-mixed-script ruff/crates/ty_python_semantic/resources/mdtest/type_properties/quantification.md:19:20

    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.90 A subscripted set name in a math table of quantifier cases, flagged for mixed Latin and modifier-letter script.
    Reasoning

    The identifier Dᵧ is a Latin D followed by a modifier-letter subscript gamma. Subscripts like this are standard mathematical notation in a documentation table about quantifiers. The raw-pass script-mixing flag is a false positive from the subscript glyph.

  227. info warn → info by review unicode-mixed-script ruff/crates/ty_python_semantic/resources/mdtest/type_properties/quantification.md:19:35

    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.90 A subscripted set name in the same quantifier table, flagged for mixed scripts due to a subscript glyph.
    Reasoning

    Dₓ is a Latin D with a modifier-letter subscript x, the same kind of mathematical subscript notation as the neighbouring Dᵧ in the same table row. The mixed-script flag comes from the subscript glyph, not from homoglyph spoofing or hidden code.

  228. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/type_qualifiers/classvar.md:12:1

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

  229. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/type_qualifiers/classvar.md:145:1

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

  230. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/type_qualifiers/classvar.md:289:1

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

  231. info warn → info by review unicode-zero-width ruff/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.80 A stray zero-width space in a prose sentence of a TypedDict markdown test doc.
    Reasoning

    A zero-width space appears inside prose in a markdown documentation file, between words, not in executable code. It is most likely a copy-paste or editor artifact. It has no effect on the rendered text or on any code that runs, though it is a minor invisible-character anomaly.

  232. info warn → info by review unicode-zero-width ruff/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.80 A second stray zero-width space in the same prose sentence of the TypedDict doc.
    Reasoning

    This is a second zero-width space adjacent to the first in the same prose sentence of a markdown doc. It is most likely the same editor or copy-paste artifact. Invisible characters in prose carry no execution risk and only lightly suggest sloppy editing.

  233. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/typed_dict.md:2087:1

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

  234. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/typed_dict.md:4892:1

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

  235. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/unary/not.md:59:1

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

  236. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/unpacking.md:858:1

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

  237. info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/unreachable.md:541:1

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

  238. info unicode-zero-width ruff/crates/ty_python_semantic/src/types/class.rs:1917:73

    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.
  239. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:630:31

    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.)
  240. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:630:58

    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.)
  241. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:631:66

    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.)
        //
  242. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:655:18

    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
  243. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:656:65

    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.)
  244. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:656:95

    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.)
  245. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:686:35

    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)
  246. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:686:54

    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)
  247. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:863:19

    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)
  248. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:863:48

    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)
  249. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:901:25

    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[β])
  250. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:901:48

    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[β])
  251. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:939:23

    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[β])
  252. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:939:44

    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[β])
  253. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:975:19

    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)
  254. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:975:48

    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)
  255. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1001:57

    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[α])
  256. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1003:15

    identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            //
        //   (α ≤ T) ∧ (U ≤ Contra[T]) ⇒ (U ≤ Contra[α])
        if upper
            .bound()
  257. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1003:65

    identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            //
        //   (α ≤ T) ∧ (U ≤ Contra[T]) ⇒ (U ≤ Contra[α])
        if upper
            .bound()
  258. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1035:23

    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,
        //
  259. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1035:44

    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,
        //
  260. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1070:19

    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,
        //
  261. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1070:47

    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,
        //
  262. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1105:25

    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,
        //
  263. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1105:47

    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,
        //
  264. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1140:23

    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,
        //
  265. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1140:43

    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,
        //
  266. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1175:19

    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,
        //
  267. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1175:47

    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,
        //
  268. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1210:25

    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,
        //
  269. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1210:47

    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,
        //
  270. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1245:23

    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,
        //
  271. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1245:43

    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,
        //
  272. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1280:23

    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,
        //
  273. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1280:43

    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,
        //
  274. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1364:40

    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);
  275. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1364:68

    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);
  276. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1382:20

    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());
  277. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1382:30

    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());
  278. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1387:13

    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());
  279. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1387:45

    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());
  280. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1392:14

    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);
  281. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1392:59

    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);
  282. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1420:40

    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);
  283. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1420:68

    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);
  284. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1450:14

    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
  285. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1450:59

    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
  286. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1450:69

    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
  287. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1454:67

    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 = α`.)
  288. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1454:76

    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 = α`.)
  289. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1455:29

    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);
  290. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1455:68

    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);
  291. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1479:40

    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);
  292. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1479:66

    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);
  293. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1501:13

    identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
        // (α ≤ β) ⇒ ((T = β) ⇒ (α ≤ T))
        if self
            .bound
  294. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1501:43

    identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
        // (α ≤ β) ⇒ ((T = β) ⇒ (α ≤ T))
        if self
            .bound
  295. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1509:31

    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);
  296. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1509:56

    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);
  297. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1522:31

    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);
  298. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1522:57

    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);
  299. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1529:40

    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);
  300. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1529:67

    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);
  301. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1542:31

    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)
  302. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1542:55

    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)
  303. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1556:40

    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();
  304. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1556:67

    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();
  305. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1593:46

    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);
  306. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1593:68

    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);
  307. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1612:13

    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());
  308. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1612:36

    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());
  309. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1617:20

    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());
  310. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1617:51

    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());
  311. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1630:20

    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);
  312. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1630:65

    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);
  313. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1658:46

    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);
  314. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1658:66

    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);
  315. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1680:20

    identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
        // (β ≤ α) ⇒ ((T = β) ⇒ (T ≤ α))
        if other
            .bound
  316. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1680:49

    identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    
        // (β ≤ α) ⇒ ((T = β) ⇒ (T ≤ α))
        if other
            .bound
  317. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1688:37

    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);
  318. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1688:56

    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);
  319. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1701:37

    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);
  320. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1701:63

    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);
  321. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1708:46

    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);
  322. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1708:67

    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);
  323. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1721:37

    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)
  324. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1721:61

    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)
  325. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1735:46

    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();
  326. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1735:65

    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();
  327. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1753:51

    identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

        ) {
        // We cannot infer any sequents from `T = α` on its own.
    }
  328. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1764:44

    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);
  329. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1764:64

    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);
  330. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1775:23

    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 {
  331. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1775:44

    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 {
  332. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1791:35

    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);
  333. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1791:54

    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);
  334. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1804:35

    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.
  335. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1804:55

    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.
  336. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1813:35

    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) {
  337. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1813:61

    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) {
  338. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1821:44

    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);
  339. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1821:65

    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);
  340. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1836:35

    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)
  341. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1836:57

    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)
  342. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1850:44

    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();
  343. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1850:63

    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();
  344. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/variables.rs:185:15

    identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            //
        //   (α | β) ≤ T   ⇔ (α ≤ T) ∧ (β ≤ T)
        match bound {
            Type::Union(bound) => Either::Left(
  345. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/variables.rs:185:37

    identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            //
        //   (α | β) ≤ T   ⇔ (α ≤ T) ∧ (β ≤ T)
        match bound {
            Type::Union(bound) => Either::Left(
  346. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/variables.rs:262:21

    identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            //
        //   T ≤ (α & β)   ⇔ (T ≤ α) ∧ (T ≤ β)
        //   T ≤ (¬α & ¬β) ⇔ (T ≤ ¬α) ∧ (T ≤ ¬β)
        match bound {
  347. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/variables.rs:262:43

    identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

            //
        //   T ≤ (α & β)   ⇔ (T ≤ α) ∧ (T ≤ β)
        //   T ≤ (¬α & ¬β) ⇔ (T ≤ ¬α) ∧ (T ≤ ¬β)
        match bound {
  348. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/variables.rs:263:23

    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) => {
  349. info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/variables.rs:263:47

    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) => {
  350. info unicode-mixed-script ruff/crates/ty_python_semantic/src/types/recursive.rs:45:10

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

    //! ```text
//! μF. λT. tuple[T, F[list[T]] | None]
//! ```
//!
  351. info unicode-mixed-script ruff/crates/ty_python_semantic/src/types/recursive.rs:48:54

    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]]`.
  352. info unicode-mixed-script ruff/crates/ty_python_semantic/src/types/recursive.rs:56:18

    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]
  353. info unicode-mixed-script ruff/crates/ty_python_semantic/src/types/recursive.rs:57:24

    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]
//! ```
  354. info unicode-zero-width ruff/crates/ty_python_semantic/src/types/set_theoretic/builder.rs:559:18

    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;
  355. info unicode-zero-width ruff/crates/ty_python_semantic/src/types/set_theoretic/builder.rs:559:21

    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;
  356. info unicode-zero-width ruff/crates/ty_python_semantic/src/types/set_theoretic/builder.rs:562:18

    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.
  357. info unicode-zero-width ruff/crates/ty_python_semantic/src/types/set_theoretic/builder.rs:562:21

    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.

Reproduce This Scan

Run disclude locally to verify. These commands scan the published file; the "new in this release" marks come from comparing it with the previous release's file, which they don't repeat. 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.3.0
curl -fsSL -o ty-0.0.90.tar.gz https://files.pythonhosted.org/packages/68/b1/613b5534624442a9118828d7a9e54d50b16f0f5c8b67c80eb6623f33b921/ty-0.0.90.tar.gz
printf '%s  %s\n' 25cef63ec07a0254c2f5d885a63b001d0bfa437b20caa0a408f4f52e66b133e7 ty-0.0.90.tar.gz | shasum -a 256 -c -
mkdir pkg && tar -xzf ty-0.0.90.tar.gz -C pkg --strip-components 1
disclude scan --untrusted --severity info pkg