disclude.io

crates.io / memchr / 2.8.3

memchr 2.8.3

Source
https://github.com/BurntSushi/memchr
Tag scanned
2.8.3
Compared with
2.8.2 (0 signals introduced since)
Files
108 scanned, 51 skipped (binary, oversized, or unrecognised)
Signals
0 critical · 0 warn · 174 info
Scan time
13.3 s
LLM review
Reviewed by claude-haiku-5-5 (Anthropic): 16 of 16 warn and critical signals; 16 demoted to info.
Disclude version
4.1.0
Scanned (UTC)
2026-10-22 22:15

Signals

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

  1. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:82:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn char_iterator(b: &mut Bencher) {
    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";

    b.iter(|| s.chars().count());
  2. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:89:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn char_iterator_for(b: &mut Bencher) {
    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";

    b.iter(|| {
  3. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:112:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn char_iterator_rev(b: &mut Bencher) {
    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";

    b.iter(|| s.chars().rev().count());
  4. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:119:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn char_iterator_rev_for(b: &mut Bencher) {
    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";

    b.iter(|| {
  5. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:130:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn char_indicesator(b: &mut Bencher) {
    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
    let len = s.chars().count();
  6. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:138:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn char_indicesator_rev(b: &mut Bencher) {
    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
    let len = s.chars().count();
  7. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:146:14

    identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn split_unicode_ascii(b: &mut Bencher) {
    let s = "ประเทศไทย中华Việt Namประเทศไทย中华Việt Nam";

    b.iter(|| assert_eq!(s.split('V').count(), 3));
  8. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:146:54

    identifier `Namประเทศไทย中华Việt` mixes scripts: Latin + Other + Han (in string/comment) (raw pass, confidence 0.40)

    fn split_unicode_ascii(b: &mut Bencher) {
    let s = "ประเทศไทย中华Việt Namประเทศไทย中华Việt Nam";

    b.iter(|| assert_eq!(s.split('V').count(), 3));
  9. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:189:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn bench_join(b: &mut Bencher) {
    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
    let sep = "→";
    let v = vec![s, s, s, s, s, s, s, s, s, s];
  10. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:299:18

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

                make_test_inner!($s, $code, short_mixed,
                "ศไทย中华Việt Nam; Mary had a little lamb, Little lam!", $iters);
            make_test_inner!($s, $code, short_pile_of_poo,
                "💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩!", $iters);
  11. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:387:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn bench_push_str(b: &mut Bencher) {
    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
    b.iter(|| {
        let mut r = String::new();
  12. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:442:14

    identifier `𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة` mixes scripts: Other + Arabic (in string/comment) (raw pass, confidence 0.40)

    fn from_utf8_lossy_100_multibyte(b: &mut Bencher) {
    let s = "𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰".as_bytes();
    assert_eq!(100, s.len());
    b.iter(|| {
  13. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:442:53

    identifier `الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰` mixes scripts: Arabic + Other + Han (in string/comment) (raw pass, confidence 0.40)

    fn from_utf8_lossy_100_multibyte(b: &mut Bencher) {
    let s = "𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰".as_bytes();
    assert_eq!(100, s.len());
    b.iter(|| {
  14. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3512:17

    identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

        assert!("hello".find(|c: char| c == 'x').is_none());
    assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30));
    assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30));
}
  15. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3513:17

    identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

        assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30));
    assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30));
}
  16. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3522:17

    identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

        assert!("hello".rfind(|c: char| c == 'x').is_none());
    assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30));
    assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30));
}
  17. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3523:17

    identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

        assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30));
    assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30));
}
  18. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3531:17

    identifier `ประเทศไทย中` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

        assert_eq!(empty, s);
    let data = "ประเทศไทย中";
    let s: String = data.chars().collect();
    assert_eq!(data, s);
  19. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3554:19

    identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    
    let string = "ประเทศไทย中华Việt Nam";
    let mut data = String::from(string);
    data.push_str(string);
  20. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3557:24

    identifier `ไท华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

        data.push_str(string);
    assert!(data.find("ไท华").is_none());
    assert_eq!(data[0..43].find(""), Some(0));
    assert_eq!(data[6..43].find(""), Some(6 - 6));
  21. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3563:34

    identifier `ย中` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

        assert_eq!(data[0..43].find("ทศไ"), Some(12));
    assert_eq!(data[0..43].find("ย中"), Some(24));
    assert_eq!(data[0..43].find("iệt"), Some(34));
    assert_eq!(data[0..43].find("Nam"), Some(40));
  22. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3569:35

    identifier `ย中` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

        assert_eq!(data[43..86].find("ทศไ"), Some(55 - 43));
    assert_eq!(data[43..86].find("ย中"), Some(67 - 43));
    assert_eq!(data[43..86].find("iệt"), Some(77 - 43));
    assert_eq!(data[43..86].find("Nam"), Some(83 - 43));
  23. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3769:17

    identifier `ประเทศไทย中华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

    fn test_replace_2a() {
    let data = "ประเทศไทย中华";
    let repl = "دولة الكويت";
  24. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3773:24

    identifier `الكويتทศไทย中华` mixes scripts: Arabic + Other + Han (in string/comment) (raw pass, confidence 0.40)

        let a = "ประเ";
    let a2 = "دولة الكويتทศไทย中华";
    assert_eq!(data.replace(a, repl), a2);
}
  25. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3779:17

    identifier `ประเทศไทย中华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

    fn test_replace_2b() {
    let data = "ประเทศไทย中华";
    let repl = "دولة الكويت";
  26. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3783:15

    identifier `ปรدولة` mixes scripts: Other + Arabic (in string/comment) (raw pass, confidence 0.40)

        let b = "ะเ";
    let b2 = "ปรدولة الكويتทศไทย中华";
    assert_eq!(data.replace(b, repl), b2);
}
  27. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3783:30

    identifier `الكويتทศไทย中华` mixes scripts: Arabic + Other + Han (in string/comment) (raw pass, confidence 0.40)

        let b = "ะเ";
    let b2 = "ปรدولة الكويتทศไทย中华";
    assert_eq!(data.replace(b, repl), b2);
}
  28. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3789:17

    identifier `ประเทศไทย中华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

    fn test_replace_2c() {
    let data = "ประเทศไทย中华";
    let repl = "دولة الكويت";
  29. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3793:15

    identifier `ประเทศไทยدولة` mixes scripts: Other + Arabic (in string/comment) (raw pass, confidence 0.40)

        let c = "中华";
    let c2 = "ประเทศไทยدولة الكويت";
    assert_eq!(data.replace(c, repl), c2);
}
  30. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3799:17

    identifier `ประเทศไทย中华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

    fn test_replace_2d() {
    let data = "ประเทศไทย中华";
    let repl = "دولة الكويت";
  31. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3802:14

    identifier `ไท华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

    
    let d = "ไท华";
    assert_eq!(data.replace(d, repl), data);
}
  32. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:3808:17

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

    fn test_replace_pattern() {
    let data = "abcdαβγδabcdαβγδ";
    assert_eq!(data.replace("dαβ", "😺😺😺"), "abc😺😺😺γδabc😺😺😺γδ");
    assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
  33. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3808:17

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

    fn test_replace_pattern() {
    let data = "abcdαβγδabcdαβγδ";
    assert_eq!(data.replace("dαβ", "😺😺😺"), "abc😺😺😺γδabc😺😺😺γδ");
    assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
  34. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:3809:30

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

        let data = "abcdαβγδabcdαβγδ";
    assert_eq!(data.replace("dαβ", "😺😺😺"), "abc😺😺😺γδabc😺😺😺γδ");
    assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
  35. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3809:30

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

        let data = "abcdαβγδabcdαβγδ";
    assert_eq!(data.replace("dαβ", "😺😺😺"), "abc😺😺😺γδabc😺😺😺γδ");
    assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
  36. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3809:71

    identifier `γδabc` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

        let data = "abcdαβγδabcdαβγδ";
    assert_eq!(data.replace("dαβ", "😺😺😺"), "abc😺😺😺γδabc😺😺😺γδ");
    assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
  37. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:3810:53

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

        assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
  38. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3810:53

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

        assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
  39. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:3810:73

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

        assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
  40. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3810:73

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

        assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
  41. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:3811:81

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

        assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
}
  42. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3811:81

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

        assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
}
  43. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:3811:114

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

        assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
}
  44. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3811:114

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

        assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
}
  45. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:3812:62

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

        assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
}
  46. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3812:62

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

        assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
}
  47. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:3812:82

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

        assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
}
  48. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3812:82

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

        assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
}
  49. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3972:21

    identifier `ประเทศไทย中华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

    
        let data = "ประเทศไทย中华";
        assert_range_eq!(data, 0..3, "ป");
        assert_range_eq!(data, 3..6, "ร");
  50. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4134:29

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

        mod boundary {
        const DATA: &str = "abcαβγ";

        const BAD_START: usize = 4;
  51. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4134:29

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

        mod boundary {
        const DATA: &str = "abcαβγ";

        const BAD_START: usize = 4;
  52. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4151:73

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

                    message:
                    "byte index 4 is not a char boundary; it is inside 'α' (bytes 3..5) of";
            }
  53. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4165:73

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

                    message:
                    "byte index 4 is not a char boundary; it is inside 'α' (bytes 3..5) of";
            }
  54. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4179:73

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

                    message:
                    "byte index 4 is not a char boundary; it is inside 'α' (bytes 3..5) of";
            }
  55. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4222:14

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

    fn test_str_slice_rangetoinclusive_ok() {
    let s = "abcαβγ";
    assert_eq!(&s[..=2], "abc");
    assert_eq!(&s[..=4], "abcα");
  56. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4222:14

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

    fn test_str_slice_rangetoinclusive_ok() {
    let s = "abcαβγ";
    assert_eq!(&s[..=2], "abc");
    assert_eq!(&s[..=4], "abcα");
  57. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4224:27

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

        assert_eq!(&s[..=2], "abc");
    assert_eq!(&s[..=4], "abcα");
}
  58. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4224:27

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

        assert_eq!(&s[..=2], "abc");
    assert_eq!(&s[..=4], "abcα");
}
  59. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4230:14

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

    fn test_str_slice_rangetoinclusive_notok() {
    let s = "abcαβγ";
    &s[..=3];
}
  60. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4230:14

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

    fn test_str_slice_rangetoinclusive_notok() {
    let s = "abcαβγ";
    &s[..=3];
}
  61. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4236:18

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

    fn test_str_slicemut_rangetoinclusive_ok() {
    let mut s = "abcαβγ".to_owned();
    let s: &mut str = &mut s;
    assert_eq!(&mut s[..=2], "abc");
  62. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4236:18

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

    fn test_str_slicemut_rangetoinclusive_ok() {
    let mut s = "abcαβγ".to_owned();
    let s: &mut str = &mut s;
    assert_eq!(&mut s[..=2], "abc");
  63. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4239:31

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

        assert_eq!(&mut s[..=2], "abc");
    assert_eq!(&mut s[..=4], "abcα");
}
  64. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4239:31

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

        assert_eq!(&mut s[..=2], "abc");
    assert_eq!(&mut s[..=4], "abcα");
}
  65. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4245:18

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

    fn test_str_slicemut_rangetoinclusive_notok() {
    let mut s = "abcαβγ".to_owned();
    let s: &mut str = &mut s;
    &mut s[..=3];
  66. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4245:18

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

    fn test_str_slicemut_rangetoinclusive_notok() {
    let mut s = "abcαβγ".to_owned();
    let s: &mut str = &mut s;
    &mut s[..=3];
  67. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4252:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_is_char_boundary() {
    let s = "ศไทย中华Việt Nam β-release 🐱123";
    assert!(s.is_char_boundary(0));
    assert!(s.is_char_boundary(s.len()));
  68. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4431:17

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

        assert_eq!("abc".as_bytes(), b"abc");
    assert_eq!("ศไทย中华Việt Nam".as_bytes(), v);
}
  69. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4484:17

    identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    
    let data = "ประเทศไทย中华Việt Nam";
    assert!(data.contains("ประเ"));
    assert!(data.contains("ะเ"));
  70. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4488:29

    identifier `ไท华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

        assert!(data.contains("中华"));
    assert!(!data.contains("ไท华"));
}
  71. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4501:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_split_at() {
    let s = "ศไทย中华Việt Nam";
    for (index, _) in s.char_indices() {
        let (a, b) = s.split_at(index);
  72. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4526:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_split_at_boundscheck() {
    let s = "ศไทย中华Việt Nam";
    s.split_at(1);
}
  73. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4592:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_iterator() {
    let s = "ศไทย中华Việt Nam";
    let v = ['ศ', 'ไ', 'ท', 'ย', '中', '华', 'V', 'i', 'ệ', 't', ' ', 'N', 'a', 'm'];
  74. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4608:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_rev_iterator() {
    let s = "ศไทย中华Việt Nam";
    let v = ['m', 'a', 'N', ' ', 't', 'ệ', 'i', 'V', '华', '中', 'ย', 'ท', 'ไ', 'ศ'];
  75. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4647:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_iterator_clone() {
    let s = "ศไทย中华Việt Nam";
    let mut it = s.chars();
    it.next();
  76. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4655:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_iterator_last() {
    let s = "ศไทย中华Việt Nam";
    let mut it = s.chars();
    it.next();
  77. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4663:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_chars_debug() {
    let s = "ศไทย中华Việt Nam";
    let c = s.chars();
    assert_eq!(
  78. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4673:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_bytesator() {
    let s = "ศไทย中华Việt Nam";
    let v = [
        224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228, 184, 173, 229, 141, 142,
  79. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4688:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_bytes_revator() {
    let s = "ศไทย中华Việt Nam";
    let v = [
        224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228, 184, 173, 229, 141, 142,
  80. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4703:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_bytesator_nth() {
    let s = "ศไทย中华Việt Nam";
    let v = [
        224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228, 184, 173, 229, 141, 142,
  81. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4717:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_bytesator_count() {
    let s = "ศไทย中华Việt Nam";

    let b = s.bytes();
  82. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4725:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_bytesator_last() {
    let s = "ศไทย中华Việt Nam";

    let b = s.bytes();
  83. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4733:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_char_indicesator() {
    let s = "ศไทย中华Việt Nam";
    let p = [0, 3, 6, 9, 12, 15, 18, 19, 20, 23, 24, 25, 26, 27];
    let v = ['ศ', 'ไ', 'ท', 'ย', '中', '华', 'V', 'i', 'ệ', 't', ' ', 'N', 'a', 'm'];
  84. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4750:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_char_indices_revator() {
    let s = "ศไทย中华Việt Nam";
    let p = [27, 26, 25, 24, 23, 20, 19, 18, 15, 12, 9, 6, 3, 0];
    let v = ['m', 'a', 'N', ' ', 't', 'ệ', 'i', 'V', '华', '中', 'ย', 'ท', 'ไ', 'ศ'];
  85. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4767:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_char_indices_last() {
    let s = "ศไทย中华Việt Nam";
    let mut it = s.char_indices();
    it.next();
  86. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4926:8

    identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

        t("::hello::there::", "::", &["", "hello", "there", ""]);
    t("ประเทศไทย中华Việt Nam", "中华", &["ประเทศไทย", "Việt Nam"]);
    t("zzXXXzzYYYzz", "zz", &["", "XXX", "YYY", ""]);
    t("zzXXXzYYYz", "XXX", &["zz", "zYYYz"]);
  87. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4968:15

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    
    let xs = "ศไทย中华Việt Nam".as_bytes();
    assert_eq!(from_utf8(xs), Ok("ศไทย中华Việt Nam"));
  88. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4969:35

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

        let xs = "ศไทย中华Việt Nam".as_bytes();
    assert_eq!(from_utf8(xs), Ok("ศไทย中华Việt Nam"));

    let xs = b"hello\xFF";
  89. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5155:17

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

        assert_eq!("ΑΣ".to_lowercase(), "ας");
    assert_eq!("Α'Σ".to_lowercase(), "α'ς");
    assert_eq!("Α''Σ".to_lowercase(), "α''ς");
  90. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5155:41

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

        assert_eq!("ΑΣ".to_lowercase(), "ας");
    assert_eq!("Α'Σ".to_lowercase(), "α'ς");
    assert_eq!("Α''Σ".to_lowercase(), "α''ς");
  91. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5156:17

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

        assert_eq!("Α'Σ".to_lowercase(), "α'ς");
    assert_eq!("Α''Σ".to_lowercase(), "α''ς");

    assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
  92. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5156:42

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

        assert_eq!("Α'Σ".to_lowercase(), "α'ς");
    assert_eq!("Α''Σ".to_lowercase(), "α''ς");

    assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
  93. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5158:22

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

    
    assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");
  94. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5158:48

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

    
    assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");
  95. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5159:17

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

        assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");
  96. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5159:23

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

        assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");
  97. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5159:44

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

        assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");
  98. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5159:50

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

        assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");
  99. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5160:17

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

        assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");

    assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");
  100. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5160:24

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

        assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");

    assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");
  101. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5160:45

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

        assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");

    assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");
  102. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5160:52

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

        assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");

    assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");
  103. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5162:23

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

    
    assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");
    assert_eq!("ΑΣ'' Α".to_lowercase(), "ας'' α");
  104. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5162:50

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

    
    assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");
    assert_eq!("ΑΣ'' Α".to_lowercase(), "ας'' α");
  105. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5163:24

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

        assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");
    assert_eq!("ΑΣ'' Α".to_lowercase(), "ας'' α");

    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
  106. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5163:52

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

        assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");
    assert_eq!("ΑΣ'' Α".to_lowercase(), "ας'' α");

    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
  107. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5165:17

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

    
    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");
  108. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5165:24

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

    
    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");
  109. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5165:45

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

    
    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");
  110. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5165:52

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

    
    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");
  111. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5166:17

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

        assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");

    assert_eq!("Α Σ".to_lowercase(), "α σ");
  112. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5166:26

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

        assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");

    assert_eq!("Α Σ".to_lowercase(), "α σ");
  113. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5166:47

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

        assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");

    assert_eq!("Α Σ".to_lowercase(), "α σ");
  114. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5166:56

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

        assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");

    assert_eq!("Α Σ".to_lowercase(), "α σ");
  115. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5168:17

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

    
    assert_eq!("Α Σ".to_lowercase(), "α σ");
    assert_eq!("Α 'Σ".to_lowercase(), "α 'σ");
    assert_eq!("Α ''Σ".to_lowercase(), "α ''σ");
  116. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5168:41

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

    
    assert_eq!("Α Σ".to_lowercase(), "α σ");
    assert_eq!("Α 'Σ".to_lowercase(), "α 'σ");
    assert_eq!("Α ''Σ".to_lowercase(), "α ''σ");
  117. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5169:17

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

        assert_eq!("Α Σ".to_lowercase(), "α σ");
    assert_eq!("Α 'Σ".to_lowercase(), "α 'σ");
    assert_eq!("Α ''Σ".to_lowercase(), "α ''σ");
  118. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5169:42

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

        assert_eq!("Α Σ".to_lowercase(), "α σ");
    assert_eq!("Α 'Σ".to_lowercase(), "α 'σ");
    assert_eq!("Α ''Σ".to_lowercase(), "α ''σ");
  119. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5170:17

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

        assert_eq!("Α 'Σ".to_lowercase(), "α 'σ");
    assert_eq!("Α ''Σ".to_lowercase(), "α ''σ");

    assert_eq!("Σ".to_lowercase(), "σ");
  120. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5170:43

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

        assert_eq!("Α 'Σ".to_lowercase(), "α 'σ");
    assert_eq!("Α ''Σ".to_lowercase(), "α ''σ");

    assert_eq!("Σ".to_lowercase(), "σ");
  121. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5177:22

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

        assert_eq!("ΑΣΑ".to_lowercase(), "ασα");
    assert_eq!("ΑΣ'Α".to_lowercase(), "ασ'α");
    assert_eq!("ΑΣ''Α".to_lowercase(), "ασ''α");
}
  122. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5177:48

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

        assert_eq!("ΑΣΑ".to_lowercase(), "ασα");
    assert_eq!("ΑΣ'Α".to_lowercase(), "ασ'α");
    assert_eq!("ΑΣ''Α".to_lowercase(), "ασ''α");
}
  123. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5178:23

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

        assert_eq!("ΑΣ'Α".to_lowercase(), "ασ'α");
    assert_eq!("ΑΣ''Α".to_lowercase(), "ασ''α");
}
  124. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5178:50

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

        assert_eq!("ΑΣ'Α".to_lowercase(), "ασ'α");
    assert_eq!("ΑΣ''Α".to_lowercase(), "ασ''α");
}
  125. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5184:17

    identifier `aéDžßfiᾀ` mixes scripts: Latin + Other + Greek (in string/comment) (raw pass, confidence 0.40)

        assert_eq!("".to_uppercase(), "");
    assert_eq!("aéDžßfiᾀ".to_uppercase(), "AÉDŽSSFIἈΙ");
}
  126. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5184:49

    identifier `AÉDŽSSFIἈΙ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

        assert_eq!("".to_uppercase(), "");
    assert_eq!("aéDžßfiᾀ".to_uppercase(), "AÉDŽSSFIἈΙ");
}
  127. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5217:17

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

        assert_eq!("abc".repeat(0), "");
    assert_eq!("α".repeat(3), "ααα");
}
  128. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5217:33

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

        assert_eq!("abc".repeat(0), "");
    assert_eq!("α".repeat(3), "ααα");
}
  129. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5666:15

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    
    let xs = "ศไทย中华Việt Nam".as_bytes().to_vec();
    assert_eq!(String::from_utf8(xs).unwrap(), String::from("ศไทย中华Việt Nam"));
  130. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5667:62

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

        let xs = "ศไทย中华Việt Nam".as_bytes().to_vec();
    assert_eq!(String::from_utf8(xs).unwrap(), String::from("ศไทย中华Việt Nam"));

    let xs = b"hello\xFF".to_vec();
  131. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5684:15

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    
    let xs = "ศไทย中华Việt Nam".as_bytes();
    let ys: Cow<'_, str> = "ศไทย中华Việt Nam".into_cow();
    assert_eq!(String::from_utf8_lossy(xs), ys);
  132. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5685:29

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

        let xs = "ศไทย中华Việt Nam".as_bytes();
    let ys: Cow<'_, str> = "ศไทย中华Việt Nam".into_cow();
    assert_eq!(String::from_utf8_lossy(xs), ys);
  133. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5837:17

    identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

        assert_eq!(&s[0..], "abc");
    s.push_str("ประเทศไทย中华Việt Nam");
    assert_eq!(&s[0..], "abcประเทศไทย中华Việt Nam");
}
  134. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5838:26

    identifier `abcประเทศไทย中华Việt` mixes scripts: Latin + Other + Han (in string/comment) (raw pass, confidence 0.40)

        s.push_str("ประเทศไทย中华Việt Nam");
    assert_eq!(&s[0..], "abcประเทศไทย中华Việt Nam");
}
  135. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5848:11

    identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

        assert_eq!(s.as_str(), "abc");
    s += "ประเทศไทย中华Việt Nam";
    assert_eq!(s.as_str(), "abcประเทศไทย中华Việt Nam");
}
  136. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5849:29

    identifier `abcประเทศไทย中华Việt` mixes scripts: Latin + Other + Han (in string/comment) (raw pass, confidence 0.40)

        s += "ประเทศไทย中华Việt Nam";
    assert_eq!(s.as_str(), "abcประเทศไทย中华Việt Nam");
}
  137. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5854:34

    identifier `ประเทศไทย中` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

    fn test_push() {
    let mut data = String::from("ประเทศไทย中");
    data.push('华');
    data.push('b'); // 1 byte
  138. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5860:23

    identifier `ประเทศไทย中华b` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

        data.push('𤭢'); // 4 byte
    assert_eq!(data, "ประเทศไทย中华b¢€𤭢");
}
  139. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5865:34

    identifier `ประเทศไทย中华b` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_pop() {
    let mut data = String::from("ประเทศไทย中华b¢€𤭢");
    assert_eq!(data.pop().unwrap(), '𤭢'); // 4 bytes
    assert_eq!(data.pop().unwrap(), '€'); // 3 bytes
  140. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5871:23

    identifier `ประเทศไทย中` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

        assert_eq!(data.pop().unwrap(), '华');
    assert_eq!(data, "ประเทศไทย中");
}
  141. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5968:18

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn remove() {
    let mut s = "ศไทย中华Việt Nam; foobar".to_string();
    assert_eq!(s.remove(0), 'ศ');
    assert_eq!(s.len(), 33);
  142. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5971:20

    identifier `ไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

        assert_eq!(s.len(), 33);
    assert_eq!(s, "ไทย中华Việt Nam; foobar");
    assert_eq!(s.remove(17), 'ệ');
    assert_eq!(s, "ไทย中华Vit Nam; foobar");
  143. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5973:20

    identifier `ไทย中华Vit` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

        assert_eq!(s.remove(17), 'ệ');
    assert_eq!(s, "ไทย中华Vit Nam; foobar");
}
  144. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5996:18

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    
    let mut s = "ศไทย中华Việt Nam; foobarศ".to_string();
    s.remove_matches('ศ');
    assert_eq!(s, "ไทย中华Việt Nam; foobar");
  145. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5996:48

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

    
    let mut s = "ศไทย中华Việt Nam; foobarศ".to_string();
    s.remove_matches('ศ');
    assert_eq!(s, "ไทย中华Việt Nam; foobar");
  146. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5998:20

    identifier `ไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

        s.remove_matches('ศ');
    assert_eq!(s, "ไทย中华Việt Nam; foobar");

    let mut s = "".to_string();
  147. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:6022:24

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

    
    s.retain(|c| c == 'α');
    assert_eq!(s, "α");
  148. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:6023:20

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

        s.retain(|c| c == 'α');
    assert_eq!(s, "α");

    s.retain(|_| false);
  149. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:6049:20

    identifier `ệfooยbar` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

        s.insert(6, 'ย');
    assert_eq!(s, "ệfooยbar");
}
  150. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:6094:14

    identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    fn test_from_iterator() {
    let s = "ศไทย中华Việt Nam".to_string();
    let t = "ศไทย中华";
    let u = "Việt Nam";
  151. info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:6095:14

    identifier `ศไทย中华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

        let s = "ศไทย中华Việt Nam".to_string();
    let t = "ศไทย中华";
    let u = "Việt Nam";
  152. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:17725:35

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

        /// ```
    /// let mut s = String::from("α is alpha, β is beta");
    /// let beta_offset = s.find('β').unwrap_or(s.len());
    ///
  153. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:17730:24

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

        /// let t: String = s.drain(..beta_offset).collect();
    /// assert_eq!(t, "α is alpha, ");
    /// assert_eq!(s, "β is beta");
    ///
  154. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:17775:35

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

        /// ```
    /// let mut s = String::from("α is alpha, β is beta");
    /// let beta_offset = s.find('β').unwrap_or(s.len());
    ///
  155. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:17779:41

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

        /// // Replace the range up until the β from the string
    /// s.replace_range(..beta_offset, "Α is capital alpha; ");
    /// assert_eq!(s, "Α is capital alpha; β is beta");
    /// ```
  156. info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:17780:24

    identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

        /// s.replace_range(..beta_offset, "Α is capital alpha; ");
    /// assert_eq!(s, "Α is capital alpha; β is beta");
    /// ```
    #[stable(feature = "splice", since = "1.27.0")]
  157. info warn → info by review unicode-homoglyph benchmarks/haystacks/opensubtitles/ru-huge.txt:5057:4

    identifier `Боr` contains homoglyph candidates: о (043E)→o (raw pass, confidence 0.70)

    — Не думаешь стал быть — Стал-быть так.
А Боr?
Ты гляди...
не чужого вскармливаешь
    likely benign LLM, confidence 0.93 A Russian subtitle line containing a Cyrillic/Latin mixed word 'Боr'.
    Reasoning

    Mixed Cyrillic 'о' with Latin 'r' in a Russian subtitle line ('Боr'), most likely a transcription/typo artifact in a subtitle corpus, not code. Benign text in a benchmark haystack.

  158. info warn → info by review unicode-mixed-script benchmarks/haystacks/opensubtitles/ru-huge.txt:5057:4

    identifier `Боr` mixes scripts: Cyrillic + Latin (raw pass, confidence 0.80)

    — Не думаешь стал быть — Стал-быть так.
А Боr?
Ты гляди...
не чужого вскармливаешь
    likely benign LLM, confidence 0.93 Mixed Cyrillic and Latin script in the same subtitle word 'Боr'.
    Reasoning

    Same mixed-script token in a plain-text Russian subtitle file; a stray Latin character in dialogue is a corpus artifact, not an identifier used for evasion.

  159. info warn → info by review narrow-file-charset benchmarks/haystacks/opensubtitles/ru-medium.txt:1:1

    file uses only 6 distinct printable characters ("!,-.:?") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)

    -Две недели не даешь мне прохода.
Вот и действуй, чем ты рискуешь?
Я думал, что сделаю тебя счастливой.
    dismissed LLM, confidence 0.95 Russian subtitle dialogue flagged for a narrow character set.
    Reasoning

    The snippet is ordinary Russian dialogue with punctuation; a small character set is just a consequence of the short punctuation alphabet in a prose subtitle file, not obfuscation.

  160. info warn → info by review long-line benchmarks/haystacks/pathological/defeat-simple-vector-freq.txt:1:1

    line length 720056 characters (raw pass, confidence 0.65)

    qjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjaz
    dismissed LLM, confidence 0.95 A synthetic benchmark haystack with a very long repeated line.
    Reasoning

    This is a deliberately pathological benchmark file built to defeat frequency-based detectors; it is a test input, not a live attack payload.

  161. info warn → info by review narrow-file-charset benchmarks/haystacks/pathological/defeat-simple-vector-freq.txt:1:1

    file uses only 4 distinct printable characters ("ajqz") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)

    qjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjaz
    dismissed LLM, confidence 0.95 Synthetic repeated four-character pattern in a benchmark file.
    Reasoning

    Synthetic benchmark file of repeated characters designed to test the scanner's charset heuristic; no executable content.

  162. info warn → info by review long-line benchmarks/haystacks/pathological/defeat-simple-vector-repeated.txt:1:1

    line length 720056 characters (raw pass, confidence 0.65)

    zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
    dismissed LLM, confidence 0.95 Synthetic long repeated-character line in a benchmark file.
    Reasoning

    Benchmark haystack of repeated characters intentionally made to stress the long-line check; not a payload.

  163. info warn → info by review narrow-file-charset benchmarks/haystacks/pathological/defeat-simple-vector-repeated.txt:1:1

    file uses only 2 distinct printable characters ("az") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)

    zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
    dismissed LLM, confidence 0.95 Synthetic two-character filler in a benchmark file.
    Reasoning

    Repeated 'z' and 'a' filler in a pathological test haystack; intended test data.

  164. info warn → info by review narrow-file-charset benchmarks/haystacks/pathological/defeat-simple-vector.txt:1:1

    file uses only 4 distinct printable characters ("abqz") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)

    qazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqaz
qazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqaz
qazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqaz
    dismissed LLM, confidence 0.95 Synthetic repeated 'qaz' filler in a benchmark file.
    Reasoning

    Repeating 'qaz' pattern in a benchmark haystack purposely constructed to defeat simple vector detection; not executable.

  165. info warn → info by review long-line benchmarks/haystacks/pathological/repeated-rare-huge.txt:1:1

    line length 500100 characters (raw pass, confidence 0.65)

    zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
    dismissed LLM, confidence 0.95 Synthetic single-character long line in a benchmark file.
    Reasoning

    A benchmark file of a single repeated character, clearly a synthetic stress test for the long-line detector.

  166. info warn → info by review narrow-file-charset benchmarks/haystacks/pathological/repeated-rare-huge.txt:1:1

    file uses only 1 distinct printable characters ("z") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)

    zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
    dismissed LLM, confidence 0.95 Synthetic single-character filler in a benchmark file.
    Reasoning

    Single-character repetition in a pathological benchmark haystack; no obfuscation payload present.

  167. info long-line benchmarks/haystacks/pathological/repeated-rare-small.txt:1:1

    line length 1000 characters (raw pass, confidence 0.50)

    zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
  168. info warn → info by review narrow-file-charset benchmarks/haystacks/pathological/repeated-rare-small.txt:1:1

    file uses only 1 distinct printable characters ("z") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)

    zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
    likely benign LLM, confidence 0.95 Benchmark haystack consisting of repeated 'z' characters.
    Reasoning

    A long run of a single repeated character in a benchmark haystack file is a test fixture for pathological input, not JSFuck-style obfuscation; there is no executable context.

  169. info warn → info by review encoding-base64 benchmarks/haystacks/sliceslice/haystack.txt:1:1

    base64-like blob (1000 bytes, compression ratio 0.78) (raw pass, confidence 0.60)

    I4BCeTWkpm1G1StV1WP8HKMX1IaRTslq88MOEg4nx7kWLaWYDRDYZrdTtsg26mz9S8DhYcd1ty35aPLyRZSeimOmPAroaqi861z44o35qP9GdrofuuHwdhSEeOg7E0L1KrTYgWZZrzyk7o0DVxw7vvmo6rVJ5T4lLMkesL1U6ObckS9oorPI5ZDm4Nk1ryh3AC8juZwJLcyWKveenfaVGaB42iYrOvrZGIMQG0OmA0k73ydw2mJawUzWE8O61MQpDm19JFaTgSJMkPs3yjY149knHg03uOBvb6d0hCmUbiHkRgFwH17cL7UJUlkggx55
    likely benign LLM, confidence 0.93 Random base64-like text in a benchmark haystack file.
    Reasoning

    The file is a benchmark haystack of random-looking text used to test string search; base64-like content in a test corpus is expected and not a payload being decoded or executed.

  170. info long-line benchmarks/haystacks/sliceslice/haystack.txt:1:1

    line length 1000 characters (raw pass, confidence 0.50)

    I4BCeTWkpm1G1StV1WP8HKMX1IaRTslq88MOEg4nx7kWLaWYDRDYZrdTtsg26mz9S8DhYcd1ty35aPLyRZSeimOmPAroaqi861z44o35qP9GdrofuuHwdhSEeOg7E0L1KrTYgWZZrzyk7o0DVxw7vvmo6rVJ5T4lLMkesL1U6ObckS9oorPI5ZDm4Nk1ryh3AC8juZwJLcyWKveenfaVGaB42iYrOvrZGIMQG0OmA0k73ydw2mJawUzWE8O61MQpDm19JFaTgSJMkPs3yjY149knHg03uOBvb6d0hCmUbiHkRgFwH17cL7UJUlkggx55
  171. info warn → info by review unicode-mixed-script benchmarks/haystacks/sliceslice/i386.txt:7496:23

    identifier `ĺͻ` mixes scripts: Latin + Greek (raw pass, confidence 0.80)

                                                 INTERNAL REGISTER 
           Ķ         ĺͻ 
                                                             
           Ķ         ĺͼ
    likely benign LLM, confidence 0.93 Greek and Latin characters in a documentation text table of i386 registers.
    Reasoning

    This is an Intel i386 manual text dump where Greek-looking glyphs are table/box-drawing or math symbols in a plain-text document, not identifiers in code. Raw-pass unicode findings in prose documents are high false-positive.

  172. info warn → info by review unicode-mixed-script benchmarks/haystacks/sliceslice/i386.txt:7498:23

    identifier `ĺͼ` mixes scripts: Latin + Greek (raw pass, confidence 0.80)

                                                                 
           Ķ         ĺͼ 
                                            ͼ
    likely benign LLM, confidence 0.93 Mixed-script symbols in an i386 documentation table.
    Reasoning

    Same i386 reference document with table characters; no code execution or identifier context, so the mixed-script flag reflects document glyphs rather than homoglyph obfuscation.

  173. info warn → info by review unicode-mixed-script benchmarks/haystacks/sliceslice/i386.txt:7506:23

    identifier `ĺͻ` mixes scripts: Latin + Greek (raw pass, confidence 0.80)

                                                 INTERNAL REGISTER 
           Ķ         ĺͻ 
                                                             
           Ķ         ĺͼ
    likely benign LLM, confidence 0.93 Mixed-script table glyphs in an i386 documentation text file.
    Reasoning

    Repeats the same pattern in the same plain-text documentation file; the flagged characters are table glyphs, not code identifiers.

  174. info warn → info by review unicode-mixed-script benchmarks/haystacks/sliceslice/i386.txt:7508:23

    identifier `ĺͼ` mixes scripts: Latin + Greek (raw pass, confidence 0.80)

                                                                 
           Ķ         ĺͼ 
                                            ͼ
           ͼ
    likely benign LLM, confidence 0.93 Mixed-script table glyphs in an i386 documentation text file.
    Reasoning

    Same documentation file and glyph pattern; no programming construct is present, so this is a false positive.

Reproduce This Scan

Run disclude locally to verify. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.

cargo install disclude --version 4.1.0
git clone https://github.com/BurntSushi/memchr memchr && cd memchr
git checkout 2.8.3
disclude scan --severity info --diff 2.8.2 .