nom 8.0.0

Source: https://github.com/rust-bakery/nom
Artifact scanned: nom-8.0.0.crate (crate · 132.4 KB · SHA-256 df9761775871…)
Compared with: nom-7.1.3.crate (4 signals introduced since)
Files: 47 scanned, 6 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 45 info
Scan time: 0.3 s
LLM review: LLM review by claude-haiku-5-5 (Anthropic): nothing at warn or critical to review.
Disclude version: 4.3.0
Scanned (UTC): 2026-10-24 07:24

Signals

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

info encoding-hex src/number/mod.rs:215:26 new in this release

16 consecutive `\xNN` escapes (entropy 4.0 bits/byte) (in comment) (raw pass, confidence 0.39)

///
/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..]), Ok((&b"abcd"[..], 0x00010203040506070809101112131415)));
/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(15))));
/// ```

info encoding-hex src/number/mod.rs:337:32 new in this release

16 consecutive `\xNN` escapes (entropy 4.0 bits/byte) (in comment) (raw pass, confidence 0.39)

///
/// assert_eq!(parser.parse(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..]), Ok((&b"abcd"[..], 0x00010203040506070809101112131415)));
/// assert_eq!(parser.parse(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(15))));
/// ```

info encoding-hex src/number/mod.rs:522:26 new in this release

16 consecutive `\xNN` escapes (entropy 4.0 bits/byte) (in comment) (raw pass, confidence 0.39)

///
/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..]), Ok((&b"abcd"[..], 0x15141312111009080706050403020100)));
/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(15))));
/// ```

info encoding-hex src/number/mod.rs:653:26 new in this release

16 consecutive `\xNN` escapes (entropy 4.0 bits/byte) (in comment) (raw pass, confidence 0.39)

///
/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..]), Ok((&b"abcd"[..], 0x15141312111009080706050403020100)));
/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(15))));
/// ```

info unicode-mixed-script src/character/complete.rs:1068:14

identifier `βèƒôřè` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
```
    let d = "βèƒôřè\nÂßÇáƒƭèř";
    assert_eq!(not_line_ending(d), Ok((&"\nÂßÇáƒƭèř"[..], &"βèƒôřè"[..])));
```

info unicode-mixed-script src/character/complete.rs:1069:69

identifier `βèƒôřè` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    let d = "βèƒôřè\nÂßÇáƒƭèř";
    assert_eq!(not_line_ending(d), Ok((&"\nÂßÇáƒƭèř"[..], &"βèƒôřè"[..])));

    let e = "βèƒôřè\r\nÂßÇáƒƭèř";

info unicode-mixed-script src/character/complete.rs:1071:14

identifier `βèƒôřè` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)


    let e = "βèƒôřè\r\nÂßÇáƒƭèř";
    assert_eq!(not_line_ending(e), Ok((&"\r\nÂßÇáƒƭèř"[..], &"βèƒôřè"[..])));
    */

info unicode-mixed-script src/character/complete.rs:1072:71

identifier `βèƒôřè` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    let e = "βèƒôřè\r\nÂßÇáƒƭèř";
    assert_eq!(not_line_ending(e), Ok((&"\r\nÂßÇáƒƭèř"[..], &"βèƒôřè"[..])));
    */

info unicode-mixed-script src/character/complete.rs:1075:14

identifier `βèƒôřè` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
```
    let f = "βèƒôřè\rÂßÇáƒƭèř";
    assert_eq!(not_line_ending(f), Err(Err::Error((f, ErrorKind::Tag))));
```
info unicode-mixed-script src/character/streaming.rs:1029:14

identifier `βèƒôřè` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
```
    let d = "βèƒôřè\nÂßÇáƒƭèř";
    assert_eq!(not_line_ending(d), Ok((&"\nÂßÇáƒƭèř"[..], &"βèƒôřè"[..])));
```

info unicode-mixed-script src/character/streaming.rs:1030:69

identifier `βèƒôřè` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    let d = "βèƒôřè\nÂßÇáƒƭèř";
    assert_eq!(not_line_ending(d), Ok((&"\nÂßÇáƒƭèř"[..], &"βèƒôřè"[..])));

    let e = "βèƒôřè\r\nÂßÇáƒƭèř";

info unicode-mixed-script src/character/streaming.rs:1032:14

identifier `βèƒôřè` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)


    let e = "βèƒôřè\r\nÂßÇáƒƭèř";
    assert_eq!(not_line_ending(e), Ok((&"\r\nÂßÇáƒƭèř"[..], &"βèƒôřè"[..])));
    */

info unicode-mixed-script src/character/streaming.rs:1033:71

identifier `βèƒôřè` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    let e = "βèƒôřè\r\nÂßÇáƒƭèř";
    assert_eq!(not_line_ending(e), Ok((&"\r\nÂßÇáƒƭèř"[..], &"βèƒôřè"[..])));
    */

info unicode-mixed-script src/character/streaming.rs:1036:14

identifier `βèƒôřè` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
```
    let f = "βèƒôřè\rÂßÇáƒƭèř";
    assert_eq!(not_line_ending(f), Err(Err::Error((f, ErrorKind::Tag))));
```

info encoding-hex src/number/streaming.rs:138:26

16 consecutive `\xNN` escapes (entropy 4.0 bits/byte) (in comment) (raw pass, confidence 0.39)

///
/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..]), Ok((&b"abcd"[..], 0x00010203040506070809101112131415)));
/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(15))));
/// ```

info encoding-hex src/number/streaming.rs:277:26

16 consecutive `\xNN` escapes (entropy 4.0 bits/byte) (in comment) (raw pass, confidence 0.39)

///
/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..]), Ok((&b"abcd"[..], 0x00010203040506070809101112131415)));
/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(15))));
/// ```

info encoding-hex src/number/streaming.rs:412:26

16 consecutive `\xNN` escapes (entropy 4.0 bits/byte) (in comment) (raw pass, confidence 0.39)

///
/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..]), Ok((&b"abcd"[..], 0x15141312111009080706050403020100)));
/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(15))));
/// ```

info encoding-hex src/number/streaming.rs:565:26

16 consecutive `\xNN` escapes (entropy 4.0 bits/byte) (in comment) (raw pass, confidence 0.39)

///
/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..]), Ok((&b"abcd"[..], 0x15141312111009080706050403020100)));
/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Incomplete(Needed::new(15))));
/// ```

info unicode-mixed-script src/str.rs:77:26

identifier `βèƒôřèÂßÇáƒƭèř` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

  fn take_s_succeed() {
    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const CONSUMED: &str = "βèƒôřèÂßÇ";
    const LEFTOVER: &str = "áƒƭèř";

info unicode-mixed-script src/str.rs:78:29

identifier `βèƒôřèÂßÇ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const CONSUMED: &str = "βèƒôřèÂßÇ";
    const LEFTOVER: &str = "áƒƭèř";

info unicode-mixed-script src/str.rs:106:26

identifier `βèƒôřèÂßÇ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

  fn take_until_succeed() {
    const INPUT: &str = "βèƒôřèÂßÇ∂áƒƭèř";
    const FIND: &str = "ÂßÇ∂";
    const CONSUMED: &str = "βèƒôřè";

info unicode-mixed-script src/str.rs:108:29

identifier `βèƒôřè` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    const FIND: &str = "ÂßÇ∂";
    const CONSUMED: &str = "βèƒôřè";
    const LEFTOVER: &str = "ÂßÇ∂áƒƭèř";

info unicode-mixed-script src/str.rs:140:26

identifier `βèƒôřèÂßÇá` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
```
    const INPUT: &str = "βèƒôřèÂßÇá";

    let res: IResult<_, _, (_, ErrorKind)> = take(13_usize)(INPUT);
```

info unicode-mixed-script src/str.rs:200:26

identifier `βèƒôřèÂßÇáƒƭèř` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

  fn take_till_s_succeed() {
    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const CONSUMED: &str = "βèƒôřèÂßÇ";
    const LEFTOVER: &str = "áƒƭèř";

info unicode-mixed-script src/str.rs:201:29

identifier `βèƒôřèÂßÇ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const CONSUMED: &str = "βèƒôřèÂßÇ";
    const LEFTOVER: &str = "áƒƭèř";
    fn till_s(c: char) -> bool {

info unicode-mixed-script src/str.rs:235:26

identifier `βèƒôřèÂßÇáƒƭèř` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)


    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const CONSUMED: &str = "";
    const LEFTOVER: &str = "βèƒôřèÂßÇáƒƭèř";

info unicode-mixed-script src/str.rs:237:29

identifier `βèƒôřèÂßÇáƒƭèř` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    const CONSUMED: &str = "";
    const LEFTOVER: &str = "βèƒôřèÂßÇáƒƭèř";
    fn while_s(c: char) -> bool {
      c == '9'

info unicode-mixed-script src/str.rs:268:26

identifier `βèƒôřèÂßÇáƒƭèř` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

  fn is_not_succeed() {
    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const AVOID: &str = "£úçƙ¥á";
    const CONSUMED: &str = "βèƒôřèÂßÇ";

info unicode-mixed-script src/str.rs:270:29

identifier `βèƒôřèÂßÇ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    const AVOID: &str = "£úçƙ¥á";
    const CONSUMED: &str = "βèƒôřèÂßÇ";
    const LEFTOVER: &str = "áƒƭèř";
    fn test(input: &str) -> IResult<&str, &str> {

info unicode-mixed-script src/str.rs:301:26

identifier `βèƒôřèÂßÇáƒƭèř` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)


    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const CONSUMED: &str = "βèƒôřèÂßÇ";
    const LEFTOVER: &str = "áƒƭèř";

info unicode-mixed-script src/str.rs:302:29

identifier `βèƒôřèÂßÇ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const CONSUMED: &str = "βèƒôřèÂßÇ";
    const LEFTOVER: &str = "áƒƭèř";
    fn while_s(c: char) -> bool {

info unicode-mixed-script src/str.rs:334:26

identifier `βèƒôřèÂßÇáƒƭèř` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

  fn is_not_fail() {
    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const AVOID: &str = "βúçƙ¥";
    fn test(input: &str) -> IResult<&str, &str> {

info unicode-mixed-script src/str.rs:335:26

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

    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const AVOID: &str = "βúçƙ¥";
    fn test(input: &str) -> IResult<&str, &str> {
      is_not(AVOID)(input)

info unicode-mixed-script src/str.rs:352:26

identifier `βèƒôřèÂßÇáƒƭèř` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)


    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const CONSUMED: &str = "βèƒôřèÂßÇ";
    const LEFTOVER: &str = "áƒƭèř";

info unicode-mixed-script src/str.rs:353:29

identifier `βèƒôřèÂßÇ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const CONSUMED: &str = "βèƒôřèÂßÇ";
    const LEFTOVER: &str = "áƒƭèř";
    fn while1_s(c: char) -> bool {

info unicode-mixed-script src/str.rs:387:26

identifier `βèƒôřè` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
```
    const INPUT: &str = "βèƒôřè";
    const FIND: &str = "βèƒôřèÂßÇ";
```

info unicode-mixed-script src/str.rs:388:25

identifier `βèƒôřèÂßÇ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    const INPUT: &str = "βèƒôřè";
    const FIND: &str = "βèƒôřèÂßÇ";

    let res: IResult<_, _, (_, ErrorKind)> = take_until(FIND)(INPUT);

info unicode-mixed-script src/str.rs:403:26

identifier `βèƒôřèÂßÇáƒƭèř` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

  fn is_a_succeed() {
    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const MATCH: &str = "βèƒôřèÂßÇ";
    const CONSUMED: &str = "βèƒôřèÂßÇ";

info unicode-mixed-script src/str.rs:404:26

identifier `βèƒôřèÂßÇ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const MATCH: &str = "βèƒôřèÂßÇ";
    const CONSUMED: &str = "βèƒôřèÂßÇ";
    const LEFTOVER: &str = "áƒƭèř";

info unicode-mixed-script src/str.rs:405:29

identifier `βèƒôřèÂßÇ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    const MATCH: &str = "βèƒôřèÂßÇ";
    const CONSUMED: &str = "βèƒôřèÂßÇ";
    const LEFTOVER: &str = "áƒƭèř";
    fn test(input: &str) -> IResult<&str, &str> {

info unicode-mixed-script src/str.rs:436:26

identifier `βèƒôřèÂßÇáƒƭèř` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
```
    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    fn while1_s(c: char) -> bool {
      c == '9'
```

info unicode-mixed-script src/str.rs:455:26

identifier `βèƒôřèÂßÇáƒƭèř` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

  fn is_a_fail() {
    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const MATCH: &str = "Ûñℓúçƙ¥";
    fn test(input: &str) -> IResult<&str, &str> {

info unicode-mixed-script src/str.rs:456:26

identifier `Ûñℓúçƙ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const MATCH: &str = "Ûñℓúçƙ¥";
    fn test(input: &str) -> IResult<&str, &str> {
      is_a(MATCH)(input)

info unicode-mixed-script src/str.rs:473:26

identifier `βèƒôřèÂßÇáƒƭèř` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
```
    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const FIND: &str = "Ráñδô₥";
```

info unicode-mixed-script src/str.rs:474:25

identifier `Ráñδô` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

    const INPUT: &str = "βèƒôřèÂßÇáƒƭèř";
    const FIND: &str = "Ráñδô₥";

    let res: IResult<_, _, (_, ErrorKind)> = take_until(FIND)(INPUT);

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 nom-8.0.0.crate 'https://static.crates.io/crates/nom/nom-8%2E0%2E0.crate'
printf '%s  %s\n' df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405 nom-8.0.0.crate | shasum -a 256 -c -
mkdir pkg && tar -xzf nom-8.0.0.crate -C pkg --strip-components 1
disclude scan --untrusted --severity info pkg