ty 0.0.91

Source: https://github.com/astral-sh/ty
Artifact scanned: ty-0.0.91.tar.gz (sdist · 7.7 MB · SHA-256 b9c434cc1e3b…)
Compared with: ty-0.0.90.tar.gz (4 signals introduced since)
Files: 3405 scanned, 1845 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 359 info
Scan time: 48.6 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 16:13

Signals

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

info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/regression/constraint_set_ordering.md:573:1 new in this release

[embedded python] 113 of 253 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)
info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/type_properties/constraints.md:1412:1 new in this release

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

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1744:37 new in this release

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.
        AtomicConstraint::add_sequents_for_range(db, env, map, other, self);

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1744:63 new in this release

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.
        AtomicConstraint::add_sequents_for_range(db, env, map, other, self);

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 symbol in a README pronunciation guide.
Reasoning
The IPA pronunciation guide for 'ty' legitimately uses the IPA long-mark and schwa-like characters; mixed script in prose is expected.
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 symbol 'ɪ' in a README pronunciation guide.
Reasoning
Same IPA pronunciation notation in documentation; not an identifier with malicious intent.

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)",
        );

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,
};
```

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̴̻͈͍͔̹̑͗̎̅͛́Ǫ̵̹̻̝̳͂̌̌͘", email = 1 }
5 | | ]
  | |_^ annotation

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̴̻͈͍͔̹̑͗̎̅͛́Ǫ̵̹̻̝̳͂̌̌͘", email = 1 }
5 | | ]
  | |_^ annotation

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̴̻͈͍͔̹̑͗̎̅͛́Ǫ̵̹̻̝̳͂̌̌͘", email = 1 }
5 │ ┃ ]
  ╰╴┗━┛ annotation

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̴̻͈͍͔̹̑͗̎̅͛́Ǫ̵̹̻̝̳͂̌̌͘", email = 1 }
5 │ ┃ ]
  ╰╴┗━┛ annotation

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}�";

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⟩␝�:�␜␇�
  | ^

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⟩␝�:�␜␇�
  │ ━

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() {
}
```
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 fixture deliberately containing a non-breaking space to test whitespace handling.
Reasoning
The comment explicitly documents that U+00A0 is a whitespace symbol being tested for non-skipping behavior; it is a deliberate test fixture.

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);

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,

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>,
```
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.90 Test string containing non-breaking space in a stylist indentation test.
Reasoning
Stylist tests for indentation detection in a Rust source file; the NBSP appears in a test string fixture for whitespace/indent handling, consistent with ruff's test suite.
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.90 Test string with non-breaking space in stylist test fixture.
Reasoning
Same test fixture for indentation/stylist testing; the whitespace anomaly is a deliberate test input.
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.90 Test string with non-breaking space in stylist test fixture.
Reasoning
Same stylist test fixture; no execution or exfiltration, just formatter test input.
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
  """
```
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)
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)
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)
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)
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)
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)
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)
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 with repeated power operator expressions.
Reasoning
Black's power-operator spacing test case consists of repeated exponentiation expressions; the narrow charset is an artifact of the numeric test content, not obfuscation.

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"]}')

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.92 Multilingual string literals used in a long-string formatting test.
Reasoning
Ordinary Korean and Chinese string literals in a formatter test about east-asian width; high compression ratio is an artifact of short text, not malicious.
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 Regression test fixture calling os.system with a formatted string literal.
Reasoning
This is a formatter test input; the os.system call is inside a fixture file never executed, and the command is a literal string with .format applied, not a real dropper.

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}:/'"

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)
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.85 Test fixture identifier containing a variation selector supplement character.
Reasoning
Black's tricky unicode symbols fixture intentionally includes variation selectors in identifiers to test formatter handling; it is a test case, not a payload.
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
```
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.
```
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
```
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)
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
```
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.85 Formatter test input with subprocess shell=True and an rm -rf f-string.
Reasoning
Formatter fixture for lambda expressions; the rm -rf command is inside a non-executed test file and the shell=True call is only syntactic input for formatting.
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.85 Formatter test input with subprocess shell=True in a lambda test case.
Reasoning
Same formatter test fixture pattern for lambda formatting; not executed code.
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)
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)

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"

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
```
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)
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
 	(
```
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)
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)
```
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)
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)
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
```
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
```
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)
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)
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)
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"""
```
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"""
```
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"""
```
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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
```

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 {

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"""

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 {

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([]),

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.85 Test string enumerating byte escapes in the Rust string parser tests.
Reasoning
A run of \xNN escapes enumerating all byte values is a parser unit test verifying escape handling, not an encoded payload.
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.90 A run of \xNN escape sequences in Rust string-parser code, most likely a test table of byte values.
Reasoning
The snippet is a long run of byte-escape sequences in a Rust parser source file, which is typical of test fixtures that exercise string escape handling. Nothing indicates an encoded payload or execution.
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.90 A sequential table of byte escapes in Rust parser code, consistent with an exhaustive escape-handling test.
Reasoning
This is a sequential table of all byte values written as escapes, in the ruff parser's string handling code. It is a standard way to write exhaustive escape tests, and the high entropy reflects the byte range rather than hidden data.
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.90 A continuation of the byte-value escape table in Rust parser code, consistent with a test fixture.
Reasoning
This is a continuation of the same sequential byte-value table in ruff's Rust string parser. It is test or reference data for escape handling, with no execution or decoding behavior.

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);

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"));

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"));
```
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"));
```
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"));
/// ```
```
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"));
/// ```
```
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 {
```
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"));
```
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"));
/// ```
```
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 {
```
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 {
```
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"
"#,
            )
```
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"
          | |__________^
```
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"
          | ^^^^^^^^^
        "#);
```
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)
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)
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.92 A generated Python stress-test line of many dict unpacks in a type checker corpus.
Reasoning
The file is in a type-checker test corpus and is named as a stress case for huge dict unpacking. The long line is a generated stress input, not obfuscation.
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)
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)
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)
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.80 A corpus test file assigning builtins.__import__ with an annotation, used to exercise the type checker.
Reasoning
The file sits in a type-checker test corpus and is named for annotation handling. The assignment to builtins.__import__ is a semantic test input for type inference, not a deployed patch. It would be a concern in ordinary package code, which this is not.
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)
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)
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)
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)
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)
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)
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)
info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/bidirectional.md:2651:1

[embedded python] 18 of 42 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)
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)
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)
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)
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.85 An mdtest example calling __import__ on a non-literal, used to check the type checker's revealed type.
Reasoning
This is a markdown mdtest of how the type checker reveals the type of __import__ called on a variable. The dynamic call is the thing being tested, and the reveal_type comments show it is an analysis fixture.
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)
info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/call/functools_partial.md:1013:1

[embedded python] 16 of 34 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)
info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/call/functools_partial.md:1727:1

[embedded python] 15 of 31 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/legacy/callables.md:1111:1

[embedded python] 22 of 52 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
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)
info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/legacy/functions.md:1729:1

[embedded python] 16 of 36 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)
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)
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)
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)
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)
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)
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)
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)
info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/callables.md:1409:1

[embedded python] 22 of 46 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)
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)
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)
info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md:2496:1

[embedded python] 15 of 30 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)
info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md:2655:1

[embedded python] 29 of 69 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md:2795:1

[embedded python] 22 of 38 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)
info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md:2978:1

[embedded python] 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)
info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md:3592:1

[embedded python] 57 of 106 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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.85 An mdtest assignment to builtins.foo with an expected diagnostic, used to test the type checker.
Reasoning
The markdown mdtest contains deliberate builtins writes annotated with expected checker errors such as error: [unresolved-attribute]. These are test expectations for the type checker, not live patches.
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.85 An mdtest assignment to builtins.bar annotated with an expected error, part of a type checker test.
Reasoning
This is one of a block of mdtest lines assigning builtins attributes, each annotated with an expected diagnostic comment. The block is a test of how assignments to builtins are diagnosed.
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.85 An mdtest assignment to builtins.baz with an expected error annotation, used for type checker testing.
Reasoning
The line is part of the same mdtest block, with checker error annotations marking expected diagnostics. It is a test fixture, not runtime code.
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.85 An mdtest assignment to builtins.chr with an expected error annotation, used for type checker testing.
Reasoning
This assignment to builtins.chr appears in an mdtest block with expected diagnostic comments. It exercises the checker's handling of builtin attribute assignment.
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.85 A second mdtest assignment to builtins.chr, part of a type checker test block.
Reasoning
This second assignment to builtins.chr is part of the same mdtest fixture, which tests how the type checker diagnoses such writes. The code is never executed as deployed software.
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)
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)
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 An mdtest identifier using a letter-like Unicode symbol that normalizes to __all__, likely a test of normalization in star-import handling.
Reasoning
The identifier mixes Latin with a letter-like symbol and is used with append inside an mdtest for star-import __all__ handling. Such a name normalizes to __all__ under NFKC, so the test appears to check Unicode normalization of dunder names. It is a deliberate fixture, but the mixed-script name is the kind of construct the scanner flags, so some doubt remains.
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)

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

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

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)
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)
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)
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)
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)
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.85 An obfuscated eval that builds 'int' inside a type-checker conformance test case expecting an invalid-type-form error.
Reasoning
This is a markdown test fixture for a type checker's conformance suite. The eval call decodes to the string 'int' and is annotated with an expected error, so it is a deliberately obfuscated invalid type alias meant to be rejected. Markdown fixtures are not imported or run by users, so the module-scope eval is test data, not a dropper.
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)
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)
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)
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 Dᵧ in a logic table of quantifier examples.
Reasoning
The identifier Dᵧ uses a Unicode subscript y, which is standard mathematical notation in a quantifier-logic table. The mixed-script flag comes from the subscript being classed as 'Other', and the pattern is legitimate in documentation.
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 Dₓ in the same logic table of quantifier examples.
Reasoning
The identifier Dₓ uses a Unicode subscript x in the same mathematical table as Dᵧ. This is conventional notation in prose, not an identifier used to hide code or evade review.
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)
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)
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)
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.75 A stray zero-width space in explanatory prose about TypedDict value types.
Reasoning
A zero-width space sits in prose before a code block. It does not alter any code, and the sentence reads normally. This looks like a copy-paste or editing artifact rather than an attempt to hide instructions or change executed logic.
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.75 A second stray zero-width space in the same prose sentence about TypedDict inference.
Reasoning
A second zero-width space appears adjacent to the first in the same prose line, consistent with a copy-paste artifact. The surrounding text is ordinary documentation with no hidden content and no effect on the following code block.
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)
info identifier-low-length ruff/crates/ty_python_semantic/resources/mdtest/typed_dict.md:4891:1

[embedded python] 19 of 42 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)
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)
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)
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)

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
        //
        //   (α ≤ T) ∧ (U ≤ Contra[T]) ⇒ (U ≤ Contra[α])
        if upper
            .bound()
```
info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1051:65

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
        //
        //   (α ≤ T) ∧ (U ≤ Contra[T]) ⇒ (U ≤ Contra[α])
        if upper
            .bound()
```
info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1083: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,
        //
```
info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1083: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,
        //
```
info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1118: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,
        //
```
info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1118: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,
        //
```
info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1153: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,
        //
```
info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1153: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,
        //
```
info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1188: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,
        //
```
info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1188: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,
        //
```

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

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

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

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

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

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

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

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1412: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) {
            AtomicConstraint::add_covariant_lower_tightened_sequent(db, env, map, self, other);

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1412: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) {
            AtomicConstraint::add_covariant_lower_tightened_sequent(db, env, map, self, other);

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

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

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

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

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

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

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1468: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) {
            AtomicConstraint::add_contravariant_tightened_sequent(db, env, map, self, other);

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1468: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) {
            AtomicConstraint::add_contravariant_tightened_sequent(db, env, map, self, other);

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

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

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

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

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

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

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

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1527: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) {
            AtomicConstraint::add_covariant_lower_tightened_sequent(db, env, map, self, other);

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1527: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) {
            AtomicConstraint::add_covariant_lower_tightened_sequent(db, env, map, self, other);

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1549:13

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


        // (α ≤ β) ⇒ ((T = β) ⇒ (α ≤ T))
        // This requires a static equivalence bound: `T = Any` permits `T = str`, so
        // assignability of `int` to `Any` does not imply `int ≤ T`.

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1549:43

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


        // (α ≤ β) ⇒ ((T = β) ⇒ (α ≤ T))
        // This requires a static equivalence bound: `T = Any` permits `T = str`, so
        // assignability of `int` to `Any` does not imply `int ≤ T`.

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1560: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.
        AtomicConstraint::add_sequents_for_range(db, env, map, self, other);

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1560: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.
        AtomicConstraint::add_sequents_for_range(db, env, map, self, other);

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

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

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1580: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.
        AtomicConstraint::add_covariant_lower_weakened_sequent(db, env, map, self, other);
        AtomicConstraint::add_contravariant_lower_weakened_sequent(db, env, map, self, other);

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1580: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.
        AtomicConstraint::add_covariant_lower_weakened_sequent(db, env, map, self, other);
        AtomicConstraint::add_contravariant_lower_weakened_sequent(db, env, map, self, other);

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

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

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

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

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1646: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) {
            AtomicConstraint::add_covariant_upper_tightened_sequent(db, env, map, self, other);

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1646: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) {
            AtomicConstraint::add_covariant_upper_tightened_sequent(db, env, map, self, other);

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

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

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

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

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

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

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1711: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) {
            AtomicConstraint::add_covariant_upper_tightened_sequent(db, env, map, self, other);

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1711: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) {
            AtomicConstraint::add_covariant_upper_tightened_sequent(db, env, map, self, other);

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1733:20

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


        // (β ≤ α) ⇒ ((T = β) ⇒ (T ≤ α))
        // This requires a static equivalence bound: `T = Any` permits `T = str`, so
        // assignability of `Any` to `int` does not imply `T ≤ int`.

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1733:49

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


        // (β ≤ α) ⇒ ((T = β) ⇒ (T ≤ α))
        // This requires a static equivalence bound: `T = Any` permits `T = str`, so
        // assignability of `Any` to `int` does not imply `T ≤ int`.

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

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

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1764: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.
        AtomicConstraint::add_covariant_upper_weakened_sequent(db, env, map, self, other);
        AtomicConstraint::add_contravariant_upper_weakened_sequent(db, env, map, self, other);

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1764: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.
        AtomicConstraint::add_covariant_upper_weakened_sequent(db, env, map, self, other);
        AtomicConstraint::add_contravariant_upper_weakened_sequent(db, env, map, self, other);

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

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

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

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

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1809: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.
    }
```

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1820: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) {
            AtomicConstraint::add_covariant_equivalence_tightened_sequent(

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1820: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) {
            AtomicConstraint::add_covariant_equivalence_tightened_sequent(

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

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

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1851: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.
        AtomicConstraint::add_sequents_for_equivalence(db, env, map, self, other);

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1851: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.
        AtomicConstraint::add_sequents_for_equivalence(db, env, map, self, other);

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

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

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

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

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1881: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.
        AtomicConstraint::add_covariant_lower_weakened_sequent(db, env, map, self, other);
        AtomicConstraint::add_covariant_upper_weakened_sequent(db, env, map, self, other);

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/sequents.rs:1881: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.
        AtomicConstraint::add_covariant_lower_weakened_sequent(db, env, map, self, other);
        AtomicConstraint::add_covariant_upper_weakened_sequent(db, env, map, self, other);

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

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

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

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

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/variables.rs:256: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(
```
info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/variables.rs:256: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(
```

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/variables.rs:333:21

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

        //
        //   T ≤ (α & β)   ⇔ (T ≤ α) ∧ (T ≤ β)
        //   T ≤ (¬α & ¬β) ⇔ (T ≤ ¬α) ∧ (T ≤ ¬β)
        match bound {

info unicode-homoglyph ruff/crates/ty_python_semantic/src/types/constraints/variables.rs:333:43

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

        //
        //   T ≤ (α & β)   ⇔ (T ≤ α) ∧ (T ≤ β)
        //   T ≤ (¬α & ¬β) ⇔ (T ≤ ¬α) ∧ (T ≤ ¬β)
        match bound {

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

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

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]
//! ```
//!
```

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]]`.

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]

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]
//! ```

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;

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;

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.

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.91.tar.gz https://files.pythonhosted.org/packages/08/c0/9e26817a5c94d504aab30bffbbf53f836f4763dd0a947089246ff555eebe/ty-0.0.91.tar.gz
printf '%s  %s\n' b9c434cc1e3b106b6b9353b78ef304d5904c82cf440abcafef7134270a22b41a ty-0.0.91.tar.gz | shasum -a 256 -c -
mkdir pkg && tar -xzf ty-0.0.91.tar.gz -C pkg --strip-components 1
disclude scan --untrusted --severity info pkg