Resolve unnested_or_patterns pedantic clippy lint

    warning: unnested or-patterns
       --> src/parse.rs:387:17
        |
    387 | /                 Some((_, 'n')) | Some((_, 'r')) | Some((_, 't')) | Some((_, '\\'))
    388 | |                 | Some((_, '\'')) | Some((_, '"')) | Some((_, '0')) => {}
        | |___________________________________________________________________^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns
    help: nest the patterns
        |
    387 |                 Some((_, 'n' | 'r' | 't' | '\\' | '\'' | '"' | '0')) => {}
        |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    warning: unnested or-patterns
       --> src/parse.rs:392:17
        |
    392 |                 Some((newline, ch @ '\n')) | Some((newline, ch @ '\r')) => {
        |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns
    help: nest the patterns
        |
    392 |                 Some((newline, ch @ ('\n' | '\r'))) => {
        |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    warning: unnested or-patterns
       --> src/parse.rs:450:17
        |
    450 | /                 Some((_, b'n')) | Some((_, b'r')) | Some((_, b't')) | Some((_, b'\\'))
    451 | |                 | Some((_, b'0')) | Some((_, b'\'')) | Some((_, b'"')) => {}
        | |______________________________________________________________________^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns
    help: nest the patterns
        |
    450 |                 Some((_, b'n' | b'r' | b't' | b'\\' | b'0' | b'\'' | b'"')) => {}
        |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    warning: unnested or-patterns
       --> src/parse.rs:452:17
        |
    452 |                 Some((newline, b @ b'\n')) | Some((newline, b @ b'\r')) => {
        |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns
    help: nest the patterns
        |
    452 |                 Some((newline, b @ (b'\n' | b'\r'))) => {
        |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    warning: unnested or-patterns
       --> src/parse.rs:553:17
        |
    553 | /                 Some((_, 'n')) | Some((_, 'r')) | Some((_, 't')) | Some((_, '\\'))
    554 | |                 | Some((_, '\'')) | Some((_, '"')) => {}
        | |__________________________________________________^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns
    help: nest the patterns
        |
    553 |                 Some((_, 'n' | 'r' | 't' | '\\' | '\'' | '"')) => {}
        |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    warning: unnested or-patterns
       --> src/parse.rs:560:17
        |
    560 |                 Some((newline, ch @ '\n')) | Some((newline, ch @ '\r')) => {
        |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns
    help: nest the patterns
        |
    560 |                 Some((newline, ch @ ('\n' | '\r'))) => {
        |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    warning: unnested or-patterns
       --> src/parse.rs:580:13
        |
    580 | /             Some(b'n') | Some(b'r') | Some(b't') | Some(b'\\') | Some(b'0') | Some(b'\'')
    581 | |             | Some(b'"') => true,
        | |________________________^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns
    help: nest the patterns
        |
    580 |             Some(b'n' | b'r' | b't' | b'\\' | b'0' | b'\'' | b'"') => true,
        |             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    warning: unnested or-patterns
       --> src/parse.rs:604:13
        |
    604 |             Some('n') | Some('r') | Some('t') | Some('\\') | Some('0') | Some('\'') | Some('"') => {
        |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns
    help: nest the patterns
        |
    604 |             Some('n' | 'r' | 't' | '\\' | '0' | '\'' | '"') => {
        |             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    warning: unnested or-patterns
       --> src/parse.rs:695:13
        |
    695 | /             Some((_, b @ b' ')) | Some((_, b @ b'\t')) | Some((_, b @ b'\n'))
    696 | |             | Some((_, b @ b'\r')) => {
        | |__________________________________^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns
    help: nest the patterns
        |
    695 |             Some((_, b @ (b' ' | b'\t' | b'\n' | b'\r'))) => {
        |             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Author: dtolnay

src/parse.rs

@@ -384,12 +384,11 @@ fn cooked_string(mut input: Cursor) -> Result<Cursor, Reject> {
                 Some((_, 'x')) => {
                     backslash_x_char(&mut chars)?;
                 }
-                Some((_, 'n')) | Some((_, 'r')) | Some((_, 't')) | Some((_, '\\'))
-                | Some((_, '\'')) | Some((_, '"')) | Some((_, '0')) => {}
+                Some((_, 'n' | 'r' | 't' | '\\' | '\'' | '"' | '0')) => {}
                 Some((_, 'u')) => {
                     backslash_u(&mut chars)?;
                 }
-                Some((newline, ch @ '\n')) | Some((newline, ch @ '\r')) => {
+                Some((newline, ch @ ('\n' | '\r'))) => {
                     input = input.advance(newline + 1);
                     trailing_backslash(&mut input, ch as u8)?;
                     chars = input.char_indices();
@@ -447,9 +446,8 @@ fn cooked_byte_string(mut input: Cursor) -> Result<Cursor, Reject> {
                 Some((_, b'x')) => {
                     backslash_x_byte(&mut bytes)?;
                 }
-                Some((_, b'n')) | Some((_, b'r')) | Some((_, b't')) | Some((_, b'\\'))
-                | Some((_, b'0')) | Some((_, b'\'')) | Some((_, b'"')) => {}
-                Some((newline, b @ b'\n')) | Some((newline, b @ b'\r')) => {
+                Some((_, b'n' | b'r' | b't' | b'\\' | b'0' | b'\'' | b'"')) => {}
+                Some((newline, b @ (b'\n' | b'\r'))) => {
                     input = input.advance(newline + 1);
                     trailing_backslash(&mut input, b)?;
                     bytes = input.bytes().enumerate();
@@ -550,14 +548,13 @@ fn cooked_c_string(mut input: Cursor) -> Result<Cursor, Reject> {
                 Some((_, 'x')) => {
                     backslash_x_nonzero(&mut chars)?;
                 }
-                Some((_, 'n')) | Some((_, 'r')) | Some((_, 't')) | Some((_, '\\'))
-                | Some((_, '\'')) | Some((_, '"')) => {}
+                Some((_, 'n' | 'r' | 't' | '\\' | '\'' | '"')) => {}
                 Some((_, 'u')) => {
                     if backslash_u(&mut chars)? == '\0' {
                         break;
                     }
                 }
-                Some((newline, ch @ '\n')) | Some((newline, ch @ '\r')) => {
+                Some((newline, ch @ ('\n' | '\r'))) => {
                     input = input.advance(newline + 1);
                     trailing_backslash(&mut input, ch as u8)?;
                     chars = input.char_indices();
@@ -577,8 +574,7 @@ fn byte(input: Cursor) -> Result<Cursor, Reject> {
     let ok = match bytes.next().map(|(_, b)| b) {
         Some(b'\\') => match bytes.next().map(|(_, b)| b) {
             Some(b'x') => backslash_x_byte(&mut bytes).is_ok(),
-            Some(b'n') | Some(b'r') | Some(b't') | Some(b'\\') | Some(b'0') | Some(b'\'')
-            | Some(b'"') => true,
+            Some(b'n' | b'r' | b't' | b'\\' | b'0' | b'\'' | b'"') => true,
             _ => false,
         },
         b => b.is_some(),
@@ -601,9 +597,7 @@ fn character(input: Cursor) -> Result<Cursor, Reject> {
         Some('\\') => match chars.next().map(|(_, ch)| ch) {
             Some('x') => backslash_x_char(&mut chars).is_ok(),
             Some('u') => backslash_u(&mut chars).is_ok(),
-            Some('n') | Some('r') | Some('t') | Some('\\') | Some('0') | Some('\'') | Some('"') => {
-                true
-            }
+            Some('n' | 'r' | 't' | '\\' | '0' | '\'' | '"') => true,
             _ => false,
         },
         ch => ch.is_some(),
@@ -692,8 +686,7 @@ fn trailing_backslash(input: &mut Cursor, mut last: u8) -> Result<(), Reject> {
             return Err(Reject);
         }
         match whitespace.next() {
-            Some((_, b @ b' ')) | Some((_, b @ b'\t')) | Some((_, b @ b'\n'))
-            | Some((_, b @ b'\r')) => {
+            Some((_, b @ (b' ' | b'\t' | b'\n' | b'\r'))) => {
                 last = b;
             }
             Some((offset, _)) => {